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_add_drive_ro (PyObject *self, PyObject *args)
1183 {
1184   PyObject *py_g;
1185   guestfs_h *g;
1186   PyObject *py_r;
1187   int r;
1188   const char *filename;
1189
1190   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive_ro",
1191                          &py_g, &filename))
1192     return NULL;
1193   g = get_handle (py_g);
1194
1195   r = guestfs_add_drive_ro (g, filename);
1196   if (r == -1) {
1197     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1198     return NULL;
1199   }
1200
1201   Py_INCREF (Py_None);
1202   py_r = Py_None;
1203   return py_r;
1204 }
1205
1206 static PyObject *
1207 py_guestfs_config (PyObject *self, PyObject *args)
1208 {
1209   PyObject *py_g;
1210   guestfs_h *g;
1211   PyObject *py_r;
1212   int r;
1213   const char *qemuparam;
1214   const char *qemuvalue;
1215
1216   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config",
1217                          &py_g, &qemuparam, &qemuvalue))
1218     return NULL;
1219   g = get_handle (py_g);
1220
1221   r = guestfs_config (g, qemuparam, qemuvalue);
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_set_qemu (PyObject *self, PyObject *args)
1234 {
1235   PyObject *py_g;
1236   guestfs_h *g;
1237   PyObject *py_r;
1238   int r;
1239   const char *qemu;
1240
1241   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_qemu",
1242                          &py_g, &qemu))
1243     return NULL;
1244   g = get_handle (py_g);
1245
1246   r = guestfs_set_qemu (g, qemu);
1247   if (r == -1) {
1248     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1249     return NULL;
1250   }
1251
1252   Py_INCREF (Py_None);
1253   py_r = Py_None;
1254   return py_r;
1255 }
1256
1257 static PyObject *
1258 py_guestfs_get_qemu (PyObject *self, PyObject *args)
1259 {
1260   PyObject *py_g;
1261   guestfs_h *g;
1262   PyObject *py_r;
1263   const char *r;
1264
1265   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_qemu",
1266                          &py_g))
1267     return NULL;
1268   g = get_handle (py_g);
1269
1270   r = guestfs_get_qemu (g);
1271   if (r == NULL) {
1272     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1273     return NULL;
1274   }
1275
1276   py_r = PyString_FromString (r);
1277   return py_r;
1278 }
1279
1280 static PyObject *
1281 py_guestfs_set_path (PyObject *self, PyObject *args)
1282 {
1283   PyObject *py_g;
1284   guestfs_h *g;
1285   PyObject *py_r;
1286   int r;
1287   const char *path;
1288
1289   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
1290                          &py_g, &path))
1291     return NULL;
1292   g = get_handle (py_g);
1293
1294   r = guestfs_set_path (g, path);
1295   if (r == -1) {
1296     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1297     return NULL;
1298   }
1299
1300   Py_INCREF (Py_None);
1301   py_r = Py_None;
1302   return py_r;
1303 }
1304
1305 static PyObject *
1306 py_guestfs_get_path (PyObject *self, PyObject *args)
1307 {
1308   PyObject *py_g;
1309   guestfs_h *g;
1310   PyObject *py_r;
1311   const char *r;
1312
1313   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
1314                          &py_g))
1315     return NULL;
1316   g = get_handle (py_g);
1317
1318   r = guestfs_get_path (g);
1319   if (r == NULL) {
1320     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1321     return NULL;
1322   }
1323
1324   py_r = PyString_FromString (r);
1325   return py_r;
1326 }
1327
1328 static PyObject *
1329 py_guestfs_set_append (PyObject *self, PyObject *args)
1330 {
1331   PyObject *py_g;
1332   guestfs_h *g;
1333   PyObject *py_r;
1334   int r;
1335   const char *append;
1336
1337   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_append",
1338                          &py_g, &append))
1339     return NULL;
1340   g = get_handle (py_g);
1341
1342   r = guestfs_set_append (g, append);
1343   if (r == -1) {
1344     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1345     return NULL;
1346   }
1347
1348   Py_INCREF (Py_None);
1349   py_r = Py_None;
1350   return py_r;
1351 }
1352
1353 static PyObject *
1354 py_guestfs_get_append (PyObject *self, PyObject *args)
1355 {
1356   PyObject *py_g;
1357   guestfs_h *g;
1358   PyObject *py_r;
1359   const char *r;
1360
1361   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_append",
1362                          &py_g))
1363     return NULL;
1364   g = get_handle (py_g);
1365
1366   r = guestfs_get_append (g);
1367   if (r == NULL) {
1368     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1369     return NULL;
1370   }
1371
1372   py_r = PyString_FromString (r);
1373   return py_r;
1374 }
1375
1376 static PyObject *
1377 py_guestfs_set_autosync (PyObject *self, PyObject *args)
1378 {
1379   PyObject *py_g;
1380   guestfs_h *g;
1381   PyObject *py_r;
1382   int r;
1383   int autosync;
1384
1385   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
1386                          &py_g, &autosync))
1387     return NULL;
1388   g = get_handle (py_g);
1389
1390   r = guestfs_set_autosync (g, autosync);
1391   if (r == -1) {
1392     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1393     return NULL;
1394   }
1395
1396   Py_INCREF (Py_None);
1397   py_r = Py_None;
1398   return py_r;
1399 }
1400
1401 static PyObject *
1402 py_guestfs_get_autosync (PyObject *self, PyObject *args)
1403 {
1404   PyObject *py_g;
1405   guestfs_h *g;
1406   PyObject *py_r;
1407   int r;
1408
1409   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
1410                          &py_g))
1411     return NULL;
1412   g = get_handle (py_g);
1413
1414   r = guestfs_get_autosync (g);
1415   if (r == -1) {
1416     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1417     return NULL;
1418   }
1419
1420   py_r = PyInt_FromLong ((long) r);
1421   return py_r;
1422 }
1423
1424 static PyObject *
1425 py_guestfs_set_verbose (PyObject *self, PyObject *args)
1426 {
1427   PyObject *py_g;
1428   guestfs_h *g;
1429   PyObject *py_r;
1430   int r;
1431   int verbose;
1432
1433   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
1434                          &py_g, &verbose))
1435     return NULL;
1436   g = get_handle (py_g);
1437
1438   r = guestfs_set_verbose (g, verbose);
1439   if (r == -1) {
1440     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1441     return NULL;
1442   }
1443
1444   Py_INCREF (Py_None);
1445   py_r = Py_None;
1446   return py_r;
1447 }
1448
1449 static PyObject *
1450 py_guestfs_get_verbose (PyObject *self, PyObject *args)
1451 {
1452   PyObject *py_g;
1453   guestfs_h *g;
1454   PyObject *py_r;
1455   int r;
1456
1457   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
1458                          &py_g))
1459     return NULL;
1460   g = get_handle (py_g);
1461
1462   r = guestfs_get_verbose (g);
1463   if (r == -1) {
1464     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1465     return NULL;
1466   }
1467
1468   py_r = PyInt_FromLong ((long) r);
1469   return py_r;
1470 }
1471
1472 static PyObject *
1473 py_guestfs_is_ready (PyObject *self, PyObject *args)
1474 {
1475   PyObject *py_g;
1476   guestfs_h *g;
1477   PyObject *py_r;
1478   int r;
1479
1480   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready",
1481                          &py_g))
1482     return NULL;
1483   g = get_handle (py_g);
1484
1485   r = guestfs_is_ready (g);
1486   if (r == -1) {
1487     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1488     return NULL;
1489   }
1490
1491   py_r = PyInt_FromLong ((long) r);
1492   return py_r;
1493 }
1494
1495 static PyObject *
1496 py_guestfs_is_config (PyObject *self, PyObject *args)
1497 {
1498   PyObject *py_g;
1499   guestfs_h *g;
1500   PyObject *py_r;
1501   int r;
1502
1503   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config",
1504                          &py_g))
1505     return NULL;
1506   g = get_handle (py_g);
1507
1508   r = guestfs_is_config (g);
1509   if (r == -1) {
1510     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1511     return NULL;
1512   }
1513
1514   py_r = PyInt_FromLong ((long) r);
1515   return py_r;
1516 }
1517
1518 static PyObject *
1519 py_guestfs_is_launching (PyObject *self, PyObject *args)
1520 {
1521   PyObject *py_g;
1522   guestfs_h *g;
1523   PyObject *py_r;
1524   int r;
1525
1526   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching",
1527                          &py_g))
1528     return NULL;
1529   g = get_handle (py_g);
1530
1531   r = guestfs_is_launching (g);
1532   if (r == -1) {
1533     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1534     return NULL;
1535   }
1536
1537   py_r = PyInt_FromLong ((long) r);
1538   return py_r;
1539 }
1540
1541 static PyObject *
1542 py_guestfs_is_busy (PyObject *self, PyObject *args)
1543 {
1544   PyObject *py_g;
1545   guestfs_h *g;
1546   PyObject *py_r;
1547   int r;
1548
1549   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy",
1550                          &py_g))
1551     return NULL;
1552   g = get_handle (py_g);
1553
1554   r = guestfs_is_busy (g);
1555   if (r == -1) {
1556     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1557     return NULL;
1558   }
1559
1560   py_r = PyInt_FromLong ((long) r);
1561   return py_r;
1562 }
1563
1564 static PyObject *
1565 py_guestfs_get_state (PyObject *self, PyObject *args)
1566 {
1567   PyObject *py_g;
1568   guestfs_h *g;
1569   PyObject *py_r;
1570   int r;
1571
1572   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state",
1573                          &py_g))
1574     return NULL;
1575   g = get_handle (py_g);
1576
1577   r = guestfs_get_state (g);
1578   if (r == -1) {
1579     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1580     return NULL;
1581   }
1582
1583   py_r = PyInt_FromLong ((long) r);
1584   return py_r;
1585 }
1586
1587 static PyObject *
1588 py_guestfs_set_busy (PyObject *self, PyObject *args)
1589 {
1590   PyObject *py_g;
1591   guestfs_h *g;
1592   PyObject *py_r;
1593   int r;
1594
1595   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy",
1596                          &py_g))
1597     return NULL;
1598   g = get_handle (py_g);
1599
1600   r = guestfs_set_busy (g);
1601   if (r == -1) {
1602     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1603     return NULL;
1604   }
1605
1606   Py_INCREF (Py_None);
1607   py_r = Py_None;
1608   return py_r;
1609 }
1610
1611 static PyObject *
1612 py_guestfs_set_ready (PyObject *self, PyObject *args)
1613 {
1614   PyObject *py_g;
1615   guestfs_h *g;
1616   PyObject *py_r;
1617   int r;
1618
1619   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_ready",
1620                          &py_g))
1621     return NULL;
1622   g = get_handle (py_g);
1623
1624   r = guestfs_set_ready (g);
1625   if (r == -1) {
1626     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1627     return NULL;
1628   }
1629
1630   Py_INCREF (Py_None);
1631   py_r = Py_None;
1632   return py_r;
1633 }
1634
1635 static PyObject *
1636 py_guestfs_end_busy (PyObject *self, PyObject *args)
1637 {
1638   PyObject *py_g;
1639   guestfs_h *g;
1640   PyObject *py_r;
1641   int r;
1642
1643   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_end_busy",
1644                          &py_g))
1645     return NULL;
1646   g = get_handle (py_g);
1647
1648   r = guestfs_end_busy (g);
1649   if (r == -1) {
1650     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1651     return NULL;
1652   }
1653
1654   Py_INCREF (Py_None);
1655   py_r = Py_None;
1656   return py_r;
1657 }
1658
1659 static PyObject *
1660 py_guestfs_mount (PyObject *self, PyObject *args)
1661 {
1662   PyObject *py_g;
1663   guestfs_h *g;
1664   PyObject *py_r;
1665   int r;
1666   const char *device;
1667   const char *mountpoint;
1668
1669   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
1670                          &py_g, &device, &mountpoint))
1671     return NULL;
1672   g = get_handle (py_g);
1673
1674   r = guestfs_mount (g, device, mountpoint);
1675   if (r == -1) {
1676     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1677     return NULL;
1678   }
1679
1680   Py_INCREF (Py_None);
1681   py_r = Py_None;
1682   return py_r;
1683 }
1684
1685 static PyObject *
1686 py_guestfs_sync (PyObject *self, PyObject *args)
1687 {
1688   PyObject *py_g;
1689   guestfs_h *g;
1690   PyObject *py_r;
1691   int r;
1692
1693   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
1694                          &py_g))
1695     return NULL;
1696   g = get_handle (py_g);
1697
1698   r = guestfs_sync (g);
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_touch (PyObject *self, PyObject *args)
1711 {
1712   PyObject *py_g;
1713   guestfs_h *g;
1714   PyObject *py_r;
1715   int r;
1716   const char *path;
1717
1718   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
1719                          &py_g, &path))
1720     return NULL;
1721   g = get_handle (py_g);
1722
1723   r = guestfs_touch (g, path);
1724   if (r == -1) {
1725     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1726     return NULL;
1727   }
1728
1729   Py_INCREF (Py_None);
1730   py_r = Py_None;
1731   return py_r;
1732 }
1733
1734 static PyObject *
1735 py_guestfs_cat (PyObject *self, PyObject *args)
1736 {
1737   PyObject *py_g;
1738   guestfs_h *g;
1739   PyObject *py_r;
1740   char *r;
1741   const char *path;
1742
1743   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
1744                          &py_g, &path))
1745     return NULL;
1746   g = get_handle (py_g);
1747
1748   r = guestfs_cat (g, path);
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_ll (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_ll",
1769                          &py_g, &directory))
1770     return NULL;
1771   g = get_handle (py_g);
1772
1773   r = guestfs_ll (g, directory);
1774   if (r == NULL) {
1775     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1776     return NULL;
1777   }
1778
1779   py_r = PyString_FromString (r);
1780   free (r);
1781   return py_r;
1782 }
1783
1784 static PyObject *
1785 py_guestfs_ls (PyObject *self, PyObject *args)
1786 {
1787   PyObject *py_g;
1788   guestfs_h *g;
1789   PyObject *py_r;
1790   char **r;
1791   const char *directory;
1792
1793   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
1794                          &py_g, &directory))
1795     return NULL;
1796   g = get_handle (py_g);
1797
1798   r = guestfs_ls (g, directory);
1799   if (r == NULL) {
1800     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1801     return NULL;
1802   }
1803
1804   py_r = put_string_list (r);
1805   free_strings (r);
1806   return py_r;
1807 }
1808
1809 static PyObject *
1810 py_guestfs_list_devices (PyObject *self, PyObject *args)
1811 {
1812   PyObject *py_g;
1813   guestfs_h *g;
1814   PyObject *py_r;
1815   char **r;
1816
1817   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
1818                          &py_g))
1819     return NULL;
1820   g = get_handle (py_g);
1821
1822   r = guestfs_list_devices (g);
1823   if (r == NULL) {
1824     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1825     return NULL;
1826   }
1827
1828   py_r = put_string_list (r);
1829   free_strings (r);
1830   return py_r;
1831 }
1832
1833 static PyObject *
1834 py_guestfs_list_partitions (PyObject *self, PyObject *args)
1835 {
1836   PyObject *py_g;
1837   guestfs_h *g;
1838   PyObject *py_r;
1839   char **r;
1840
1841   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
1842                          &py_g))
1843     return NULL;
1844   g = get_handle (py_g);
1845
1846   r = guestfs_list_partitions (g);
1847   if (r == NULL) {
1848     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1849     return NULL;
1850   }
1851
1852   py_r = put_string_list (r);
1853   free_strings (r);
1854   return py_r;
1855 }
1856
1857 static PyObject *
1858 py_guestfs_pvs (PyObject *self, PyObject *args)
1859 {
1860   PyObject *py_g;
1861   guestfs_h *g;
1862   PyObject *py_r;
1863   char **r;
1864
1865   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
1866                          &py_g))
1867     return NULL;
1868   g = get_handle (py_g);
1869
1870   r = guestfs_pvs (g);
1871   if (r == NULL) {
1872     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1873     return NULL;
1874   }
1875
1876   py_r = put_string_list (r);
1877   free_strings (r);
1878   return py_r;
1879 }
1880
1881 static PyObject *
1882 py_guestfs_vgs (PyObject *self, PyObject *args)
1883 {
1884   PyObject *py_g;
1885   guestfs_h *g;
1886   PyObject *py_r;
1887   char **r;
1888
1889   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
1890                          &py_g))
1891     return NULL;
1892   g = get_handle (py_g);
1893
1894   r = guestfs_vgs (g);
1895   if (r == NULL) {
1896     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1897     return NULL;
1898   }
1899
1900   py_r = put_string_list (r);
1901   free_strings (r);
1902   return py_r;
1903 }
1904
1905 static PyObject *
1906 py_guestfs_lvs (PyObject *self, PyObject *args)
1907 {
1908   PyObject *py_g;
1909   guestfs_h *g;
1910   PyObject *py_r;
1911   char **r;
1912
1913   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
1914                          &py_g))
1915     return NULL;
1916   g = get_handle (py_g);
1917
1918   r = guestfs_lvs (g);
1919   if (r == NULL) {
1920     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1921     return NULL;
1922   }
1923
1924   py_r = put_string_list (r);
1925   free_strings (r);
1926   return py_r;
1927 }
1928
1929 static PyObject *
1930 py_guestfs_pvs_full (PyObject *self, PyObject *args)
1931 {
1932   PyObject *py_g;
1933   guestfs_h *g;
1934   PyObject *py_r;
1935   struct guestfs_lvm_pv_list *r;
1936
1937   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
1938                          &py_g))
1939     return NULL;
1940   g = get_handle (py_g);
1941
1942   r = guestfs_pvs_full (g);
1943   if (r == NULL) {
1944     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1945     return NULL;
1946   }
1947
1948   py_r = put_lvm_pv_list (r);
1949   guestfs_free_lvm_pv_list (r);
1950   return py_r;
1951 }
1952
1953 static PyObject *
1954 py_guestfs_vgs_full (PyObject *self, PyObject *args)
1955 {
1956   PyObject *py_g;
1957   guestfs_h *g;
1958   PyObject *py_r;
1959   struct guestfs_lvm_vg_list *r;
1960
1961   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
1962                          &py_g))
1963     return NULL;
1964   g = get_handle (py_g);
1965
1966   r = guestfs_vgs_full (g);
1967   if (r == NULL) {
1968     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1969     return NULL;
1970   }
1971
1972   py_r = put_lvm_vg_list (r);
1973   guestfs_free_lvm_vg_list (r);
1974   return py_r;
1975 }
1976
1977 static PyObject *
1978 py_guestfs_lvs_full (PyObject *self, PyObject *args)
1979 {
1980   PyObject *py_g;
1981   guestfs_h *g;
1982   PyObject *py_r;
1983   struct guestfs_lvm_lv_list *r;
1984
1985   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
1986                          &py_g))
1987     return NULL;
1988   g = get_handle (py_g);
1989
1990   r = guestfs_lvs_full (g);
1991   if (r == NULL) {
1992     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1993     return NULL;
1994   }
1995
1996   py_r = put_lvm_lv_list (r);
1997   guestfs_free_lvm_lv_list (r);
1998   return py_r;
1999 }
2000
2001 static PyObject *
2002 py_guestfs_read_lines (PyObject *self, PyObject *args)
2003 {
2004   PyObject *py_g;
2005   guestfs_h *g;
2006   PyObject *py_r;
2007   char **r;
2008   const char *path;
2009
2010   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
2011                          &py_g, &path))
2012     return NULL;
2013   g = get_handle (py_g);
2014
2015   r = guestfs_read_lines (g, path);
2016   if (r == NULL) {
2017     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2018     return NULL;
2019   }
2020
2021   py_r = put_string_list (r);
2022   free_strings (r);
2023   return py_r;
2024 }
2025
2026 static PyObject *
2027 py_guestfs_aug_init (PyObject *self, PyObject *args)
2028 {
2029   PyObject *py_g;
2030   guestfs_h *g;
2031   PyObject *py_r;
2032   int r;
2033   const char *root;
2034   int flags;
2035
2036   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
2037                          &py_g, &root, &flags))
2038     return NULL;
2039   g = get_handle (py_g);
2040
2041   r = guestfs_aug_init (g, root, flags);
2042   if (r == -1) {
2043     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2044     return NULL;
2045   }
2046
2047   Py_INCREF (Py_None);
2048   py_r = Py_None;
2049   return py_r;
2050 }
2051
2052 static PyObject *
2053 py_guestfs_aug_close (PyObject *self, PyObject *args)
2054 {
2055   PyObject *py_g;
2056   guestfs_h *g;
2057   PyObject *py_r;
2058   int r;
2059
2060   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
2061                          &py_g))
2062     return NULL;
2063   g = get_handle (py_g);
2064
2065   r = guestfs_aug_close (g);
2066   if (r == -1) {
2067     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2068     return NULL;
2069   }
2070
2071   Py_INCREF (Py_None);
2072   py_r = Py_None;
2073   return py_r;
2074 }
2075
2076 static PyObject *
2077 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
2078 {
2079   PyObject *py_g;
2080   guestfs_h *g;
2081   PyObject *py_r;
2082   int r;
2083   const char *name;
2084   const char *expr;
2085
2086   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
2087                          &py_g, &name, &expr))
2088     return NULL;
2089   g = get_handle (py_g);
2090
2091   r = guestfs_aug_defvar (g, name, expr);
2092   if (r == -1) {
2093     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2094     return NULL;
2095   }
2096
2097   py_r = PyInt_FromLong ((long) r);
2098   return py_r;
2099 }
2100
2101 static PyObject *
2102 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
2103 {
2104   PyObject *py_g;
2105   guestfs_h *g;
2106   PyObject *py_r;
2107   struct guestfs_int_bool *r;
2108   const char *name;
2109   const char *expr;
2110   const char *val;
2111
2112   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
2113                          &py_g, &name, &expr, &val))
2114     return NULL;
2115   g = get_handle (py_g);
2116
2117   r = guestfs_aug_defnode (g, name, expr, val);
2118   if (r == NULL) {
2119     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2120     return NULL;
2121   }
2122
2123   py_r = PyTuple_New (2);
2124   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
2125   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
2126   guestfs_free_int_bool (r);
2127   return py_r;
2128 }
2129
2130 static PyObject *
2131 py_guestfs_aug_get (PyObject *self, PyObject *args)
2132 {
2133   PyObject *py_g;
2134   guestfs_h *g;
2135   PyObject *py_r;
2136   char *r;
2137   const char *path;
2138
2139   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
2140                          &py_g, &path))
2141     return NULL;
2142   g = get_handle (py_g);
2143
2144   r = guestfs_aug_get (g, path);
2145   if (r == NULL) {
2146     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2147     return NULL;
2148   }
2149
2150   py_r = PyString_FromString (r);
2151   free (r);
2152   return py_r;
2153 }
2154
2155 static PyObject *
2156 py_guestfs_aug_set (PyObject *self, PyObject *args)
2157 {
2158   PyObject *py_g;
2159   guestfs_h *g;
2160   PyObject *py_r;
2161   int r;
2162   const char *path;
2163   const char *val;
2164
2165   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
2166                          &py_g, &path, &val))
2167     return NULL;
2168   g = get_handle (py_g);
2169
2170   r = guestfs_aug_set (g, path, val);
2171   if (r == -1) {
2172     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2173     return NULL;
2174   }
2175
2176   Py_INCREF (Py_None);
2177   py_r = Py_None;
2178   return py_r;
2179 }
2180
2181 static PyObject *
2182 py_guestfs_aug_insert (PyObject *self, PyObject *args)
2183 {
2184   PyObject *py_g;
2185   guestfs_h *g;
2186   PyObject *py_r;
2187   int r;
2188   const char *path;
2189   const char *label;
2190   int before;
2191
2192   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
2193                          &py_g, &path, &label, &before))
2194     return NULL;
2195   g = get_handle (py_g);
2196
2197   r = guestfs_aug_insert (g, path, label, before);
2198   if (r == -1) {
2199     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2200     return NULL;
2201   }
2202
2203   Py_INCREF (Py_None);
2204   py_r = Py_None;
2205   return py_r;
2206 }
2207
2208 static PyObject *
2209 py_guestfs_aug_rm (PyObject *self, PyObject *args)
2210 {
2211   PyObject *py_g;
2212   guestfs_h *g;
2213   PyObject *py_r;
2214   int r;
2215   const char *path;
2216
2217   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
2218                          &py_g, &path))
2219     return NULL;
2220   g = get_handle (py_g);
2221
2222   r = guestfs_aug_rm (g, path);
2223   if (r == -1) {
2224     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2225     return NULL;
2226   }
2227
2228   py_r = PyInt_FromLong ((long) r);
2229   return py_r;
2230 }
2231
2232 static PyObject *
2233 py_guestfs_aug_mv (PyObject *self, PyObject *args)
2234 {
2235   PyObject *py_g;
2236   guestfs_h *g;
2237   PyObject *py_r;
2238   int r;
2239   const char *src;
2240   const char *dest;
2241
2242   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
2243                          &py_g, &src, &dest))
2244     return NULL;
2245   g = get_handle (py_g);
2246
2247   r = guestfs_aug_mv (g, src, dest);
2248   if (r == -1) {
2249     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2250     return NULL;
2251   }
2252
2253   Py_INCREF (Py_None);
2254   py_r = Py_None;
2255   return py_r;
2256 }
2257
2258 static PyObject *
2259 py_guestfs_aug_match (PyObject *self, PyObject *args)
2260 {
2261   PyObject *py_g;
2262   guestfs_h *g;
2263   PyObject *py_r;
2264   char **r;
2265   const char *path;
2266
2267   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
2268                          &py_g, &path))
2269     return NULL;
2270   g = get_handle (py_g);
2271
2272   r = guestfs_aug_match (g, path);
2273   if (r == NULL) {
2274     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2275     return NULL;
2276   }
2277
2278   py_r = put_string_list (r);
2279   free_strings (r);
2280   return py_r;
2281 }
2282
2283 static PyObject *
2284 py_guestfs_aug_save (PyObject *self, PyObject *args)
2285 {
2286   PyObject *py_g;
2287   guestfs_h *g;
2288   PyObject *py_r;
2289   int r;
2290
2291   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
2292                          &py_g))
2293     return NULL;
2294   g = get_handle (py_g);
2295
2296   r = guestfs_aug_save (g);
2297   if (r == -1) {
2298     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2299     return NULL;
2300   }
2301
2302   Py_INCREF (Py_None);
2303   py_r = Py_None;
2304   return py_r;
2305 }
2306
2307 static PyObject *
2308 py_guestfs_aug_load (PyObject *self, PyObject *args)
2309 {
2310   PyObject *py_g;
2311   guestfs_h *g;
2312   PyObject *py_r;
2313   int r;
2314
2315   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
2316                          &py_g))
2317     return NULL;
2318   g = get_handle (py_g);
2319
2320   r = guestfs_aug_load (g);
2321   if (r == -1) {
2322     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2323     return NULL;
2324   }
2325
2326   Py_INCREF (Py_None);
2327   py_r = Py_None;
2328   return py_r;
2329 }
2330
2331 static PyObject *
2332 py_guestfs_aug_ls (PyObject *self, PyObject *args)
2333 {
2334   PyObject *py_g;
2335   guestfs_h *g;
2336   PyObject *py_r;
2337   char **r;
2338   const char *path;
2339
2340   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
2341                          &py_g, &path))
2342     return NULL;
2343   g = get_handle (py_g);
2344
2345   r = guestfs_aug_ls (g, path);
2346   if (r == NULL) {
2347     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2348     return NULL;
2349   }
2350
2351   py_r = put_string_list (r);
2352   free_strings (r);
2353   return py_r;
2354 }
2355
2356 static PyObject *
2357 py_guestfs_rm (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_rm",
2366                          &py_g, &path))
2367     return NULL;
2368   g = get_handle (py_g);
2369
2370   r = guestfs_rm (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_rmdir (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_rmdir",
2391                          &py_g, &path))
2392     return NULL;
2393   g = get_handle (py_g);
2394
2395   r = guestfs_rmdir (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_rm_rf (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_rm_rf",
2416                          &py_g, &path))
2417     return NULL;
2418   g = get_handle (py_g);
2419
2420   r = guestfs_rm_rf (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 (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",
2441                          &py_g, &path))
2442     return NULL;
2443   g = get_handle (py_g);
2444
2445   r = guestfs_mkdir (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_mkdir_p (PyObject *self, PyObject *args)
2458 {
2459   PyObject *py_g;
2460   guestfs_h *g;
2461   PyObject *py_r;
2462   int r;
2463   const char *path;
2464
2465   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
2466                          &py_g, &path))
2467     return NULL;
2468   g = get_handle (py_g);
2469
2470   r = guestfs_mkdir_p (g, path);
2471   if (r == -1) {
2472     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2473     return NULL;
2474   }
2475
2476   Py_INCREF (Py_None);
2477   py_r = Py_None;
2478   return py_r;
2479 }
2480
2481 static PyObject *
2482 py_guestfs_chmod (PyObject *self, PyObject *args)
2483 {
2484   PyObject *py_g;
2485   guestfs_h *g;
2486   PyObject *py_r;
2487   int r;
2488   int mode;
2489   const char *path;
2490
2491   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
2492                          &py_g, &mode, &path))
2493     return NULL;
2494   g = get_handle (py_g);
2495
2496   r = guestfs_chmod (g, mode, path);
2497   if (r == -1) {
2498     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2499     return NULL;
2500   }
2501
2502   Py_INCREF (Py_None);
2503   py_r = Py_None;
2504   return py_r;
2505 }
2506
2507 static PyObject *
2508 py_guestfs_chown (PyObject *self, PyObject *args)
2509 {
2510   PyObject *py_g;
2511   guestfs_h *g;
2512   PyObject *py_r;
2513   int r;
2514   int owner;
2515   int group;
2516   const char *path;
2517
2518   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
2519                          &py_g, &owner, &group, &path))
2520     return NULL;
2521   g = get_handle (py_g);
2522
2523   r = guestfs_chown (g, owner, group, path);
2524   if (r == -1) {
2525     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2526     return NULL;
2527   }
2528
2529   Py_INCREF (Py_None);
2530   py_r = Py_None;
2531   return py_r;
2532 }
2533
2534 static PyObject *
2535 py_guestfs_exists (PyObject *self, PyObject *args)
2536 {
2537   PyObject *py_g;
2538   guestfs_h *g;
2539   PyObject *py_r;
2540   int r;
2541   const char *path;
2542
2543   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
2544                          &py_g, &path))
2545     return NULL;
2546   g = get_handle (py_g);
2547
2548   r = guestfs_exists (g, path);
2549   if (r == -1) {
2550     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2551     return NULL;
2552   }
2553
2554   py_r = PyInt_FromLong ((long) r);
2555   return py_r;
2556 }
2557
2558 static PyObject *
2559 py_guestfs_is_file (PyObject *self, PyObject *args)
2560 {
2561   PyObject *py_g;
2562   guestfs_h *g;
2563   PyObject *py_r;
2564   int r;
2565   const char *path;
2566
2567   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
2568                          &py_g, &path))
2569     return NULL;
2570   g = get_handle (py_g);
2571
2572   r = guestfs_is_file (g, path);
2573   if (r == -1) {
2574     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2575     return NULL;
2576   }
2577
2578   py_r = PyInt_FromLong ((long) r);
2579   return py_r;
2580 }
2581
2582 static PyObject *
2583 py_guestfs_is_dir (PyObject *self, PyObject *args)
2584 {
2585   PyObject *py_g;
2586   guestfs_h *g;
2587   PyObject *py_r;
2588   int r;
2589   const char *path;
2590
2591   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
2592                          &py_g, &path))
2593     return NULL;
2594   g = get_handle (py_g);
2595
2596   r = guestfs_is_dir (g, path);
2597   if (r == -1) {
2598     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2599     return NULL;
2600   }
2601
2602   py_r = PyInt_FromLong ((long) r);
2603   return py_r;
2604 }
2605
2606 static PyObject *
2607 py_guestfs_pvcreate (PyObject *self, PyObject *args)
2608 {
2609   PyObject *py_g;
2610   guestfs_h *g;
2611   PyObject *py_r;
2612   int r;
2613   const char *device;
2614
2615   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
2616                          &py_g, &device))
2617     return NULL;
2618   g = get_handle (py_g);
2619
2620   r = guestfs_pvcreate (g, device);
2621   if (r == -1) {
2622     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2623     return NULL;
2624   }
2625
2626   Py_INCREF (Py_None);
2627   py_r = Py_None;
2628   return py_r;
2629 }
2630
2631 static PyObject *
2632 py_guestfs_vgcreate (PyObject *self, PyObject *args)
2633 {
2634   PyObject *py_g;
2635   guestfs_h *g;
2636   PyObject *py_r;
2637   int r;
2638   const char *volgroup;
2639   PyObject *py_physvols;
2640   const char **physvols;
2641
2642   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
2643                          &py_g, &volgroup, &py_physvols))
2644     return NULL;
2645   g = get_handle (py_g);
2646   physvols = get_string_list (py_physvols);
2647   if (!physvols) return NULL;
2648
2649   r = guestfs_vgcreate (g, volgroup, physvols);
2650   free (physvols);
2651   if (r == -1) {
2652     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2653     return NULL;
2654   }
2655
2656   Py_INCREF (Py_None);
2657   py_r = Py_None;
2658   return py_r;
2659 }
2660
2661 static PyObject *
2662 py_guestfs_lvcreate (PyObject *self, PyObject *args)
2663 {
2664   PyObject *py_g;
2665   guestfs_h *g;
2666   PyObject *py_r;
2667   int r;
2668   const char *logvol;
2669   const char *volgroup;
2670   int mbytes;
2671
2672   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
2673                          &py_g, &logvol, &volgroup, &mbytes))
2674     return NULL;
2675   g = get_handle (py_g);
2676
2677   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2678   if (r == -1) {
2679     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2680     return NULL;
2681   }
2682
2683   Py_INCREF (Py_None);
2684   py_r = Py_None;
2685   return py_r;
2686 }
2687
2688 static PyObject *
2689 py_guestfs_mkfs (PyObject *self, PyObject *args)
2690 {
2691   PyObject *py_g;
2692   guestfs_h *g;
2693   PyObject *py_r;
2694   int r;
2695   const char *fstype;
2696   const char *device;
2697
2698   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
2699                          &py_g, &fstype, &device))
2700     return NULL;
2701   g = get_handle (py_g);
2702
2703   r = guestfs_mkfs (g, fstype, device);
2704   if (r == -1) {
2705     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2706     return NULL;
2707   }
2708
2709   Py_INCREF (Py_None);
2710   py_r = Py_None;
2711   return py_r;
2712 }
2713
2714 static PyObject *
2715 py_guestfs_sfdisk (PyObject *self, PyObject *args)
2716 {
2717   PyObject *py_g;
2718   guestfs_h *g;
2719   PyObject *py_r;
2720   int r;
2721   const char *device;
2722   int cyls;
2723   int heads;
2724   int sectors;
2725   PyObject *py_lines;
2726   const char **lines;
2727
2728   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
2729                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
2730     return NULL;
2731   g = get_handle (py_g);
2732   lines = get_string_list (py_lines);
2733   if (!lines) return NULL;
2734
2735   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2736   free (lines);
2737   if (r == -1) {
2738     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2739     return NULL;
2740   }
2741
2742   Py_INCREF (Py_None);
2743   py_r = Py_None;
2744   return py_r;
2745 }
2746
2747 static PyObject *
2748 py_guestfs_write_file (PyObject *self, PyObject *args)
2749 {
2750   PyObject *py_g;
2751   guestfs_h *g;
2752   PyObject *py_r;
2753   int r;
2754   const char *path;
2755   const char *content;
2756   int size;
2757
2758   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
2759                          &py_g, &path, &content, &size))
2760     return NULL;
2761   g = get_handle (py_g);
2762
2763   r = guestfs_write_file (g, path, content, size);
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_umount (PyObject *self, PyObject *args)
2776 {
2777   PyObject *py_g;
2778   guestfs_h *g;
2779   PyObject *py_r;
2780   int r;
2781   const char *pathordevice;
2782
2783   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
2784                          &py_g, &pathordevice))
2785     return NULL;
2786   g = get_handle (py_g);
2787
2788   r = guestfs_umount (g, pathordevice);
2789   if (r == -1) {
2790     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2791     return NULL;
2792   }
2793
2794   Py_INCREF (Py_None);
2795   py_r = Py_None;
2796   return py_r;
2797 }
2798
2799 static PyObject *
2800 py_guestfs_mounts (PyObject *self, PyObject *args)
2801 {
2802   PyObject *py_g;
2803   guestfs_h *g;
2804   PyObject *py_r;
2805   char **r;
2806
2807   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
2808                          &py_g))
2809     return NULL;
2810   g = get_handle (py_g);
2811
2812   r = guestfs_mounts (g);
2813   if (r == NULL) {
2814     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2815     return NULL;
2816   }
2817
2818   py_r = put_string_list (r);
2819   free_strings (r);
2820   return py_r;
2821 }
2822
2823 static PyObject *
2824 py_guestfs_umount_all (PyObject *self, PyObject *args)
2825 {
2826   PyObject *py_g;
2827   guestfs_h *g;
2828   PyObject *py_r;
2829   int r;
2830
2831   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
2832                          &py_g))
2833     return NULL;
2834   g = get_handle (py_g);
2835
2836   r = guestfs_umount_all (g);
2837   if (r == -1) {
2838     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2839     return NULL;
2840   }
2841
2842   Py_INCREF (Py_None);
2843   py_r = Py_None;
2844   return py_r;
2845 }
2846
2847 static PyObject *
2848 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
2849 {
2850   PyObject *py_g;
2851   guestfs_h *g;
2852   PyObject *py_r;
2853   int r;
2854
2855   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
2856                          &py_g))
2857     return NULL;
2858   g = get_handle (py_g);
2859
2860   r = guestfs_lvm_remove_all (g);
2861   if (r == -1) {
2862     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2863     return NULL;
2864   }
2865
2866   Py_INCREF (Py_None);
2867   py_r = Py_None;
2868   return py_r;
2869 }
2870
2871 static PyObject *
2872 py_guestfs_file (PyObject *self, PyObject *args)
2873 {
2874   PyObject *py_g;
2875   guestfs_h *g;
2876   PyObject *py_r;
2877   char *r;
2878   const char *path;
2879
2880   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
2881                          &py_g, &path))
2882     return NULL;
2883   g = get_handle (py_g);
2884
2885   r = guestfs_file (g, path);
2886   if (r == NULL) {
2887     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2888     return NULL;
2889   }
2890
2891   py_r = PyString_FromString (r);
2892   free (r);
2893   return py_r;
2894 }
2895
2896 static PyObject *
2897 py_guestfs_command (PyObject *self, PyObject *args)
2898 {
2899   PyObject *py_g;
2900   guestfs_h *g;
2901   PyObject *py_r;
2902   char *r;
2903   PyObject *py_arguments;
2904   const char **arguments;
2905
2906   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
2907                          &py_g, &py_arguments))
2908     return NULL;
2909   g = get_handle (py_g);
2910   arguments = get_string_list (py_arguments);
2911   if (!arguments) return NULL;
2912
2913   r = guestfs_command (g, arguments);
2914   free (arguments);
2915   if (r == NULL) {
2916     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2917     return NULL;
2918   }
2919
2920   py_r = PyString_FromString (r);
2921   free (r);
2922   return py_r;
2923 }
2924
2925 static PyObject *
2926 py_guestfs_command_lines (PyObject *self, PyObject *args)
2927 {
2928   PyObject *py_g;
2929   guestfs_h *g;
2930   PyObject *py_r;
2931   char **r;
2932   PyObject *py_arguments;
2933   const char **arguments;
2934
2935   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
2936                          &py_g, &py_arguments))
2937     return NULL;
2938   g = get_handle (py_g);
2939   arguments = get_string_list (py_arguments);
2940   if (!arguments) return NULL;
2941
2942   r = guestfs_command_lines (g, arguments);
2943   free (arguments);
2944   if (r == NULL) {
2945     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2946     return NULL;
2947   }
2948
2949   py_r = put_string_list (r);
2950   free_strings (r);
2951   return py_r;
2952 }
2953
2954 static PyObject *
2955 py_guestfs_stat (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_stat",
2964                          &py_g, &path))
2965     return NULL;
2966   g = get_handle (py_g);
2967
2968   r = guestfs_stat (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_lstat (PyObject *self, PyObject *args)
2981 {
2982   PyObject *py_g;
2983   guestfs_h *g;
2984   PyObject *py_r;
2985   struct guestfs_stat *r;
2986   const char *path;
2987
2988   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
2989                          &py_g, &path))
2990     return NULL;
2991   g = get_handle (py_g);
2992
2993   r = guestfs_lstat (g, path);
2994   if (r == NULL) {
2995     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2996     return NULL;
2997   }
2998
2999   py_r = put_stat (r);
3000   free (r);
3001   return py_r;
3002 }
3003
3004 static PyObject *
3005 py_guestfs_statvfs (PyObject *self, PyObject *args)
3006 {
3007   PyObject *py_g;
3008   guestfs_h *g;
3009   PyObject *py_r;
3010   struct guestfs_statvfs *r;
3011   const char *path;
3012
3013   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
3014                          &py_g, &path))
3015     return NULL;
3016   g = get_handle (py_g);
3017
3018   r = guestfs_statvfs (g, path);
3019   if (r == NULL) {
3020     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3021     return NULL;
3022   }
3023
3024   py_r = put_statvfs (r);
3025   free (r);
3026   return py_r;
3027 }
3028
3029 static PyObject *
3030 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
3031 {
3032   PyObject *py_g;
3033   guestfs_h *g;
3034   PyObject *py_r;
3035   char **r;
3036   const char *device;
3037
3038   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
3039                          &py_g, &device))
3040     return NULL;
3041   g = get_handle (py_g);
3042
3043   r = guestfs_tune2fs_l (g, device);
3044   if (r == NULL) {
3045     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3046     return NULL;
3047   }
3048
3049   py_r = put_table (r);
3050   free_strings (r);
3051   return py_r;
3052 }
3053
3054 static PyObject *
3055 py_guestfs_blockdev_setro (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_setro",
3064                          &py_g, &device))
3065     return NULL;
3066   g = get_handle (py_g);
3067
3068   r = guestfs_blockdev_setro (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_setrw (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_setrw",
3089                          &py_g, &device))
3090     return NULL;
3091   g = get_handle (py_g);
3092
3093   r = guestfs_blockdev_setrw (g, device);
3094   if (r == -1) {
3095     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3096     return NULL;
3097   }
3098
3099   Py_INCREF (Py_None);
3100   py_r = Py_None;
3101   return py_r;
3102 }
3103
3104 static PyObject *
3105 py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
3106 {
3107   PyObject *py_g;
3108   guestfs_h *g;
3109   PyObject *py_r;
3110   int r;
3111   const char *device;
3112
3113   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
3114                          &py_g, &device))
3115     return NULL;
3116   g = get_handle (py_g);
3117
3118   r = guestfs_blockdev_getro (g, device);
3119   if (r == -1) {
3120     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3121     return NULL;
3122   }
3123
3124   py_r = PyInt_FromLong ((long) r);
3125   return py_r;
3126 }
3127
3128 static PyObject *
3129 py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
3130 {
3131   PyObject *py_g;
3132   guestfs_h *g;
3133   PyObject *py_r;
3134   int r;
3135   const char *device;
3136
3137   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
3138                          &py_g, &device))
3139     return NULL;
3140   g = get_handle (py_g);
3141
3142   r = guestfs_blockdev_getss (g, device);
3143   if (r == -1) {
3144     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3145     return NULL;
3146   }
3147
3148   py_r = PyInt_FromLong ((long) r);
3149   return py_r;
3150 }
3151
3152 static PyObject *
3153 py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
3154 {
3155   PyObject *py_g;
3156   guestfs_h *g;
3157   PyObject *py_r;
3158   int r;
3159   const char *device;
3160
3161   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
3162                          &py_g, &device))
3163     return NULL;
3164   g = get_handle (py_g);
3165
3166   r = guestfs_blockdev_getbsz (g, device);
3167   if (r == -1) {
3168     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3169     return NULL;
3170   }
3171
3172   py_r = PyInt_FromLong ((long) r);
3173   return py_r;
3174 }
3175
3176 static PyObject *
3177 py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
3178 {
3179   PyObject *py_g;
3180   guestfs_h *g;
3181   PyObject *py_r;
3182   int r;
3183   const char *device;
3184   int blocksize;
3185
3186   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
3187                          &py_g, &device, &blocksize))
3188     return NULL;
3189   g = get_handle (py_g);
3190
3191   r = guestfs_blockdev_setbsz (g, device, blocksize);
3192   if (r == -1) {
3193     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3194     return NULL;
3195   }
3196
3197   Py_INCREF (Py_None);
3198   py_r = Py_None;
3199   return py_r;
3200 }
3201
3202 static PyObject *
3203 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
3204 {
3205   PyObject *py_g;
3206   guestfs_h *g;
3207   PyObject *py_r;
3208   int64_t r;
3209   const char *device;
3210
3211   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
3212                          &py_g, &device))
3213     return NULL;
3214   g = get_handle (py_g);
3215
3216   r = guestfs_blockdev_getsz (g, device);
3217   if (r == -1) {
3218     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3219     return NULL;
3220   }
3221
3222   py_r = PyLong_FromLongLong (r);
3223   return py_r;
3224 }
3225
3226 static PyObject *
3227 py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
3228 {
3229   PyObject *py_g;
3230   guestfs_h *g;
3231   PyObject *py_r;
3232   int64_t r;
3233   const char *device;
3234
3235   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
3236                          &py_g, &device))
3237     return NULL;
3238   g = get_handle (py_g);
3239
3240   r = guestfs_blockdev_getsize64 (g, device);
3241   if (r == -1) {
3242     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3243     return NULL;
3244   }
3245
3246   py_r = PyLong_FromLongLong (r);
3247   return py_r;
3248 }
3249
3250 static PyObject *
3251 py_guestfs_blockdev_flushbufs (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_flushbufs",
3260                          &py_g, &device))
3261     return NULL;
3262   g = get_handle (py_g);
3263
3264   r = guestfs_blockdev_flushbufs (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_blockdev_rereadpt (PyObject *self, PyObject *args)
3277 {
3278   PyObject *py_g;
3279   guestfs_h *g;
3280   PyObject *py_r;
3281   int r;
3282   const char *device;
3283
3284   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
3285                          &py_g, &device))
3286     return NULL;
3287   g = get_handle (py_g);
3288
3289   r = guestfs_blockdev_rereadpt (g, device);
3290   if (r == -1) {
3291     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3292     return NULL;
3293   }
3294
3295   Py_INCREF (Py_None);
3296   py_r = Py_None;
3297   return py_r;
3298 }
3299
3300 static PyObject *
3301 py_guestfs_upload (PyObject *self, PyObject *args)
3302 {
3303   PyObject *py_g;
3304   guestfs_h *g;
3305   PyObject *py_r;
3306   int r;
3307   const char *filename;
3308   const char *remotefilename;
3309
3310   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
3311                          &py_g, &filename, &remotefilename))
3312     return NULL;
3313   g = get_handle (py_g);
3314
3315   r = guestfs_upload (g, filename, remotefilename);
3316   if (r == -1) {
3317     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3318     return NULL;
3319   }
3320
3321   Py_INCREF (Py_None);
3322   py_r = Py_None;
3323   return py_r;
3324 }
3325
3326 static PyObject *
3327 py_guestfs_download (PyObject *self, PyObject *args)
3328 {
3329   PyObject *py_g;
3330   guestfs_h *g;
3331   PyObject *py_r;
3332   int r;
3333   const char *remotefilename;
3334   const char *filename;
3335
3336   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
3337                          &py_g, &remotefilename, &filename))
3338     return NULL;
3339   g = get_handle (py_g);
3340
3341   r = guestfs_download (g, remotefilename, filename);
3342   if (r == -1) {
3343     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3344     return NULL;
3345   }
3346
3347   Py_INCREF (Py_None);
3348   py_r = Py_None;
3349   return py_r;
3350 }
3351
3352 static PyObject *
3353 py_guestfs_checksum (PyObject *self, PyObject *args)
3354 {
3355   PyObject *py_g;
3356   guestfs_h *g;
3357   PyObject *py_r;
3358   char *r;
3359   const char *csumtype;
3360   const char *path;
3361
3362   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum",
3363                          &py_g, &csumtype, &path))
3364     return NULL;
3365   g = get_handle (py_g);
3366
3367   r = guestfs_checksum (g, csumtype, path);
3368   if (r == NULL) {
3369     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3370     return NULL;
3371   }
3372
3373   py_r = PyString_FromString (r);
3374   free (r);
3375   return py_r;
3376 }
3377
3378 static PyObject *
3379 py_guestfs_tar_in (PyObject *self, PyObject *args)
3380 {
3381   PyObject *py_g;
3382   guestfs_h *g;
3383   PyObject *py_r;
3384   int r;
3385   const char *tarfile;
3386   const char *directory;
3387
3388   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in",
3389                          &py_g, &tarfile, &directory))
3390     return NULL;
3391   g = get_handle (py_g);
3392
3393   r = guestfs_tar_in (g, tarfile, directory);
3394   if (r == -1) {
3395     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3396     return NULL;
3397   }
3398
3399   Py_INCREF (Py_None);
3400   py_r = Py_None;
3401   return py_r;
3402 }
3403
3404 static PyObject *
3405 py_guestfs_tar_out (PyObject *self, PyObject *args)
3406 {
3407   PyObject *py_g;
3408   guestfs_h *g;
3409   PyObject *py_r;
3410   int r;
3411   const char *directory;
3412   const char *tarfile;
3413
3414   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out",
3415                          &py_g, &directory, &tarfile))
3416     return NULL;
3417   g = get_handle (py_g);
3418
3419   r = guestfs_tar_out (g, directory, tarfile);
3420   if (r == -1) {
3421     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3422     return NULL;
3423   }
3424
3425   Py_INCREF (Py_None);
3426   py_r = Py_None;
3427   return py_r;
3428 }
3429
3430 static PyObject *
3431 py_guestfs_tgz_in (PyObject *self, PyObject *args)
3432 {
3433   PyObject *py_g;
3434   guestfs_h *g;
3435   PyObject *py_r;
3436   int r;
3437   const char *tarball;
3438   const char *directory;
3439
3440   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in",
3441                          &py_g, &tarball, &directory))
3442     return NULL;
3443   g = get_handle (py_g);
3444
3445   r = guestfs_tgz_in (g, tarball, directory);
3446   if (r == -1) {
3447     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3448     return NULL;
3449   }
3450
3451   Py_INCREF (Py_None);
3452   py_r = Py_None;
3453   return py_r;
3454 }
3455
3456 static PyObject *
3457 py_guestfs_tgz_out (PyObject *self, PyObject *args)
3458 {
3459   PyObject *py_g;
3460   guestfs_h *g;
3461   PyObject *py_r;
3462   int r;
3463   const char *directory;
3464   const char *tarball;
3465
3466   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out",
3467                          &py_g, &directory, &tarball))
3468     return NULL;
3469   g = get_handle (py_g);
3470
3471   r = guestfs_tgz_out (g, directory, tarball);
3472   if (r == -1) {
3473     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3474     return NULL;
3475   }
3476
3477   Py_INCREF (Py_None);
3478   py_r = Py_None;
3479   return py_r;
3480 }
3481
3482 static PyObject *
3483 py_guestfs_mount_ro (PyObject *self, PyObject *args)
3484 {
3485   PyObject *py_g;
3486   guestfs_h *g;
3487   PyObject *py_r;
3488   int r;
3489   const char *device;
3490   const char *mountpoint;
3491
3492   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro",
3493                          &py_g, &device, &mountpoint))
3494     return NULL;
3495   g = get_handle (py_g);
3496
3497   r = guestfs_mount_ro (g, device, mountpoint);
3498   if (r == -1) {
3499     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3500     return NULL;
3501   }
3502
3503   Py_INCREF (Py_None);
3504   py_r = Py_None;
3505   return py_r;
3506 }
3507
3508 static PyObject *
3509 py_guestfs_mount_options (PyObject *self, PyObject *args)
3510 {
3511   PyObject *py_g;
3512   guestfs_h *g;
3513   PyObject *py_r;
3514   int r;
3515   const char *options;
3516   const char *device;
3517   const char *mountpoint;
3518
3519   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options",
3520                          &py_g, &options, &device, &mountpoint))
3521     return NULL;
3522   g = get_handle (py_g);
3523
3524   r = guestfs_mount_options (g, options, device, mountpoint);
3525   if (r == -1) {
3526     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3527     return NULL;
3528   }
3529
3530   Py_INCREF (Py_None);
3531   py_r = Py_None;
3532   return py_r;
3533 }
3534
3535 static PyObject *
3536 py_guestfs_mount_vfs (PyObject *self, PyObject *args)
3537 {
3538   PyObject *py_g;
3539   guestfs_h *g;
3540   PyObject *py_r;
3541   int r;
3542   const char *options;
3543   const char *vfstype;
3544   const char *device;
3545   const char *mountpoint;
3546
3547   if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs",
3548                          &py_g, &options, &vfstype, &device, &mountpoint))
3549     return NULL;
3550   g = get_handle (py_g);
3551
3552   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3553   if (r == -1) {
3554     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3555     return NULL;
3556   }
3557
3558   Py_INCREF (Py_None);
3559   py_r = Py_None;
3560   return py_r;
3561 }
3562
3563 static PyObject *
3564 py_guestfs_debug (PyObject *self, PyObject *args)
3565 {
3566   PyObject *py_g;
3567   guestfs_h *g;
3568   PyObject *py_r;
3569   char *r;
3570   const char *subcmd;
3571   PyObject *py_extraargs;
3572   const char **extraargs;
3573
3574   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug",
3575                          &py_g, &subcmd, &py_extraargs))
3576     return NULL;
3577   g = get_handle (py_g);
3578   extraargs = get_string_list (py_extraargs);
3579   if (!extraargs) return NULL;
3580
3581   r = guestfs_debug (g, subcmd, extraargs);
3582   free (extraargs);
3583   if (r == NULL) {
3584     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3585     return NULL;
3586   }
3587
3588   py_r = PyString_FromString (r);
3589   free (r);
3590   return py_r;
3591 }
3592
3593 static PyObject *
3594 py_guestfs_lvremove (PyObject *self, PyObject *args)
3595 {
3596   PyObject *py_g;
3597   guestfs_h *g;
3598   PyObject *py_r;
3599   int r;
3600   const char *device;
3601
3602   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove",
3603                          &py_g, &device))
3604     return NULL;
3605   g = get_handle (py_g);
3606
3607   r = guestfs_lvremove (g, device);
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_vgremove (PyObject *self, PyObject *args)
3620 {
3621   PyObject *py_g;
3622   guestfs_h *g;
3623   PyObject *py_r;
3624   int r;
3625   const char *vgname;
3626
3627   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove",
3628                          &py_g, &vgname))
3629     return NULL;
3630   g = get_handle (py_g);
3631
3632   r = guestfs_vgremove (g, vgname);
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_pvremove (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
3652   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove",
3653                          &py_g, &device))
3654     return NULL;
3655   g = get_handle (py_g);
3656
3657   r = guestfs_pvremove (g, device);
3658   if (r == -1) {
3659     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3660     return NULL;
3661   }
3662
3663   Py_INCREF (Py_None);
3664   py_r = Py_None;
3665   return py_r;
3666 }
3667
3668 static PyObject *
3669 py_guestfs_set_e2label (PyObject *self, PyObject *args)
3670 {
3671   PyObject *py_g;
3672   guestfs_h *g;
3673   PyObject *py_r;
3674   int r;
3675   const char *device;
3676   const char *label;
3677
3678   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label",
3679                          &py_g, &device, &label))
3680     return NULL;
3681   g = get_handle (py_g);
3682
3683   r = guestfs_set_e2label (g, device, label);
3684   if (r == -1) {
3685     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3686     return NULL;
3687   }
3688
3689   Py_INCREF (Py_None);
3690   py_r = Py_None;
3691   return py_r;
3692 }
3693
3694 static PyObject *
3695 py_guestfs_get_e2label (PyObject *self, PyObject *args)
3696 {
3697   PyObject *py_g;
3698   guestfs_h *g;
3699   PyObject *py_r;
3700   char *r;
3701   const char *device;
3702
3703   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label",
3704                          &py_g, &device))
3705     return NULL;
3706   g = get_handle (py_g);
3707
3708   r = guestfs_get_e2label (g, device);
3709   if (r == NULL) {
3710     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3711     return NULL;
3712   }
3713
3714   py_r = PyString_FromString (r);
3715   free (r);
3716   return py_r;
3717 }
3718
3719 static PyObject *
3720 py_guestfs_set_e2uuid (PyObject *self, PyObject *args)
3721 {
3722   PyObject *py_g;
3723   guestfs_h *g;
3724   PyObject *py_r;
3725   int r;
3726   const char *device;
3727   const char *uuid;
3728
3729   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid",
3730                          &py_g, &device, &uuid))
3731     return NULL;
3732   g = get_handle (py_g);
3733
3734   r = guestfs_set_e2uuid (g, device, uuid);
3735   if (r == -1) {
3736     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3737     return NULL;
3738   }
3739
3740   Py_INCREF (Py_None);
3741   py_r = Py_None;
3742   return py_r;
3743 }
3744
3745 static PyObject *
3746 py_guestfs_get_e2uuid (PyObject *self, PyObject *args)
3747 {
3748   PyObject *py_g;
3749   guestfs_h *g;
3750   PyObject *py_r;
3751   char *r;
3752   const char *device;
3753
3754   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid",
3755                          &py_g, &device))
3756     return NULL;
3757   g = get_handle (py_g);
3758
3759   r = guestfs_get_e2uuid (g, device);
3760   if (r == NULL) {
3761     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3762     return NULL;
3763   }
3764
3765   py_r = PyString_FromString (r);
3766   free (r);
3767   return py_r;
3768 }
3769
3770 static PyObject *
3771 py_guestfs_fsck (PyObject *self, PyObject *args)
3772 {
3773   PyObject *py_g;
3774   guestfs_h *g;
3775   PyObject *py_r;
3776   int r;
3777   const char *fstype;
3778   const char *device;
3779
3780   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck",
3781                          &py_g, &fstype, &device))
3782     return NULL;
3783   g = get_handle (py_g);
3784
3785   r = guestfs_fsck (g, fstype, device);
3786   if (r == -1) {
3787     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3788     return NULL;
3789   }
3790
3791   py_r = PyInt_FromLong ((long) r);
3792   return py_r;
3793 }
3794
3795 static PyObject *
3796 py_guestfs_zero (PyObject *self, PyObject *args)
3797 {
3798   PyObject *py_g;
3799   guestfs_h *g;
3800   PyObject *py_r;
3801   int r;
3802   const char *device;
3803
3804   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero",
3805                          &py_g, &device))
3806     return NULL;
3807   g = get_handle (py_g);
3808
3809   r = guestfs_zero (g, device);
3810   if (r == -1) {
3811     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3812     return NULL;
3813   }
3814
3815   Py_INCREF (Py_None);
3816   py_r = Py_None;
3817   return py_r;
3818 }
3819
3820 static PyObject *
3821 py_guestfs_grub_install (PyObject *self, PyObject *args)
3822 {
3823   PyObject *py_g;
3824   guestfs_h *g;
3825   PyObject *py_r;
3826   int r;
3827   const char *root;
3828   const char *device;
3829
3830   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install",
3831                          &py_g, &root, &device))
3832     return NULL;
3833   g = get_handle (py_g);
3834
3835   r = guestfs_grub_install (g, root, device);
3836   if (r == -1) {
3837     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3838     return NULL;
3839   }
3840
3841   Py_INCREF (Py_None);
3842   py_r = Py_None;
3843   return py_r;
3844 }
3845
3846 static PyObject *
3847 py_guestfs_cp (PyObject *self, PyObject *args)
3848 {
3849   PyObject *py_g;
3850   guestfs_h *g;
3851   PyObject *py_r;
3852   int r;
3853   const char *src;
3854   const char *dest;
3855
3856   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp",
3857                          &py_g, &src, &dest))
3858     return NULL;
3859   g = get_handle (py_g);
3860
3861   r = guestfs_cp (g, src, dest);
3862   if (r == -1) {
3863     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3864     return NULL;
3865   }
3866
3867   Py_INCREF (Py_None);
3868   py_r = Py_None;
3869   return py_r;
3870 }
3871
3872 static PyObject *
3873 py_guestfs_cp_a (PyObject *self, PyObject *args)
3874 {
3875   PyObject *py_g;
3876   guestfs_h *g;
3877   PyObject *py_r;
3878   int r;
3879   const char *src;
3880   const char *dest;
3881
3882   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a",
3883                          &py_g, &src, &dest))
3884     return NULL;
3885   g = get_handle (py_g);
3886
3887   r = guestfs_cp_a (g, src, dest);
3888   if (r == -1) {
3889     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3890     return NULL;
3891   }
3892
3893   Py_INCREF (Py_None);
3894   py_r = Py_None;
3895   return py_r;
3896 }
3897
3898 static PyObject *
3899 py_guestfs_mv (PyObject *self, PyObject *args)
3900 {
3901   PyObject *py_g;
3902   guestfs_h *g;
3903   PyObject *py_r;
3904   int r;
3905   const char *src;
3906   const char *dest;
3907
3908   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv",
3909                          &py_g, &src, &dest))
3910     return NULL;
3911   g = get_handle (py_g);
3912
3913   r = guestfs_mv (g, src, dest);
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_drop_caches (PyObject *self, PyObject *args)
3926 {
3927   PyObject *py_g;
3928   guestfs_h *g;
3929   PyObject *py_r;
3930   int r;
3931   int whattodrop;
3932
3933   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches",
3934                          &py_g, &whattodrop))
3935     return NULL;
3936   g = get_handle (py_g);
3937
3938   r = guestfs_drop_caches (g, whattodrop);
3939   if (r == -1) {
3940     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3941     return NULL;
3942   }
3943
3944   Py_INCREF (Py_None);
3945   py_r = Py_None;
3946   return py_r;
3947 }
3948
3949 static PyObject *
3950 py_guestfs_dmesg (PyObject *self, PyObject *args)
3951 {
3952   PyObject *py_g;
3953   guestfs_h *g;
3954   PyObject *py_r;
3955   char *r;
3956
3957   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_dmesg",
3958                          &py_g))
3959     return NULL;
3960   g = get_handle (py_g);
3961
3962   r = guestfs_dmesg (g);
3963   if (r == NULL) {
3964     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3965     return NULL;
3966   }
3967
3968   py_r = PyString_FromString (r);
3969   free (r);
3970   return py_r;
3971 }
3972
3973 static PyObject *
3974 py_guestfs_ping_daemon (PyObject *self, PyObject *args)
3975 {
3976   PyObject *py_g;
3977   guestfs_h *g;
3978   PyObject *py_r;
3979   int r;
3980
3981   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_ping_daemon",
3982                          &py_g))
3983     return NULL;
3984   g = get_handle (py_g);
3985
3986   r = guestfs_ping_daemon (g);
3987   if (r == -1) {
3988     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3989     return NULL;
3990   }
3991
3992   Py_INCREF (Py_None);
3993   py_r = Py_None;
3994   return py_r;
3995 }
3996
3997 static PyObject *
3998 py_guestfs_equal (PyObject *self, PyObject *args)
3999 {
4000   PyObject *py_g;
4001   guestfs_h *g;
4002   PyObject *py_r;
4003   int r;
4004   const char *file1;
4005   const char *file2;
4006
4007   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_equal",
4008                          &py_g, &file1, &file2))
4009     return NULL;
4010   g = get_handle (py_g);
4011
4012   r = guestfs_equal (g, file1, file2);
4013   if (r == -1) {
4014     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4015     return NULL;
4016   }
4017
4018   py_r = PyInt_FromLong ((long) r);
4019   return py_r;
4020 }
4021
4022 static PyObject *
4023 py_guestfs_strings (PyObject *self, PyObject *args)
4024 {
4025   PyObject *py_g;
4026   guestfs_h *g;
4027   PyObject *py_r;
4028   char **r;
4029   const char *path;
4030
4031   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_strings",
4032                          &py_g, &path))
4033     return NULL;
4034   g = get_handle (py_g);
4035
4036   r = guestfs_strings (g, path);
4037   if (r == NULL) {
4038     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4039     return NULL;
4040   }
4041
4042   py_r = put_string_list (r);
4043   free_strings (r);
4044   return py_r;
4045 }
4046
4047 static PyObject *
4048 py_guestfs_strings_e (PyObject *self, PyObject *args)
4049 {
4050   PyObject *py_g;
4051   guestfs_h *g;
4052   PyObject *py_r;
4053   char **r;
4054   const char *encoding;
4055   const char *path;
4056
4057   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_strings_e",
4058                          &py_g, &encoding, &path))
4059     return NULL;
4060   g = get_handle (py_g);
4061
4062   r = guestfs_strings_e (g, encoding, path);
4063   if (r == NULL) {
4064     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4065     return NULL;
4066   }
4067
4068   py_r = put_string_list (r);
4069   free_strings (r);
4070   return py_r;
4071 }
4072
4073 static PyObject *
4074 py_guestfs_hexdump (PyObject *self, PyObject *args)
4075 {
4076   PyObject *py_g;
4077   guestfs_h *g;
4078   PyObject *py_r;
4079   char *r;
4080   const char *path;
4081
4082   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_hexdump",
4083                          &py_g, &path))
4084     return NULL;
4085   g = get_handle (py_g);
4086
4087   r = guestfs_hexdump (g, path);
4088   if (r == NULL) {
4089     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4090     return NULL;
4091   }
4092
4093   py_r = PyString_FromString (r);
4094   free (r);
4095   return py_r;
4096 }
4097
4098 static PyObject *
4099 py_guestfs_zerofree (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_zerofree",
4108                          &py_g, &device))
4109     return NULL;
4110   g = get_handle (py_g);
4111
4112   r = guestfs_zerofree (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 }
4122
4123 static PyObject *
4124 py_guestfs_pvresize (PyObject *self, PyObject *args)
4125 {
4126   PyObject *py_g;
4127   guestfs_h *g;
4128   PyObject *py_r;
4129   int r;
4130   const char *device;
4131
4132   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvresize",
4133                          &py_g, &device))
4134     return NULL;
4135   g = get_handle (py_g);
4136
4137   r = guestfs_pvresize (g, device);
4138   if (r == -1) {
4139     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4140     return NULL;
4141   }
4142
4143   Py_INCREF (Py_None);
4144   py_r = Py_None;
4145   return py_r;
4146 }
4147
4148 static PyObject *
4149 py_guestfs_sfdisk_N (PyObject *self, PyObject *args)
4150 {
4151   PyObject *py_g;
4152   guestfs_h *g;
4153   PyObject *py_r;
4154   int r;
4155   const char *device;
4156   int partnum;
4157   int cyls;
4158   int heads;
4159   int sectors;
4160   const char *line;
4161
4162   if (!PyArg_ParseTuple (args, (char *) "Osiiiis:guestfs_sfdisk_N",
4163                          &py_g, &device, &partnum, &cyls, &heads, &sectors, &line))
4164     return NULL;
4165   g = get_handle (py_g);
4166
4167   r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
4168   if (r == -1) {
4169     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4170     return NULL;
4171   }
4172
4173   Py_INCREF (Py_None);
4174   py_r = Py_None;
4175   return py_r;
4176 }
4177
4178 static PyObject *
4179 py_guestfs_sfdisk_l (PyObject *self, PyObject *args)
4180 {
4181   PyObject *py_g;
4182   guestfs_h *g;
4183   PyObject *py_r;
4184   char *r;
4185   const char *device;
4186
4187   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_l",
4188                          &py_g, &device))
4189     return NULL;
4190   g = get_handle (py_g);
4191
4192   r = guestfs_sfdisk_l (g, device);
4193   if (r == NULL) {
4194     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4195     return NULL;
4196   }
4197
4198   py_r = PyString_FromString (r);
4199   free (r);
4200   return py_r;
4201 }
4202
4203 static PyObject *
4204 py_guestfs_sfdisk_kernel_geometry (PyObject *self, PyObject *args)
4205 {
4206   PyObject *py_g;
4207   guestfs_h *g;
4208   PyObject *py_r;
4209   char *r;
4210   const char *device;
4211
4212   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_kernel_geometry",
4213                          &py_g, &device))
4214     return NULL;
4215   g = get_handle (py_g);
4216
4217   r = guestfs_sfdisk_kernel_geometry (g, device);
4218   if (r == NULL) {
4219     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4220     return NULL;
4221   }
4222
4223   py_r = PyString_FromString (r);
4224   free (r);
4225   return py_r;
4226 }
4227
4228 static PyObject *
4229 py_guestfs_sfdisk_disk_geometry (PyObject *self, PyObject *args)
4230 {
4231   PyObject *py_g;
4232   guestfs_h *g;
4233   PyObject *py_r;
4234   char *r;
4235   const char *device;
4236
4237   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_disk_geometry",
4238                          &py_g, &device))
4239     return NULL;
4240   g = get_handle (py_g);
4241
4242   r = guestfs_sfdisk_disk_geometry (g, device);
4243   if (r == NULL) {
4244     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4245     return NULL;
4246   }
4247
4248   py_r = PyString_FromString (r);
4249   free (r);
4250   return py_r;
4251 }
4252
4253 static PyObject *
4254 py_guestfs_vg_activate_all (PyObject *self, PyObject *args)
4255 {
4256   PyObject *py_g;
4257   guestfs_h *g;
4258   PyObject *py_r;
4259   int r;
4260   int activate;
4261
4262   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_vg_activate_all",
4263                          &py_g, &activate))
4264     return NULL;
4265   g = get_handle (py_g);
4266
4267   r = guestfs_vg_activate_all (g, activate);
4268   if (r == -1) {
4269     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4270     return NULL;
4271   }
4272
4273   Py_INCREF (Py_None);
4274   py_r = Py_None;
4275   return py_r;
4276 }
4277
4278 static PyObject *
4279 py_guestfs_vg_activate (PyObject *self, PyObject *args)
4280 {
4281   PyObject *py_g;
4282   guestfs_h *g;
4283   PyObject *py_r;
4284   int r;
4285   int activate;
4286   PyObject *py_volgroups;
4287   const char **volgroups;
4288
4289   if (!PyArg_ParseTuple (args, (char *) "OiO:guestfs_vg_activate",
4290                          &py_g, &activate, &py_volgroups))
4291     return NULL;
4292   g = get_handle (py_g);
4293   volgroups = get_string_list (py_volgroups);
4294   if (!volgroups) return NULL;
4295
4296   r = guestfs_vg_activate (g, activate, volgroups);
4297   free (volgroups);
4298   if (r == -1) {
4299     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4300     return NULL;
4301   }
4302
4303   Py_INCREF (Py_None);
4304   py_r = Py_None;
4305   return py_r;
4306 }
4307
4308 static PyObject *
4309 py_guestfs_lvresize (PyObject *self, PyObject *args)
4310 {
4311   PyObject *py_g;
4312   guestfs_h *g;
4313   PyObject *py_r;
4314   int r;
4315   const char *device;
4316   int mbytes;
4317
4318   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_lvresize",
4319                          &py_g, &device, &mbytes))
4320     return NULL;
4321   g = get_handle (py_g);
4322
4323   r = guestfs_lvresize (g, device, mbytes);
4324   if (r == -1) {
4325     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4326     return NULL;
4327   }
4328
4329   Py_INCREF (Py_None);
4330   py_r = Py_None;
4331   return py_r;
4332 }
4333
4334 static PyObject *
4335 py_guestfs_resize2fs (PyObject *self, PyObject *args)
4336 {
4337   PyObject *py_g;
4338   guestfs_h *g;
4339   PyObject *py_r;
4340   int r;
4341   const char *device;
4342
4343   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_resize2fs",
4344                          &py_g, &device))
4345     return NULL;
4346   g = get_handle (py_g);
4347
4348   r = guestfs_resize2fs (g, device);
4349   if (r == -1) {
4350     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4351     return NULL;
4352   }
4353
4354   Py_INCREF (Py_None);
4355   py_r = Py_None;
4356   return py_r;
4357 }
4358
4359 static PyObject *
4360 py_guestfs_find (PyObject *self, PyObject *args)
4361 {
4362   PyObject *py_g;
4363   guestfs_h *g;
4364   PyObject *py_r;
4365   char **r;
4366   const char *directory;
4367
4368   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_find",
4369                          &py_g, &directory))
4370     return NULL;
4371   g = get_handle (py_g);
4372
4373   r = guestfs_find (g, directory);
4374   if (r == NULL) {
4375     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4376     return NULL;
4377   }
4378
4379   py_r = put_string_list (r);
4380   free_strings (r);
4381   return py_r;
4382 }
4383
4384 static PyObject *
4385 py_guestfs_e2fsck_f (PyObject *self, PyObject *args)
4386 {
4387   PyObject *py_g;
4388   guestfs_h *g;
4389   PyObject *py_r;
4390   int r;
4391   const char *device;
4392
4393   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_e2fsck_f",
4394                          &py_g, &device))
4395     return NULL;
4396   g = get_handle (py_g);
4397
4398   r = guestfs_e2fsck_f (g, device);
4399   if (r == -1) {
4400     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4401     return NULL;
4402   }
4403
4404   Py_INCREF (Py_None);
4405   py_r = Py_None;
4406   return py_r;
4407 }
4408
4409 static PyObject *
4410 py_guestfs_sleep (PyObject *self, PyObject *args)
4411 {
4412   PyObject *py_g;
4413   guestfs_h *g;
4414   PyObject *py_r;
4415   int r;
4416   int secs;
4417
4418   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_sleep",
4419                          &py_g, &secs))
4420     return NULL;
4421   g = get_handle (py_g);
4422
4423   r = guestfs_sleep (g, secs);
4424   if (r == -1) {
4425     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4426     return NULL;
4427   }
4428
4429   Py_INCREF (Py_None);
4430   py_r = Py_None;
4431   return py_r;
4432 }
4433
4434 static PyObject *
4435 py_guestfs_ntfs_3g_probe (PyObject *self, PyObject *args)
4436 {
4437   PyObject *py_g;
4438   guestfs_h *g;
4439   PyObject *py_r;
4440   int r;
4441   int rw;
4442   const char *device;
4443
4444   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_ntfs_3g_probe",
4445                          &py_g, &rw, &device))
4446     return NULL;
4447   g = get_handle (py_g);
4448
4449   r = guestfs_ntfs_3g_probe (g, rw, device);
4450   if (r == -1) {
4451     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4452     return NULL;
4453   }
4454
4455   py_r = PyInt_FromLong ((long) r);
4456   return py_r;
4457 }
4458
4459 static PyObject *
4460 py_guestfs_sh (PyObject *self, PyObject *args)
4461 {
4462   PyObject *py_g;
4463   guestfs_h *g;
4464   PyObject *py_r;
4465   char *r;
4466   const char *command;
4467
4468   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sh",
4469                          &py_g, &command))
4470     return NULL;
4471   g = get_handle (py_g);
4472
4473   r = guestfs_sh (g, command);
4474   if (r == NULL) {
4475     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4476     return NULL;
4477   }
4478
4479   py_r = PyString_FromString (r);
4480   free (r);
4481   return py_r;
4482 }
4483
4484 static PyObject *
4485 py_guestfs_sh_lines (PyObject *self, PyObject *args)
4486 {
4487   PyObject *py_g;
4488   guestfs_h *g;
4489   PyObject *py_r;
4490   char **r;
4491   const char *command;
4492
4493   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sh_lines",
4494                          &py_g, &command))
4495     return NULL;
4496   g = get_handle (py_g);
4497
4498   r = guestfs_sh_lines (g, command);
4499   if (r == NULL) {
4500     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4501     return NULL;
4502   }
4503
4504   py_r = put_string_list (r);
4505   free_strings (r);
4506   return py_r;
4507 }
4508
4509 static PyObject *
4510 py_guestfs_glob_expand (PyObject *self, PyObject *args)
4511 {
4512   PyObject *py_g;
4513   guestfs_h *g;
4514   PyObject *py_r;
4515   char **r;
4516   const char *pattern;
4517
4518   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_glob_expand",
4519                          &py_g, &pattern))
4520     return NULL;
4521   g = get_handle (py_g);
4522
4523   r = guestfs_glob_expand (g, pattern);
4524   if (r == NULL) {
4525     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4526     return NULL;
4527   }
4528
4529   py_r = put_string_list (r);
4530   free_strings (r);
4531   return py_r;
4532 }
4533
4534 static PyObject *
4535 py_guestfs_scrub_device (PyObject *self, PyObject *args)
4536 {
4537   PyObject *py_g;
4538   guestfs_h *g;
4539   PyObject *py_r;
4540   int r;
4541   const char *device;
4542
4543   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_device",
4544                          &py_g, &device))
4545     return NULL;
4546   g = get_handle (py_g);
4547
4548   r = guestfs_scrub_device (g, device);
4549   if (r == -1) {
4550     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4551     return NULL;
4552   }
4553
4554   Py_INCREF (Py_None);
4555   py_r = Py_None;
4556   return py_r;
4557 }
4558
4559 static PyObject *
4560 py_guestfs_scrub_file (PyObject *self, PyObject *args)
4561 {
4562   PyObject *py_g;
4563   guestfs_h *g;
4564   PyObject *py_r;
4565   int r;
4566   const char *file;
4567
4568   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_file",
4569                          &py_g, &file))
4570     return NULL;
4571   g = get_handle (py_g);
4572
4573   r = guestfs_scrub_file (g, file);
4574   if (r == -1) {
4575     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4576     return NULL;
4577   }
4578
4579   Py_INCREF (Py_None);
4580   py_r = Py_None;
4581   return py_r;
4582 }
4583
4584 static PyObject *
4585 py_guestfs_scrub_freespace (PyObject *self, PyObject *args)
4586 {
4587   PyObject *py_g;
4588   guestfs_h *g;
4589   PyObject *py_r;
4590   int r;
4591   const char *dir;
4592
4593   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_freespace",
4594                          &py_g, &dir))
4595     return NULL;
4596   g = get_handle (py_g);
4597
4598   r = guestfs_scrub_freespace (g, dir);
4599   if (r == -1) {
4600     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4601     return NULL;
4602   }
4603
4604   Py_INCREF (Py_None);
4605   py_r = Py_None;
4606   return py_r;
4607 }
4608
4609 static PyObject *
4610 py_guestfs_mkdtemp (PyObject *self, PyObject *args)
4611 {
4612   PyObject *py_g;
4613   guestfs_h *g;
4614   PyObject *py_r;
4615   char *r;
4616   const char *template;
4617
4618   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdtemp",
4619                          &py_g, &template))
4620     return NULL;
4621   g = get_handle (py_g);
4622
4623   r = guestfs_mkdtemp (g, template);
4624   if (r == NULL) {
4625     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4626     return NULL;
4627   }
4628
4629   py_r = PyString_FromString (r);
4630   free (r);
4631   return py_r;
4632 }
4633
4634 static PyObject *
4635 py_guestfs_wc_l (PyObject *self, PyObject *args)
4636 {
4637   PyObject *py_g;
4638   guestfs_h *g;
4639   PyObject *py_r;
4640   int r;
4641   const char *path;
4642
4643   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_wc_l",
4644                          &py_g, &path))
4645     return NULL;
4646   g = get_handle (py_g);
4647
4648   r = guestfs_wc_l (g, path);
4649   if (r == -1) {
4650     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4651     return NULL;
4652   }
4653
4654   py_r = PyInt_FromLong ((long) r);
4655   return py_r;
4656 }
4657
4658 static PyObject *
4659 py_guestfs_wc_w (PyObject *self, PyObject *args)
4660 {
4661   PyObject *py_g;
4662   guestfs_h *g;
4663   PyObject *py_r;
4664   int r;
4665   const char *path;
4666
4667   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_wc_w",
4668                          &py_g, &path))
4669     return NULL;
4670   g = get_handle (py_g);
4671
4672   r = guestfs_wc_w (g, path);
4673   if (r == -1) {
4674     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4675     return NULL;
4676   }
4677
4678   py_r = PyInt_FromLong ((long) r);
4679   return py_r;
4680 }
4681
4682 static PyObject *
4683 py_guestfs_wc_c (PyObject *self, PyObject *args)
4684 {
4685   PyObject *py_g;
4686   guestfs_h *g;
4687   PyObject *py_r;
4688   int r;
4689   const char *path;
4690
4691   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_wc_c",
4692                          &py_g, &path))
4693     return NULL;
4694   g = get_handle (py_g);
4695
4696   r = guestfs_wc_c (g, path);
4697   if (r == -1) {
4698     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4699     return NULL;
4700   }
4701
4702   py_r = PyInt_FromLong ((long) r);
4703   return py_r;
4704 }
4705
4706 static PyObject *
4707 py_guestfs_head (PyObject *self, PyObject *args)
4708 {
4709   PyObject *py_g;
4710   guestfs_h *g;
4711   PyObject *py_r;
4712   char **r;
4713   const char *path;
4714
4715   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_head",
4716                          &py_g, &path))
4717     return NULL;
4718   g = get_handle (py_g);
4719
4720   r = guestfs_head (g, path);
4721   if (r == NULL) {
4722     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4723     return NULL;
4724   }
4725
4726   py_r = put_string_list (r);
4727   free_strings (r);
4728   return py_r;
4729 }
4730
4731 static PyObject *
4732 py_guestfs_head_n (PyObject *self, PyObject *args)
4733 {
4734   PyObject *py_g;
4735   guestfs_h *g;
4736   PyObject *py_r;
4737   char **r;
4738   int nrlines;
4739   const char *path;
4740
4741   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_head_n",
4742                          &py_g, &nrlines, &path))
4743     return NULL;
4744   g = get_handle (py_g);
4745
4746   r = guestfs_head_n (g, nrlines, path);
4747   if (r == NULL) {
4748     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4749     return NULL;
4750   }
4751
4752   py_r = put_string_list (r);
4753   free_strings (r);
4754   return py_r;
4755 }
4756
4757 static PyObject *
4758 py_guestfs_tail (PyObject *self, PyObject *args)
4759 {
4760   PyObject *py_g;
4761   guestfs_h *g;
4762   PyObject *py_r;
4763   char **r;
4764   const char *path;
4765
4766   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tail",
4767                          &py_g, &path))
4768     return NULL;
4769   g = get_handle (py_g);
4770
4771   r = guestfs_tail (g, path);
4772   if (r == NULL) {
4773     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4774     return NULL;
4775   }
4776
4777   py_r = put_string_list (r);
4778   free_strings (r);
4779   return py_r;
4780 }
4781
4782 static PyObject *
4783 py_guestfs_tail_n (PyObject *self, PyObject *args)
4784 {
4785   PyObject *py_g;
4786   guestfs_h *g;
4787   PyObject *py_r;
4788   char **r;
4789   int nrlines;
4790   const char *path;
4791
4792   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_tail_n",
4793                          &py_g, &nrlines, &path))
4794     return NULL;
4795   g = get_handle (py_g);
4796
4797   r = guestfs_tail_n (g, nrlines, path);
4798   if (r == NULL) {
4799     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4800     return NULL;
4801   }
4802
4803   py_r = put_string_list (r);
4804   free_strings (r);
4805   return py_r;
4806 }
4807
4808 static PyObject *
4809 py_guestfs_df (PyObject *self, PyObject *args)
4810 {
4811   PyObject *py_g;
4812   guestfs_h *g;
4813   PyObject *py_r;
4814   char *r;
4815
4816   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_df",
4817                          &py_g))
4818     return NULL;
4819   g = get_handle (py_g);
4820
4821   r = guestfs_df (g);
4822   if (r == NULL) {
4823     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4824     return NULL;
4825   }
4826
4827   py_r = PyString_FromString (r);
4828   free (r);
4829   return py_r;
4830 }
4831
4832 static PyObject *
4833 py_guestfs_df_h (PyObject *self, PyObject *args)
4834 {
4835   PyObject *py_g;
4836   guestfs_h *g;
4837   PyObject *py_r;
4838   char *r;
4839
4840   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_df_h",
4841                          &py_g))
4842     return NULL;
4843   g = get_handle (py_g);
4844
4845   r = guestfs_df_h (g);
4846   if (r == NULL) {
4847     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4848     return NULL;
4849   }
4850
4851   py_r = PyString_FromString (r);
4852   free (r);
4853   return py_r;
4854 }
4855
4856 static PyObject *
4857 py_guestfs_du (PyObject *self, PyObject *args)
4858 {
4859   PyObject *py_g;
4860   guestfs_h *g;
4861   PyObject *py_r;
4862   int64_t r;
4863   const char *path;
4864
4865   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_du",
4866                          &py_g, &path))
4867     return NULL;
4868   g = get_handle (py_g);
4869
4870   r = guestfs_du (g, path);
4871   if (r == -1) {
4872     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4873     return NULL;
4874   }
4875
4876   py_r = PyLong_FromLongLong (r);
4877   return py_r;
4878 }
4879
4880 static PyObject *
4881 py_guestfs_initrd_list (PyObject *self, PyObject *args)
4882 {
4883   PyObject *py_g;
4884   guestfs_h *g;
4885   PyObject *py_r;
4886   char **r;
4887   const char *path;
4888
4889   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_initrd_list",
4890                          &py_g, &path))
4891     return NULL;
4892   g = get_handle (py_g);
4893
4894   r = guestfs_initrd_list (g, path);
4895   if (r == NULL) {
4896     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4897     return NULL;
4898   }
4899
4900   py_r = put_string_list (r);
4901   free_strings (r);
4902   return py_r;
4903 }
4904
4905 static PyMethodDef methods[] = {
4906   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
4907   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
4908   { (char *) "test0", py_guestfs_test0, METH_VARARGS, NULL },
4909   { (char *) "test0rint", py_guestfs_test0rint, METH_VARARGS, NULL },
4910   { (char *) "test0rinterr", py_guestfs_test0rinterr, METH_VARARGS, NULL },
4911   { (char *) "test0rint64", py_guestfs_test0rint64, METH_VARARGS, NULL },
4912   { (char *) "test0rint64err", py_guestfs_test0rint64err, METH_VARARGS, NULL },
4913   { (char *) "test0rbool", py_guestfs_test0rbool, METH_VARARGS, NULL },
4914   { (char *) "test0rboolerr", py_guestfs_test0rboolerr, METH_VARARGS, NULL },
4915   { (char *) "test0rconststring", py_guestfs_test0rconststring, METH_VARARGS, NULL },
4916   { (char *) "test0rconststringerr", py_guestfs_test0rconststringerr, METH_VARARGS, NULL },
4917   { (char *) "test0rstring", py_guestfs_test0rstring, METH_VARARGS, NULL },
4918   { (char *) "test0rstringerr", py_guestfs_test0rstringerr, METH_VARARGS, NULL },
4919   { (char *) "test0rstringlist", py_guestfs_test0rstringlist, METH_VARARGS, NULL },
4920   { (char *) "test0rstringlisterr", py_guestfs_test0rstringlisterr, METH_VARARGS, NULL },
4921   { (char *) "test0rintbool", py_guestfs_test0rintbool, METH_VARARGS, NULL },
4922   { (char *) "test0rintboolerr", py_guestfs_test0rintboolerr, METH_VARARGS, NULL },
4923   { (char *) "test0rpvlist", py_guestfs_test0rpvlist, METH_VARARGS, NULL },
4924   { (char *) "test0rpvlisterr", py_guestfs_test0rpvlisterr, METH_VARARGS, NULL },
4925   { (char *) "test0rvglist", py_guestfs_test0rvglist, METH_VARARGS, NULL },
4926   { (char *) "test0rvglisterr", py_guestfs_test0rvglisterr, METH_VARARGS, NULL },
4927   { (char *) "test0rlvlist", py_guestfs_test0rlvlist, METH_VARARGS, NULL },
4928   { (char *) "test0rlvlisterr", py_guestfs_test0rlvlisterr, METH_VARARGS, NULL },
4929   { (char *) "test0rstat", py_guestfs_test0rstat, METH_VARARGS, NULL },
4930   { (char *) "test0rstaterr", py_guestfs_test0rstaterr, METH_VARARGS, NULL },
4931   { (char *) "test0rstatvfs", py_guestfs_test0rstatvfs, METH_VARARGS, NULL },
4932   { (char *) "test0rstatvfserr", py_guestfs_test0rstatvfserr, METH_VARARGS, NULL },
4933   { (char *) "test0rhashtable", py_guestfs_test0rhashtable, METH_VARARGS, NULL },
4934   { (char *) "test0rhashtableerr", py_guestfs_test0rhashtableerr, METH_VARARGS, NULL },
4935   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
4936   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
4937   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
4938   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
4939   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
4940   { (char *) "add_drive_ro", py_guestfs_add_drive_ro, METH_VARARGS, NULL },
4941   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
4942   { (char *) "set_qemu", py_guestfs_set_qemu, METH_VARARGS, NULL },
4943   { (char *) "get_qemu", py_guestfs_get_qemu, METH_VARARGS, NULL },
4944   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
4945   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
4946   { (char *) "set_append", py_guestfs_set_append, METH_VARARGS, NULL },
4947   { (char *) "get_append", py_guestfs_get_append, METH_VARARGS, NULL },
4948   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
4949   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
4950   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
4951   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
4952   { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
4953   { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
4954   { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
4955   { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
4956   { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
4957   { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL },
4958   { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL },
4959   { (char *) "end_busy", py_guestfs_end_busy, METH_VARARGS, NULL },
4960   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
4961   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
4962   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
4963   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
4964   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
4965   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
4966   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
4967   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
4968   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
4969   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
4970   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
4971   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
4972   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
4973   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
4974   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
4975   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
4976   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
4977   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
4978   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
4979   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
4980   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
4981   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
4982   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
4983   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
4984   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
4985   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
4986   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
4987   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
4988   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
4989   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
4990   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
4991   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
4992   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
4993   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
4994   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
4995   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
4996   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
4997   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
4998   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
4999   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
5000   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
5001   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
5002   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
5003   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
5004   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
5005   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
5006   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
5007   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
5008   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
5009   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
5010   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
5011   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
5012   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
5013   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
5014   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
5015   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
5016   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
5017   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
5018   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
5019   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
5020   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
5021   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
5022   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
5023   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
5024   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
5025   { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
5026   { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
5027   { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL },
5028   { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL },
5029   { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL },
5030   { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL },
5031   { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL },
5032   { (char *) "mount_ro", py_guestfs_mount_ro, METH_VARARGS, NULL },
5033   { (char *) "mount_options", py_guestfs_mount_options, METH_VARARGS, NULL },
5034   { (char *) "mount_vfs", py_guestfs_mount_vfs, METH_VARARGS, NULL },
5035   { (char *) "debug", py_guestfs_debug, METH_VARARGS, NULL },
5036   { (char *) "lvremove", py_guestfs_lvremove, METH_VARARGS, NULL },
5037   { (char *) "vgremove", py_guestfs_vgremove, METH_VARARGS, NULL },
5038   { (char *) "pvremove", py_guestfs_pvremove, METH_VARARGS, NULL },
5039   { (char *) "set_e2label", py_guestfs_set_e2label, METH_VARARGS, NULL },
5040   { (char *) "get_e2label", py_guestfs_get_e2label, METH_VARARGS, NULL },
5041   { (char *) "set_e2uuid", py_guestfs_set_e2uuid, METH_VARARGS, NULL },
5042   { (char *) "get_e2uuid", py_guestfs_get_e2uuid, METH_VARARGS, NULL },
5043   { (char *) "fsck", py_guestfs_fsck, METH_VARARGS, NULL },
5044   { (char *) "zero", py_guestfs_zero, METH_VARARGS, NULL },
5045   { (char *) "grub_install", py_guestfs_grub_install, METH_VARARGS, NULL },
5046   { (char *) "cp", py_guestfs_cp, METH_VARARGS, NULL },
5047   { (char *) "cp_a", py_guestfs_cp_a, METH_VARARGS, NULL },
5048   { (char *) "mv", py_guestfs_mv, METH_VARARGS, NULL },
5049   { (char *) "drop_caches", py_guestfs_drop_caches, METH_VARARGS, NULL },
5050   { (char *) "dmesg", py_guestfs_dmesg, METH_VARARGS, NULL },
5051   { (char *) "ping_daemon", py_guestfs_ping_daemon, METH_VARARGS, NULL },
5052   { (char *) "equal", py_guestfs_equal, METH_VARARGS, NULL },
5053   { (char *) "strings", py_guestfs_strings, METH_VARARGS, NULL },
5054   { (char *) "strings_e", py_guestfs_strings_e, METH_VARARGS, NULL },
5055   { (char *) "hexdump", py_guestfs_hexdump, METH_VARARGS, NULL },
5056   { (char *) "zerofree", py_guestfs_zerofree, METH_VARARGS, NULL },
5057   { (char *) "pvresize", py_guestfs_pvresize, METH_VARARGS, NULL },
5058   { (char *) "sfdisk_N", py_guestfs_sfdisk_N, METH_VARARGS, NULL },
5059   { (char *) "sfdisk_l", py_guestfs_sfdisk_l, METH_VARARGS, NULL },
5060   { (char *) "sfdisk_kernel_geometry", py_guestfs_sfdisk_kernel_geometry, METH_VARARGS, NULL },
5061   { (char *) "sfdisk_disk_geometry", py_guestfs_sfdisk_disk_geometry, METH_VARARGS, NULL },
5062   { (char *) "vg_activate_all", py_guestfs_vg_activate_all, METH_VARARGS, NULL },
5063   { (char *) "vg_activate", py_guestfs_vg_activate, METH_VARARGS, NULL },
5064   { (char *) "lvresize", py_guestfs_lvresize, METH_VARARGS, NULL },
5065   { (char *) "resize2fs", py_guestfs_resize2fs, METH_VARARGS, NULL },
5066   { (char *) "find", py_guestfs_find, METH_VARARGS, NULL },
5067   { (char *) "e2fsck_f", py_guestfs_e2fsck_f, METH_VARARGS, NULL },
5068   { (char *) "sleep", py_guestfs_sleep, METH_VARARGS, NULL },
5069   { (char *) "ntfs_3g_probe", py_guestfs_ntfs_3g_probe, METH_VARARGS, NULL },
5070   { (char *) "sh", py_guestfs_sh, METH_VARARGS, NULL },
5071   { (char *) "sh_lines", py_guestfs_sh_lines, METH_VARARGS, NULL },
5072   { (char *) "glob_expand", py_guestfs_glob_expand, METH_VARARGS, NULL },
5073   { (char *) "scrub_device", py_guestfs_scrub_device, METH_VARARGS, NULL },
5074   { (char *) "scrub_file", py_guestfs_scrub_file, METH_VARARGS, NULL },
5075   { (char *) "scrub_freespace", py_guestfs_scrub_freespace, METH_VARARGS, NULL },
5076   { (char *) "mkdtemp", py_guestfs_mkdtemp, METH_VARARGS, NULL },
5077   { (char *) "wc_l", py_guestfs_wc_l, METH_VARARGS, NULL },
5078   { (char *) "wc_w", py_guestfs_wc_w, METH_VARARGS, NULL },
5079   { (char *) "wc_c", py_guestfs_wc_c, METH_VARARGS, NULL },
5080   { (char *) "head", py_guestfs_head, METH_VARARGS, NULL },
5081   { (char *) "head_n", py_guestfs_head_n, METH_VARARGS, NULL },
5082   { (char *) "tail", py_guestfs_tail, METH_VARARGS, NULL },
5083   { (char *) "tail_n", py_guestfs_tail_n, METH_VARARGS, NULL },
5084   { (char *) "df", py_guestfs_df, METH_VARARGS, NULL },
5085   { (char *) "df_h", py_guestfs_df_h, METH_VARARGS, NULL },
5086   { (char *) "du", py_guestfs_du, METH_VARARGS, NULL },
5087   { (char *) "initrd_list", py_guestfs_initrd_list, METH_VARARGS, NULL },
5088   { NULL, NULL, 0, NULL }
5089 };
5090
5091 void
5092 initlibguestfsmod (void)
5093 {
5094   static int initialized = 0;
5095
5096   if (initialized) return;
5097   Py_InitModule ((char *) "libguestfsmod", methods);
5098   initialized = 1;
5099 }