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_set_memsize (PyObject *self, PyObject *args)
1661 {
1662   PyObject *py_g;
1663   guestfs_h *g;
1664   PyObject *py_r;
1665   int r;
1666   int memsize;
1667
1668   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_memsize",
1669                          &py_g, &memsize))
1670     return NULL;
1671   g = get_handle (py_g);
1672
1673   r = guestfs_set_memsize (g, memsize);
1674   if (r == -1) {
1675     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1676     return NULL;
1677   }
1678
1679   Py_INCREF (Py_None);
1680   py_r = Py_None;
1681   return py_r;
1682 }
1683
1684 static PyObject *
1685 py_guestfs_get_memsize (PyObject *self, PyObject *args)
1686 {
1687   PyObject *py_g;
1688   guestfs_h *g;
1689   PyObject *py_r;
1690   int r;
1691
1692   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_memsize",
1693                          &py_g))
1694     return NULL;
1695   g = get_handle (py_g);
1696
1697   r = guestfs_get_memsize (g);
1698   if (r == -1) {
1699     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1700     return NULL;
1701   }
1702
1703   py_r = PyInt_FromLong ((long) r);
1704   return py_r;
1705 }
1706
1707 static PyObject *
1708 py_guestfs_mount (PyObject *self, PyObject *args)
1709 {
1710   PyObject *py_g;
1711   guestfs_h *g;
1712   PyObject *py_r;
1713   int r;
1714   const char *device;
1715   const char *mountpoint;
1716
1717   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
1718                          &py_g, &device, &mountpoint))
1719     return NULL;
1720   g = get_handle (py_g);
1721
1722   r = guestfs_mount (g, device, mountpoint);
1723   if (r == -1) {
1724     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1725     return NULL;
1726   }
1727
1728   Py_INCREF (Py_None);
1729   py_r = Py_None;
1730   return py_r;
1731 }
1732
1733 static PyObject *
1734 py_guestfs_sync (PyObject *self, PyObject *args)
1735 {
1736   PyObject *py_g;
1737   guestfs_h *g;
1738   PyObject *py_r;
1739   int r;
1740
1741   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
1742                          &py_g))
1743     return NULL;
1744   g = get_handle (py_g);
1745
1746   r = guestfs_sync (g);
1747   if (r == -1) {
1748     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1749     return NULL;
1750   }
1751
1752   Py_INCREF (Py_None);
1753   py_r = Py_None;
1754   return py_r;
1755 }
1756
1757 static PyObject *
1758 py_guestfs_touch (PyObject *self, PyObject *args)
1759 {
1760   PyObject *py_g;
1761   guestfs_h *g;
1762   PyObject *py_r;
1763   int r;
1764   const char *path;
1765
1766   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
1767                          &py_g, &path))
1768     return NULL;
1769   g = get_handle (py_g);
1770
1771   r = guestfs_touch (g, path);
1772   if (r == -1) {
1773     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1774     return NULL;
1775   }
1776
1777   Py_INCREF (Py_None);
1778   py_r = Py_None;
1779   return py_r;
1780 }
1781
1782 static PyObject *
1783 py_guestfs_cat (PyObject *self, PyObject *args)
1784 {
1785   PyObject *py_g;
1786   guestfs_h *g;
1787   PyObject *py_r;
1788   char *r;
1789   const char *path;
1790
1791   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
1792                          &py_g, &path))
1793     return NULL;
1794   g = get_handle (py_g);
1795
1796   r = guestfs_cat (g, path);
1797   if (r == NULL) {
1798     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1799     return NULL;
1800   }
1801
1802   py_r = PyString_FromString (r);
1803   free (r);
1804   return py_r;
1805 }
1806
1807 static PyObject *
1808 py_guestfs_ll (PyObject *self, PyObject *args)
1809 {
1810   PyObject *py_g;
1811   guestfs_h *g;
1812   PyObject *py_r;
1813   char *r;
1814   const char *directory;
1815
1816   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
1817                          &py_g, &directory))
1818     return NULL;
1819   g = get_handle (py_g);
1820
1821   r = guestfs_ll (g, directory);
1822   if (r == NULL) {
1823     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1824     return NULL;
1825   }
1826
1827   py_r = PyString_FromString (r);
1828   free (r);
1829   return py_r;
1830 }
1831
1832 static PyObject *
1833 py_guestfs_ls (PyObject *self, PyObject *args)
1834 {
1835   PyObject *py_g;
1836   guestfs_h *g;
1837   PyObject *py_r;
1838   char **r;
1839   const char *directory;
1840
1841   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
1842                          &py_g, &directory))
1843     return NULL;
1844   g = get_handle (py_g);
1845
1846   r = guestfs_ls (g, directory);
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_list_devices (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_list_devices",
1866                          &py_g))
1867     return NULL;
1868   g = get_handle (py_g);
1869
1870   r = guestfs_list_devices (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_list_partitions (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_list_partitions",
1890                          &py_g))
1891     return NULL;
1892   g = get_handle (py_g);
1893
1894   r = guestfs_list_partitions (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_pvs (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_pvs",
1914                          &py_g))
1915     return NULL;
1916   g = get_handle (py_g);
1917
1918   r = guestfs_pvs (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_vgs (PyObject *self, PyObject *args)
1931 {
1932   PyObject *py_g;
1933   guestfs_h *g;
1934   PyObject *py_r;
1935   char **r;
1936
1937   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
1938                          &py_g))
1939     return NULL;
1940   g = get_handle (py_g);
1941
1942   r = guestfs_vgs (g);
1943   if (r == NULL) {
1944     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1945     return NULL;
1946   }
1947
1948   py_r = put_string_list (r);
1949   free_strings (r);
1950   return py_r;
1951 }
1952
1953 static PyObject *
1954 py_guestfs_lvs (PyObject *self, PyObject *args)
1955 {
1956   PyObject *py_g;
1957   guestfs_h *g;
1958   PyObject *py_r;
1959   char **r;
1960
1961   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
1962                          &py_g))
1963     return NULL;
1964   g = get_handle (py_g);
1965
1966   r = guestfs_lvs (g);
1967   if (r == NULL) {
1968     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1969     return NULL;
1970   }
1971
1972   py_r = put_string_list (r);
1973   free_strings (r);
1974   return py_r;
1975 }
1976
1977 static PyObject *
1978 py_guestfs_pvs_full (PyObject *self, PyObject *args)
1979 {
1980   PyObject *py_g;
1981   guestfs_h *g;
1982   PyObject *py_r;
1983   struct guestfs_lvm_pv_list *r;
1984
1985   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
1986                          &py_g))
1987     return NULL;
1988   g = get_handle (py_g);
1989
1990   r = guestfs_pvs_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_pv_list (r);
1997   guestfs_free_lvm_pv_list (r);
1998   return py_r;
1999 }
2000
2001 static PyObject *
2002 py_guestfs_vgs_full (PyObject *self, PyObject *args)
2003 {
2004   PyObject *py_g;
2005   guestfs_h *g;
2006   PyObject *py_r;
2007   struct guestfs_lvm_vg_list *r;
2008
2009   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
2010                          &py_g))
2011     return NULL;
2012   g = get_handle (py_g);
2013
2014   r = guestfs_vgs_full (g);
2015   if (r == NULL) {
2016     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2017     return NULL;
2018   }
2019
2020   py_r = put_lvm_vg_list (r);
2021   guestfs_free_lvm_vg_list (r);
2022   return py_r;
2023 }
2024
2025 static PyObject *
2026 py_guestfs_lvs_full (PyObject *self, PyObject *args)
2027 {
2028   PyObject *py_g;
2029   guestfs_h *g;
2030   PyObject *py_r;
2031   struct guestfs_lvm_lv_list *r;
2032
2033   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
2034                          &py_g))
2035     return NULL;
2036   g = get_handle (py_g);
2037
2038   r = guestfs_lvs_full (g);
2039   if (r == NULL) {
2040     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2041     return NULL;
2042   }
2043
2044   py_r = put_lvm_lv_list (r);
2045   guestfs_free_lvm_lv_list (r);
2046   return py_r;
2047 }
2048
2049 static PyObject *
2050 py_guestfs_read_lines (PyObject *self, PyObject *args)
2051 {
2052   PyObject *py_g;
2053   guestfs_h *g;
2054   PyObject *py_r;
2055   char **r;
2056   const char *path;
2057
2058   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
2059                          &py_g, &path))
2060     return NULL;
2061   g = get_handle (py_g);
2062
2063   r = guestfs_read_lines (g, path);
2064   if (r == NULL) {
2065     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2066     return NULL;
2067   }
2068
2069   py_r = put_string_list (r);
2070   free_strings (r);
2071   return py_r;
2072 }
2073
2074 static PyObject *
2075 py_guestfs_aug_init (PyObject *self, PyObject *args)
2076 {
2077   PyObject *py_g;
2078   guestfs_h *g;
2079   PyObject *py_r;
2080   int r;
2081   const char *root;
2082   int flags;
2083
2084   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
2085                          &py_g, &root, &flags))
2086     return NULL;
2087   g = get_handle (py_g);
2088
2089   r = guestfs_aug_init (g, root, flags);
2090   if (r == -1) {
2091     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2092     return NULL;
2093   }
2094
2095   Py_INCREF (Py_None);
2096   py_r = Py_None;
2097   return py_r;
2098 }
2099
2100 static PyObject *
2101 py_guestfs_aug_close (PyObject *self, PyObject *args)
2102 {
2103   PyObject *py_g;
2104   guestfs_h *g;
2105   PyObject *py_r;
2106   int r;
2107
2108   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
2109                          &py_g))
2110     return NULL;
2111   g = get_handle (py_g);
2112
2113   r = guestfs_aug_close (g);
2114   if (r == -1) {
2115     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2116     return NULL;
2117   }
2118
2119   Py_INCREF (Py_None);
2120   py_r = Py_None;
2121   return py_r;
2122 }
2123
2124 static PyObject *
2125 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
2126 {
2127   PyObject *py_g;
2128   guestfs_h *g;
2129   PyObject *py_r;
2130   int r;
2131   const char *name;
2132   const char *expr;
2133
2134   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
2135                          &py_g, &name, &expr))
2136     return NULL;
2137   g = get_handle (py_g);
2138
2139   r = guestfs_aug_defvar (g, name, expr);
2140   if (r == -1) {
2141     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2142     return NULL;
2143   }
2144
2145   py_r = PyInt_FromLong ((long) r);
2146   return py_r;
2147 }
2148
2149 static PyObject *
2150 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
2151 {
2152   PyObject *py_g;
2153   guestfs_h *g;
2154   PyObject *py_r;
2155   struct guestfs_int_bool *r;
2156   const char *name;
2157   const char *expr;
2158   const char *val;
2159
2160   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
2161                          &py_g, &name, &expr, &val))
2162     return NULL;
2163   g = get_handle (py_g);
2164
2165   r = guestfs_aug_defnode (g, name, expr, val);
2166   if (r == NULL) {
2167     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2168     return NULL;
2169   }
2170
2171   py_r = PyTuple_New (2);
2172   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
2173   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
2174   guestfs_free_int_bool (r);
2175   return py_r;
2176 }
2177
2178 static PyObject *
2179 py_guestfs_aug_get (PyObject *self, PyObject *args)
2180 {
2181   PyObject *py_g;
2182   guestfs_h *g;
2183   PyObject *py_r;
2184   char *r;
2185   const char *path;
2186
2187   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
2188                          &py_g, &path))
2189     return NULL;
2190   g = get_handle (py_g);
2191
2192   r = guestfs_aug_get (g, path);
2193   if (r == NULL) {
2194     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2195     return NULL;
2196   }
2197
2198   py_r = PyString_FromString (r);
2199   free (r);
2200   return py_r;
2201 }
2202
2203 static PyObject *
2204 py_guestfs_aug_set (PyObject *self, PyObject *args)
2205 {
2206   PyObject *py_g;
2207   guestfs_h *g;
2208   PyObject *py_r;
2209   int r;
2210   const char *path;
2211   const char *val;
2212
2213   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
2214                          &py_g, &path, &val))
2215     return NULL;
2216   g = get_handle (py_g);
2217
2218   r = guestfs_aug_set (g, path, val);
2219   if (r == -1) {
2220     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2221     return NULL;
2222   }
2223
2224   Py_INCREF (Py_None);
2225   py_r = Py_None;
2226   return py_r;
2227 }
2228
2229 static PyObject *
2230 py_guestfs_aug_insert (PyObject *self, PyObject *args)
2231 {
2232   PyObject *py_g;
2233   guestfs_h *g;
2234   PyObject *py_r;
2235   int r;
2236   const char *path;
2237   const char *label;
2238   int before;
2239
2240   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
2241                          &py_g, &path, &label, &before))
2242     return NULL;
2243   g = get_handle (py_g);
2244
2245   r = guestfs_aug_insert (g, path, label, before);
2246   if (r == -1) {
2247     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2248     return NULL;
2249   }
2250
2251   Py_INCREF (Py_None);
2252   py_r = Py_None;
2253   return py_r;
2254 }
2255
2256 static PyObject *
2257 py_guestfs_aug_rm (PyObject *self, PyObject *args)
2258 {
2259   PyObject *py_g;
2260   guestfs_h *g;
2261   PyObject *py_r;
2262   int r;
2263   const char *path;
2264
2265   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
2266                          &py_g, &path))
2267     return NULL;
2268   g = get_handle (py_g);
2269
2270   r = guestfs_aug_rm (g, path);
2271   if (r == -1) {
2272     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2273     return NULL;
2274   }
2275
2276   py_r = PyInt_FromLong ((long) r);
2277   return py_r;
2278 }
2279
2280 static PyObject *
2281 py_guestfs_aug_mv (PyObject *self, PyObject *args)
2282 {
2283   PyObject *py_g;
2284   guestfs_h *g;
2285   PyObject *py_r;
2286   int r;
2287   const char *src;
2288   const char *dest;
2289
2290   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
2291                          &py_g, &src, &dest))
2292     return NULL;
2293   g = get_handle (py_g);
2294
2295   r = guestfs_aug_mv (g, src, dest);
2296   if (r == -1) {
2297     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2298     return NULL;
2299   }
2300
2301   Py_INCREF (Py_None);
2302   py_r = Py_None;
2303   return py_r;
2304 }
2305
2306 static PyObject *
2307 py_guestfs_aug_match (PyObject *self, PyObject *args)
2308 {
2309   PyObject *py_g;
2310   guestfs_h *g;
2311   PyObject *py_r;
2312   char **r;
2313   const char *path;
2314
2315   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
2316                          &py_g, &path))
2317     return NULL;
2318   g = get_handle (py_g);
2319
2320   r = guestfs_aug_match (g, path);
2321   if (r == NULL) {
2322     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2323     return NULL;
2324   }
2325
2326   py_r = put_string_list (r);
2327   free_strings (r);
2328   return py_r;
2329 }
2330
2331 static PyObject *
2332 py_guestfs_aug_save (PyObject *self, PyObject *args)
2333 {
2334   PyObject *py_g;
2335   guestfs_h *g;
2336   PyObject *py_r;
2337   int r;
2338
2339   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
2340                          &py_g))
2341     return NULL;
2342   g = get_handle (py_g);
2343
2344   r = guestfs_aug_save (g);
2345   if (r == -1) {
2346     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2347     return NULL;
2348   }
2349
2350   Py_INCREF (Py_None);
2351   py_r = Py_None;
2352   return py_r;
2353 }
2354
2355 static PyObject *
2356 py_guestfs_aug_load (PyObject *self, PyObject *args)
2357 {
2358   PyObject *py_g;
2359   guestfs_h *g;
2360   PyObject *py_r;
2361   int r;
2362
2363   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
2364                          &py_g))
2365     return NULL;
2366   g = get_handle (py_g);
2367
2368   r = guestfs_aug_load (g);
2369   if (r == -1) {
2370     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2371     return NULL;
2372   }
2373
2374   Py_INCREF (Py_None);
2375   py_r = Py_None;
2376   return py_r;
2377 }
2378
2379 static PyObject *
2380 py_guestfs_aug_ls (PyObject *self, PyObject *args)
2381 {
2382   PyObject *py_g;
2383   guestfs_h *g;
2384   PyObject *py_r;
2385   char **r;
2386   const char *path;
2387
2388   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
2389                          &py_g, &path))
2390     return NULL;
2391   g = get_handle (py_g);
2392
2393   r = guestfs_aug_ls (g, path);
2394   if (r == NULL) {
2395     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2396     return NULL;
2397   }
2398
2399   py_r = put_string_list (r);
2400   free_strings (r);
2401   return py_r;
2402 }
2403
2404 static PyObject *
2405 py_guestfs_rm (PyObject *self, PyObject *args)
2406 {
2407   PyObject *py_g;
2408   guestfs_h *g;
2409   PyObject *py_r;
2410   int r;
2411   const char *path;
2412
2413   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
2414                          &py_g, &path))
2415     return NULL;
2416   g = get_handle (py_g);
2417
2418   r = guestfs_rm (g, path);
2419   if (r == -1) {
2420     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2421     return NULL;
2422   }
2423
2424   Py_INCREF (Py_None);
2425   py_r = Py_None;
2426   return py_r;
2427 }
2428
2429 static PyObject *
2430 py_guestfs_rmdir (PyObject *self, PyObject *args)
2431 {
2432   PyObject *py_g;
2433   guestfs_h *g;
2434   PyObject *py_r;
2435   int r;
2436   const char *path;
2437
2438   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
2439                          &py_g, &path))
2440     return NULL;
2441   g = get_handle (py_g);
2442
2443   r = guestfs_rmdir (g, path);
2444   if (r == -1) {
2445     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2446     return NULL;
2447   }
2448
2449   Py_INCREF (Py_None);
2450   py_r = Py_None;
2451   return py_r;
2452 }
2453
2454 static PyObject *
2455 py_guestfs_rm_rf (PyObject *self, PyObject *args)
2456 {
2457   PyObject *py_g;
2458   guestfs_h *g;
2459   PyObject *py_r;
2460   int r;
2461   const char *path;
2462
2463   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
2464                          &py_g, &path))
2465     return NULL;
2466   g = get_handle (py_g);
2467
2468   r = guestfs_rm_rf (g, path);
2469   if (r == -1) {
2470     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2471     return NULL;
2472   }
2473
2474   Py_INCREF (Py_None);
2475   py_r = Py_None;
2476   return py_r;
2477 }
2478
2479 static PyObject *
2480 py_guestfs_mkdir (PyObject *self, PyObject *args)
2481 {
2482   PyObject *py_g;
2483   guestfs_h *g;
2484   PyObject *py_r;
2485   int r;
2486   const char *path;
2487
2488   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
2489                          &py_g, &path))
2490     return NULL;
2491   g = get_handle (py_g);
2492
2493   r = guestfs_mkdir (g, path);
2494   if (r == -1) {
2495     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2496     return NULL;
2497   }
2498
2499   Py_INCREF (Py_None);
2500   py_r = Py_None;
2501   return py_r;
2502 }
2503
2504 static PyObject *
2505 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
2506 {
2507   PyObject *py_g;
2508   guestfs_h *g;
2509   PyObject *py_r;
2510   int r;
2511   const char *path;
2512
2513   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
2514                          &py_g, &path))
2515     return NULL;
2516   g = get_handle (py_g);
2517
2518   r = guestfs_mkdir_p (g, path);
2519   if (r == -1) {
2520     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2521     return NULL;
2522   }
2523
2524   Py_INCREF (Py_None);
2525   py_r = Py_None;
2526   return py_r;
2527 }
2528
2529 static PyObject *
2530 py_guestfs_chmod (PyObject *self, PyObject *args)
2531 {
2532   PyObject *py_g;
2533   guestfs_h *g;
2534   PyObject *py_r;
2535   int r;
2536   int mode;
2537   const char *path;
2538
2539   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
2540                          &py_g, &mode, &path))
2541     return NULL;
2542   g = get_handle (py_g);
2543
2544   r = guestfs_chmod (g, mode, path);
2545   if (r == -1) {
2546     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2547     return NULL;
2548   }
2549
2550   Py_INCREF (Py_None);
2551   py_r = Py_None;
2552   return py_r;
2553 }
2554
2555 static PyObject *
2556 py_guestfs_chown (PyObject *self, PyObject *args)
2557 {
2558   PyObject *py_g;
2559   guestfs_h *g;
2560   PyObject *py_r;
2561   int r;
2562   int owner;
2563   int group;
2564   const char *path;
2565
2566   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
2567                          &py_g, &owner, &group, &path))
2568     return NULL;
2569   g = get_handle (py_g);
2570
2571   r = guestfs_chown (g, owner, group, path);
2572   if (r == -1) {
2573     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2574     return NULL;
2575   }
2576
2577   Py_INCREF (Py_None);
2578   py_r = Py_None;
2579   return py_r;
2580 }
2581
2582 static PyObject *
2583 py_guestfs_exists (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_exists",
2592                          &py_g, &path))
2593     return NULL;
2594   g = get_handle (py_g);
2595
2596   r = guestfs_exists (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_is_file (PyObject *self, PyObject *args)
2608 {
2609   PyObject *py_g;
2610   guestfs_h *g;
2611   PyObject *py_r;
2612   int r;
2613   const char *path;
2614
2615   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
2616                          &py_g, &path))
2617     return NULL;
2618   g = get_handle (py_g);
2619
2620   r = guestfs_is_file (g, path);
2621   if (r == -1) {
2622     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2623     return NULL;
2624   }
2625
2626   py_r = PyInt_FromLong ((long) r);
2627   return py_r;
2628 }
2629
2630 static PyObject *
2631 py_guestfs_is_dir (PyObject *self, PyObject *args)
2632 {
2633   PyObject *py_g;
2634   guestfs_h *g;
2635   PyObject *py_r;
2636   int r;
2637   const char *path;
2638
2639   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
2640                          &py_g, &path))
2641     return NULL;
2642   g = get_handle (py_g);
2643
2644   r = guestfs_is_dir (g, path);
2645   if (r == -1) {
2646     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2647     return NULL;
2648   }
2649
2650   py_r = PyInt_FromLong ((long) r);
2651   return py_r;
2652 }
2653
2654 static PyObject *
2655 py_guestfs_pvcreate (PyObject *self, PyObject *args)
2656 {
2657   PyObject *py_g;
2658   guestfs_h *g;
2659   PyObject *py_r;
2660   int r;
2661   const char *device;
2662
2663   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
2664                          &py_g, &device))
2665     return NULL;
2666   g = get_handle (py_g);
2667
2668   r = guestfs_pvcreate (g, device);
2669   if (r == -1) {
2670     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2671     return NULL;
2672   }
2673
2674   Py_INCREF (Py_None);
2675   py_r = Py_None;
2676   return py_r;
2677 }
2678
2679 static PyObject *
2680 py_guestfs_vgcreate (PyObject *self, PyObject *args)
2681 {
2682   PyObject *py_g;
2683   guestfs_h *g;
2684   PyObject *py_r;
2685   int r;
2686   const char *volgroup;
2687   PyObject *py_physvols;
2688   const char **physvols;
2689
2690   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
2691                          &py_g, &volgroup, &py_physvols))
2692     return NULL;
2693   g = get_handle (py_g);
2694   physvols = get_string_list (py_physvols);
2695   if (!physvols) return NULL;
2696
2697   r = guestfs_vgcreate (g, volgroup, physvols);
2698   free (physvols);
2699   if (r == -1) {
2700     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2701     return NULL;
2702   }
2703
2704   Py_INCREF (Py_None);
2705   py_r = Py_None;
2706   return py_r;
2707 }
2708
2709 static PyObject *
2710 py_guestfs_lvcreate (PyObject *self, PyObject *args)
2711 {
2712   PyObject *py_g;
2713   guestfs_h *g;
2714   PyObject *py_r;
2715   int r;
2716   const char *logvol;
2717   const char *volgroup;
2718   int mbytes;
2719
2720   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
2721                          &py_g, &logvol, &volgroup, &mbytes))
2722     return NULL;
2723   g = get_handle (py_g);
2724
2725   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2726   if (r == -1) {
2727     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2728     return NULL;
2729   }
2730
2731   Py_INCREF (Py_None);
2732   py_r = Py_None;
2733   return py_r;
2734 }
2735
2736 static PyObject *
2737 py_guestfs_mkfs (PyObject *self, PyObject *args)
2738 {
2739   PyObject *py_g;
2740   guestfs_h *g;
2741   PyObject *py_r;
2742   int r;
2743   const char *fstype;
2744   const char *device;
2745
2746   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
2747                          &py_g, &fstype, &device))
2748     return NULL;
2749   g = get_handle (py_g);
2750
2751   r = guestfs_mkfs (g, fstype, device);
2752   if (r == -1) {
2753     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2754     return NULL;
2755   }
2756
2757   Py_INCREF (Py_None);
2758   py_r = Py_None;
2759   return py_r;
2760 }
2761
2762 static PyObject *
2763 py_guestfs_sfdisk (PyObject *self, PyObject *args)
2764 {
2765   PyObject *py_g;
2766   guestfs_h *g;
2767   PyObject *py_r;
2768   int r;
2769   const char *device;
2770   int cyls;
2771   int heads;
2772   int sectors;
2773   PyObject *py_lines;
2774   const char **lines;
2775
2776   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
2777                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
2778     return NULL;
2779   g = get_handle (py_g);
2780   lines = get_string_list (py_lines);
2781   if (!lines) return NULL;
2782
2783   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2784   free (lines);
2785   if (r == -1) {
2786     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2787     return NULL;
2788   }
2789
2790   Py_INCREF (Py_None);
2791   py_r = Py_None;
2792   return py_r;
2793 }
2794
2795 static PyObject *
2796 py_guestfs_write_file (PyObject *self, PyObject *args)
2797 {
2798   PyObject *py_g;
2799   guestfs_h *g;
2800   PyObject *py_r;
2801   int r;
2802   const char *path;
2803   const char *content;
2804   int size;
2805
2806   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
2807                          &py_g, &path, &content, &size))
2808     return NULL;
2809   g = get_handle (py_g);
2810
2811   r = guestfs_write_file (g, path, content, size);
2812   if (r == -1) {
2813     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2814     return NULL;
2815   }
2816
2817   Py_INCREF (Py_None);
2818   py_r = Py_None;
2819   return py_r;
2820 }
2821
2822 static PyObject *
2823 py_guestfs_umount (PyObject *self, PyObject *args)
2824 {
2825   PyObject *py_g;
2826   guestfs_h *g;
2827   PyObject *py_r;
2828   int r;
2829   const char *pathordevice;
2830
2831   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
2832                          &py_g, &pathordevice))
2833     return NULL;
2834   g = get_handle (py_g);
2835
2836   r = guestfs_umount (g, pathordevice);
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_mounts (PyObject *self, PyObject *args)
2849 {
2850   PyObject *py_g;
2851   guestfs_h *g;
2852   PyObject *py_r;
2853   char **r;
2854
2855   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
2856                          &py_g))
2857     return NULL;
2858   g = get_handle (py_g);
2859
2860   r = guestfs_mounts (g);
2861   if (r == NULL) {
2862     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2863     return NULL;
2864   }
2865
2866   py_r = put_string_list (r);
2867   free_strings (r);
2868   return py_r;
2869 }
2870
2871 static PyObject *
2872 py_guestfs_umount_all (PyObject *self, PyObject *args)
2873 {
2874   PyObject *py_g;
2875   guestfs_h *g;
2876   PyObject *py_r;
2877   int r;
2878
2879   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
2880                          &py_g))
2881     return NULL;
2882   g = get_handle (py_g);
2883
2884   r = guestfs_umount_all (g);
2885   if (r == -1) {
2886     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2887     return NULL;
2888   }
2889
2890   Py_INCREF (Py_None);
2891   py_r = Py_None;
2892   return py_r;
2893 }
2894
2895 static PyObject *
2896 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
2897 {
2898   PyObject *py_g;
2899   guestfs_h *g;
2900   PyObject *py_r;
2901   int r;
2902
2903   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
2904                          &py_g))
2905     return NULL;
2906   g = get_handle (py_g);
2907
2908   r = guestfs_lvm_remove_all (g);
2909   if (r == -1) {
2910     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2911     return NULL;
2912   }
2913
2914   Py_INCREF (Py_None);
2915   py_r = Py_None;
2916   return py_r;
2917 }
2918
2919 static PyObject *
2920 py_guestfs_file (PyObject *self, PyObject *args)
2921 {
2922   PyObject *py_g;
2923   guestfs_h *g;
2924   PyObject *py_r;
2925   char *r;
2926   const char *path;
2927
2928   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
2929                          &py_g, &path))
2930     return NULL;
2931   g = get_handle (py_g);
2932
2933   r = guestfs_file (g, path);
2934   if (r == NULL) {
2935     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2936     return NULL;
2937   }
2938
2939   py_r = PyString_FromString (r);
2940   free (r);
2941   return py_r;
2942 }
2943
2944 static PyObject *
2945 py_guestfs_command (PyObject *self, PyObject *args)
2946 {
2947   PyObject *py_g;
2948   guestfs_h *g;
2949   PyObject *py_r;
2950   char *r;
2951   PyObject *py_arguments;
2952   const char **arguments;
2953
2954   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
2955                          &py_g, &py_arguments))
2956     return NULL;
2957   g = get_handle (py_g);
2958   arguments = get_string_list (py_arguments);
2959   if (!arguments) return NULL;
2960
2961   r = guestfs_command (g, arguments);
2962   free (arguments);
2963   if (r == NULL) {
2964     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2965     return NULL;
2966   }
2967
2968   py_r = PyString_FromString (r);
2969   free (r);
2970   return py_r;
2971 }
2972
2973 static PyObject *
2974 py_guestfs_command_lines (PyObject *self, PyObject *args)
2975 {
2976   PyObject *py_g;
2977   guestfs_h *g;
2978   PyObject *py_r;
2979   char **r;
2980   PyObject *py_arguments;
2981   const char **arguments;
2982
2983   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
2984                          &py_g, &py_arguments))
2985     return NULL;
2986   g = get_handle (py_g);
2987   arguments = get_string_list (py_arguments);
2988   if (!arguments) return NULL;
2989
2990   r = guestfs_command_lines (g, arguments);
2991   free (arguments);
2992   if (r == NULL) {
2993     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2994     return NULL;
2995   }
2996
2997   py_r = put_string_list (r);
2998   free_strings (r);
2999   return py_r;
3000 }
3001
3002 static PyObject *
3003 py_guestfs_stat (PyObject *self, PyObject *args)
3004 {
3005   PyObject *py_g;
3006   guestfs_h *g;
3007   PyObject *py_r;
3008   struct guestfs_stat *r;
3009   const char *path;
3010
3011   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
3012                          &py_g, &path))
3013     return NULL;
3014   g = get_handle (py_g);
3015
3016   r = guestfs_stat (g, path);
3017   if (r == NULL) {
3018     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3019     return NULL;
3020   }
3021
3022   py_r = put_stat (r);
3023   free (r);
3024   return py_r;
3025 }
3026
3027 static PyObject *
3028 py_guestfs_lstat (PyObject *self, PyObject *args)
3029 {
3030   PyObject *py_g;
3031   guestfs_h *g;
3032   PyObject *py_r;
3033   struct guestfs_stat *r;
3034   const char *path;
3035
3036   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
3037                          &py_g, &path))
3038     return NULL;
3039   g = get_handle (py_g);
3040
3041   r = guestfs_lstat (g, path);
3042   if (r == NULL) {
3043     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3044     return NULL;
3045   }
3046
3047   py_r = put_stat (r);
3048   free (r);
3049   return py_r;
3050 }
3051
3052 static PyObject *
3053 py_guestfs_statvfs (PyObject *self, PyObject *args)
3054 {
3055   PyObject *py_g;
3056   guestfs_h *g;
3057   PyObject *py_r;
3058   struct guestfs_statvfs *r;
3059   const char *path;
3060
3061   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
3062                          &py_g, &path))
3063     return NULL;
3064   g = get_handle (py_g);
3065
3066   r = guestfs_statvfs (g, path);
3067   if (r == NULL) {
3068     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3069     return NULL;
3070   }
3071
3072   py_r = put_statvfs (r);
3073   free (r);
3074   return py_r;
3075 }
3076
3077 static PyObject *
3078 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
3079 {
3080   PyObject *py_g;
3081   guestfs_h *g;
3082   PyObject *py_r;
3083   char **r;
3084   const char *device;
3085
3086   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
3087                          &py_g, &device))
3088     return NULL;
3089   g = get_handle (py_g);
3090
3091   r = guestfs_tune2fs_l (g, device);
3092   if (r == NULL) {
3093     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3094     return NULL;
3095   }
3096
3097   py_r = put_table (r);
3098   free_strings (r);
3099   return py_r;
3100 }
3101
3102 static PyObject *
3103 py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
3104 {
3105   PyObject *py_g;
3106   guestfs_h *g;
3107   PyObject *py_r;
3108   int r;
3109   const char *device;
3110
3111   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
3112                          &py_g, &device))
3113     return NULL;
3114   g = get_handle (py_g);
3115
3116   r = guestfs_blockdev_setro (g, device);
3117   if (r == -1) {
3118     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3119     return NULL;
3120   }
3121
3122   Py_INCREF (Py_None);
3123   py_r = Py_None;
3124   return py_r;
3125 }
3126
3127 static PyObject *
3128 py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
3129 {
3130   PyObject *py_g;
3131   guestfs_h *g;
3132   PyObject *py_r;
3133   int r;
3134   const char *device;
3135
3136   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
3137                          &py_g, &device))
3138     return NULL;
3139   g = get_handle (py_g);
3140
3141   r = guestfs_blockdev_setrw (g, device);
3142   if (r == -1) {
3143     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3144     return NULL;
3145   }
3146
3147   Py_INCREF (Py_None);
3148   py_r = Py_None;
3149   return py_r;
3150 }
3151
3152 static PyObject *
3153 py_guestfs_blockdev_getro (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_getro",
3162                          &py_g, &device))
3163     return NULL;
3164   g = get_handle (py_g);
3165
3166   r = guestfs_blockdev_getro (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_getss (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
3185   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
3186                          &py_g, &device))
3187     return NULL;
3188   g = get_handle (py_g);
3189
3190   r = guestfs_blockdev_getss (g, device);
3191   if (r == -1) {
3192     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3193     return NULL;
3194   }
3195
3196   py_r = PyInt_FromLong ((long) r);
3197   return py_r;
3198 }
3199
3200 static PyObject *
3201 py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
3202 {
3203   PyObject *py_g;
3204   guestfs_h *g;
3205   PyObject *py_r;
3206   int r;
3207   const char *device;
3208
3209   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
3210                          &py_g, &device))
3211     return NULL;
3212   g = get_handle (py_g);
3213
3214   r = guestfs_blockdev_getbsz (g, device);
3215   if (r == -1) {
3216     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3217     return NULL;
3218   }
3219
3220   py_r = PyInt_FromLong ((long) r);
3221   return py_r;
3222 }
3223
3224 static PyObject *
3225 py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
3226 {
3227   PyObject *py_g;
3228   guestfs_h *g;
3229   PyObject *py_r;
3230   int r;
3231   const char *device;
3232   int blocksize;
3233
3234   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
3235                          &py_g, &device, &blocksize))
3236     return NULL;
3237   g = get_handle (py_g);
3238
3239   r = guestfs_blockdev_setbsz (g, device, blocksize);
3240   if (r == -1) {
3241     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3242     return NULL;
3243   }
3244
3245   Py_INCREF (Py_None);
3246   py_r = Py_None;
3247   return py_r;
3248 }
3249
3250 static PyObject *
3251 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
3252 {
3253   PyObject *py_g;
3254   guestfs_h *g;
3255   PyObject *py_r;
3256   int64_t r;
3257   const char *device;
3258
3259   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
3260                          &py_g, &device))
3261     return NULL;
3262   g = get_handle (py_g);
3263
3264   r = guestfs_blockdev_getsz (g, device);
3265   if (r == -1) {
3266     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3267     return NULL;
3268   }
3269
3270   py_r = PyLong_FromLongLong (r);
3271   return py_r;
3272 }
3273
3274 static PyObject *
3275 py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
3276 {
3277   PyObject *py_g;
3278   guestfs_h *g;
3279   PyObject *py_r;
3280   int64_t r;
3281   const char *device;
3282
3283   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
3284                          &py_g, &device))
3285     return NULL;
3286   g = get_handle (py_g);
3287
3288   r = guestfs_blockdev_getsize64 (g, device);
3289   if (r == -1) {
3290     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3291     return NULL;
3292   }
3293
3294   py_r = PyLong_FromLongLong (r);
3295   return py_r;
3296 }
3297
3298 static PyObject *
3299 py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
3300 {
3301   PyObject *py_g;
3302   guestfs_h *g;
3303   PyObject *py_r;
3304   int r;
3305   const char *device;
3306
3307   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
3308                          &py_g, &device))
3309     return NULL;
3310   g = get_handle (py_g);
3311
3312   r = guestfs_blockdev_flushbufs (g, device);
3313   if (r == -1) {
3314     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3315     return NULL;
3316   }
3317
3318   Py_INCREF (Py_None);
3319   py_r = Py_None;
3320   return py_r;
3321 }
3322
3323 static PyObject *
3324 py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
3325 {
3326   PyObject *py_g;
3327   guestfs_h *g;
3328   PyObject *py_r;
3329   int r;
3330   const char *device;
3331
3332   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
3333                          &py_g, &device))
3334     return NULL;
3335   g = get_handle (py_g);
3336
3337   r = guestfs_blockdev_rereadpt (g, device);
3338   if (r == -1) {
3339     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3340     return NULL;
3341   }
3342
3343   Py_INCREF (Py_None);
3344   py_r = Py_None;
3345   return py_r;
3346 }
3347
3348 static PyObject *
3349 py_guestfs_upload (PyObject *self, PyObject *args)
3350 {
3351   PyObject *py_g;
3352   guestfs_h *g;
3353   PyObject *py_r;
3354   int r;
3355   const char *filename;
3356   const char *remotefilename;
3357
3358   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
3359                          &py_g, &filename, &remotefilename))
3360     return NULL;
3361   g = get_handle (py_g);
3362
3363   r = guestfs_upload (g, filename, remotefilename);
3364   if (r == -1) {
3365     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3366     return NULL;
3367   }
3368
3369   Py_INCREF (Py_None);
3370   py_r = Py_None;
3371   return py_r;
3372 }
3373
3374 static PyObject *
3375 py_guestfs_download (PyObject *self, PyObject *args)
3376 {
3377   PyObject *py_g;
3378   guestfs_h *g;
3379   PyObject *py_r;
3380   int r;
3381   const char *remotefilename;
3382   const char *filename;
3383
3384   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
3385                          &py_g, &remotefilename, &filename))
3386     return NULL;
3387   g = get_handle (py_g);
3388
3389   r = guestfs_download (g, remotefilename, filename);
3390   if (r == -1) {
3391     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3392     return NULL;
3393   }
3394
3395   Py_INCREF (Py_None);
3396   py_r = Py_None;
3397   return py_r;
3398 }
3399
3400 static PyObject *
3401 py_guestfs_checksum (PyObject *self, PyObject *args)
3402 {
3403   PyObject *py_g;
3404   guestfs_h *g;
3405   PyObject *py_r;
3406   char *r;
3407   const char *csumtype;
3408   const char *path;
3409
3410   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum",
3411                          &py_g, &csumtype, &path))
3412     return NULL;
3413   g = get_handle (py_g);
3414
3415   r = guestfs_checksum (g, csumtype, path);
3416   if (r == NULL) {
3417     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3418     return NULL;
3419   }
3420
3421   py_r = PyString_FromString (r);
3422   free (r);
3423   return py_r;
3424 }
3425
3426 static PyObject *
3427 py_guestfs_tar_in (PyObject *self, PyObject *args)
3428 {
3429   PyObject *py_g;
3430   guestfs_h *g;
3431   PyObject *py_r;
3432   int r;
3433   const char *tarfile;
3434   const char *directory;
3435
3436   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in",
3437                          &py_g, &tarfile, &directory))
3438     return NULL;
3439   g = get_handle (py_g);
3440
3441   r = guestfs_tar_in (g, tarfile, directory);
3442   if (r == -1) {
3443     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3444     return NULL;
3445   }
3446
3447   Py_INCREF (Py_None);
3448   py_r = Py_None;
3449   return py_r;
3450 }
3451
3452 static PyObject *
3453 py_guestfs_tar_out (PyObject *self, PyObject *args)
3454 {
3455   PyObject *py_g;
3456   guestfs_h *g;
3457   PyObject *py_r;
3458   int r;
3459   const char *directory;
3460   const char *tarfile;
3461
3462   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out",
3463                          &py_g, &directory, &tarfile))
3464     return NULL;
3465   g = get_handle (py_g);
3466
3467   r = guestfs_tar_out (g, directory, tarfile);
3468   if (r == -1) {
3469     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3470     return NULL;
3471   }
3472
3473   Py_INCREF (Py_None);
3474   py_r = Py_None;
3475   return py_r;
3476 }
3477
3478 static PyObject *
3479 py_guestfs_tgz_in (PyObject *self, PyObject *args)
3480 {
3481   PyObject *py_g;
3482   guestfs_h *g;
3483   PyObject *py_r;
3484   int r;
3485   const char *tarball;
3486   const char *directory;
3487
3488   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in",
3489                          &py_g, &tarball, &directory))
3490     return NULL;
3491   g = get_handle (py_g);
3492
3493   r = guestfs_tgz_in (g, tarball, directory);
3494   if (r == -1) {
3495     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3496     return NULL;
3497   }
3498
3499   Py_INCREF (Py_None);
3500   py_r = Py_None;
3501   return py_r;
3502 }
3503
3504 static PyObject *
3505 py_guestfs_tgz_out (PyObject *self, PyObject *args)
3506 {
3507   PyObject *py_g;
3508   guestfs_h *g;
3509   PyObject *py_r;
3510   int r;
3511   const char *directory;
3512   const char *tarball;
3513
3514   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out",
3515                          &py_g, &directory, &tarball))
3516     return NULL;
3517   g = get_handle (py_g);
3518
3519   r = guestfs_tgz_out (g, directory, tarball);
3520   if (r == -1) {
3521     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3522     return NULL;
3523   }
3524
3525   Py_INCREF (Py_None);
3526   py_r = Py_None;
3527   return py_r;
3528 }
3529
3530 static PyObject *
3531 py_guestfs_mount_ro (PyObject *self, PyObject *args)
3532 {
3533   PyObject *py_g;
3534   guestfs_h *g;
3535   PyObject *py_r;
3536   int r;
3537   const char *device;
3538   const char *mountpoint;
3539
3540   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro",
3541                          &py_g, &device, &mountpoint))
3542     return NULL;
3543   g = get_handle (py_g);
3544
3545   r = guestfs_mount_ro (g, device, mountpoint);
3546   if (r == -1) {
3547     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3548     return NULL;
3549   }
3550
3551   Py_INCREF (Py_None);
3552   py_r = Py_None;
3553   return py_r;
3554 }
3555
3556 static PyObject *
3557 py_guestfs_mount_options (PyObject *self, PyObject *args)
3558 {
3559   PyObject *py_g;
3560   guestfs_h *g;
3561   PyObject *py_r;
3562   int r;
3563   const char *options;
3564   const char *device;
3565   const char *mountpoint;
3566
3567   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options",
3568                          &py_g, &options, &device, &mountpoint))
3569     return NULL;
3570   g = get_handle (py_g);
3571
3572   r = guestfs_mount_options (g, options, device, mountpoint);
3573   if (r == -1) {
3574     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3575     return NULL;
3576   }
3577
3578   Py_INCREF (Py_None);
3579   py_r = Py_None;
3580   return py_r;
3581 }
3582
3583 static PyObject *
3584 py_guestfs_mount_vfs (PyObject *self, PyObject *args)
3585 {
3586   PyObject *py_g;
3587   guestfs_h *g;
3588   PyObject *py_r;
3589   int r;
3590   const char *options;
3591   const char *vfstype;
3592   const char *device;
3593   const char *mountpoint;
3594
3595   if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs",
3596                          &py_g, &options, &vfstype, &device, &mountpoint))
3597     return NULL;
3598   g = get_handle (py_g);
3599
3600   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3601   if (r == -1) {
3602     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3603     return NULL;
3604   }
3605
3606   Py_INCREF (Py_None);
3607   py_r = Py_None;
3608   return py_r;
3609 }
3610
3611 static PyObject *
3612 py_guestfs_debug (PyObject *self, PyObject *args)
3613 {
3614   PyObject *py_g;
3615   guestfs_h *g;
3616   PyObject *py_r;
3617   char *r;
3618   const char *subcmd;
3619   PyObject *py_extraargs;
3620   const char **extraargs;
3621
3622   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug",
3623                          &py_g, &subcmd, &py_extraargs))
3624     return NULL;
3625   g = get_handle (py_g);
3626   extraargs = get_string_list (py_extraargs);
3627   if (!extraargs) return NULL;
3628
3629   r = guestfs_debug (g, subcmd, extraargs);
3630   free (extraargs);
3631   if (r == NULL) {
3632     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3633     return NULL;
3634   }
3635
3636   py_r = PyString_FromString (r);
3637   free (r);
3638   return py_r;
3639 }
3640
3641 static PyObject *
3642 py_guestfs_lvremove (PyObject *self, PyObject *args)
3643 {
3644   PyObject *py_g;
3645   guestfs_h *g;
3646   PyObject *py_r;
3647   int r;
3648   const char *device;
3649
3650   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove",
3651                          &py_g, &device))
3652     return NULL;
3653   g = get_handle (py_g);
3654
3655   r = guestfs_lvremove (g, device);
3656   if (r == -1) {
3657     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3658     return NULL;
3659   }
3660
3661   Py_INCREF (Py_None);
3662   py_r = Py_None;
3663   return py_r;
3664 }
3665
3666 static PyObject *
3667 py_guestfs_vgremove (PyObject *self, PyObject *args)
3668 {
3669   PyObject *py_g;
3670   guestfs_h *g;
3671   PyObject *py_r;
3672   int r;
3673   const char *vgname;
3674
3675   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove",
3676                          &py_g, &vgname))
3677     return NULL;
3678   g = get_handle (py_g);
3679
3680   r = guestfs_vgremove (g, vgname);
3681   if (r == -1) {
3682     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3683     return NULL;
3684   }
3685
3686   Py_INCREF (Py_None);
3687   py_r = Py_None;
3688   return py_r;
3689 }
3690
3691 static PyObject *
3692 py_guestfs_pvremove (PyObject *self, PyObject *args)
3693 {
3694   PyObject *py_g;
3695   guestfs_h *g;
3696   PyObject *py_r;
3697   int r;
3698   const char *device;
3699
3700   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove",
3701                          &py_g, &device))
3702     return NULL;
3703   g = get_handle (py_g);
3704
3705   r = guestfs_pvremove (g, device);
3706   if (r == -1) {
3707     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3708     return NULL;
3709   }
3710
3711   Py_INCREF (Py_None);
3712   py_r = Py_None;
3713   return py_r;
3714 }
3715
3716 static PyObject *
3717 py_guestfs_set_e2label (PyObject *self, PyObject *args)
3718 {
3719   PyObject *py_g;
3720   guestfs_h *g;
3721   PyObject *py_r;
3722   int r;
3723   const char *device;
3724   const char *label;
3725
3726   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label",
3727                          &py_g, &device, &label))
3728     return NULL;
3729   g = get_handle (py_g);
3730
3731   r = guestfs_set_e2label (g, device, label);
3732   if (r == -1) {
3733     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3734     return NULL;
3735   }
3736
3737   Py_INCREF (Py_None);
3738   py_r = Py_None;
3739   return py_r;
3740 }
3741
3742 static PyObject *
3743 py_guestfs_get_e2label (PyObject *self, PyObject *args)
3744 {
3745   PyObject *py_g;
3746   guestfs_h *g;
3747   PyObject *py_r;
3748   char *r;
3749   const char *device;
3750
3751   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label",
3752                          &py_g, &device))
3753     return NULL;
3754   g = get_handle (py_g);
3755
3756   r = guestfs_get_e2label (g, device);
3757   if (r == NULL) {
3758     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3759     return NULL;
3760   }
3761
3762   py_r = PyString_FromString (r);
3763   free (r);
3764   return py_r;
3765 }
3766
3767 static PyObject *
3768 py_guestfs_set_e2uuid (PyObject *self, PyObject *args)
3769 {
3770   PyObject *py_g;
3771   guestfs_h *g;
3772   PyObject *py_r;
3773   int r;
3774   const char *device;
3775   const char *uuid;
3776
3777   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid",
3778                          &py_g, &device, &uuid))
3779     return NULL;
3780   g = get_handle (py_g);
3781
3782   r = guestfs_set_e2uuid (g, device, uuid);
3783   if (r == -1) {
3784     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3785     return NULL;
3786   }
3787
3788   Py_INCREF (Py_None);
3789   py_r = Py_None;
3790   return py_r;
3791 }
3792
3793 static PyObject *
3794 py_guestfs_get_e2uuid (PyObject *self, PyObject *args)
3795 {
3796   PyObject *py_g;
3797   guestfs_h *g;
3798   PyObject *py_r;
3799   char *r;
3800   const char *device;
3801
3802   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid",
3803                          &py_g, &device))
3804     return NULL;
3805   g = get_handle (py_g);
3806
3807   r = guestfs_get_e2uuid (g, device);
3808   if (r == NULL) {
3809     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3810     return NULL;
3811   }
3812
3813   py_r = PyString_FromString (r);
3814   free (r);
3815   return py_r;
3816 }
3817
3818 static PyObject *
3819 py_guestfs_fsck (PyObject *self, PyObject *args)
3820 {
3821   PyObject *py_g;
3822   guestfs_h *g;
3823   PyObject *py_r;
3824   int r;
3825   const char *fstype;
3826   const char *device;
3827
3828   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck",
3829                          &py_g, &fstype, &device))
3830     return NULL;
3831   g = get_handle (py_g);
3832
3833   r = guestfs_fsck (g, fstype, device);
3834   if (r == -1) {
3835     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3836     return NULL;
3837   }
3838
3839   py_r = PyInt_FromLong ((long) r);
3840   return py_r;
3841 }
3842
3843 static PyObject *
3844 py_guestfs_zero (PyObject *self, PyObject *args)
3845 {
3846   PyObject *py_g;
3847   guestfs_h *g;
3848   PyObject *py_r;
3849   int r;
3850   const char *device;
3851
3852   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero",
3853                          &py_g, &device))
3854     return NULL;
3855   g = get_handle (py_g);
3856
3857   r = guestfs_zero (g, device);
3858   if (r == -1) {
3859     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3860     return NULL;
3861   }
3862
3863   Py_INCREF (Py_None);
3864   py_r = Py_None;
3865   return py_r;
3866 }
3867
3868 static PyObject *
3869 py_guestfs_grub_install (PyObject *self, PyObject *args)
3870 {
3871   PyObject *py_g;
3872   guestfs_h *g;
3873   PyObject *py_r;
3874   int r;
3875   const char *root;
3876   const char *device;
3877
3878   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install",
3879                          &py_g, &root, &device))
3880     return NULL;
3881   g = get_handle (py_g);
3882
3883   r = guestfs_grub_install (g, root, device);
3884   if (r == -1) {
3885     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3886     return NULL;
3887   }
3888
3889   Py_INCREF (Py_None);
3890   py_r = Py_None;
3891   return py_r;
3892 }
3893
3894 static PyObject *
3895 py_guestfs_cp (PyObject *self, PyObject *args)
3896 {
3897   PyObject *py_g;
3898   guestfs_h *g;
3899   PyObject *py_r;
3900   int r;
3901   const char *src;
3902   const char *dest;
3903
3904   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp",
3905                          &py_g, &src, &dest))
3906     return NULL;
3907   g = get_handle (py_g);
3908
3909   r = guestfs_cp (g, src, dest);
3910   if (r == -1) {
3911     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3912     return NULL;
3913   }
3914
3915   Py_INCREF (Py_None);
3916   py_r = Py_None;
3917   return py_r;
3918 }
3919
3920 static PyObject *
3921 py_guestfs_cp_a (PyObject *self, PyObject *args)
3922 {
3923   PyObject *py_g;
3924   guestfs_h *g;
3925   PyObject *py_r;
3926   int r;
3927   const char *src;
3928   const char *dest;
3929
3930   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a",
3931                          &py_g, &src, &dest))
3932     return NULL;
3933   g = get_handle (py_g);
3934
3935   r = guestfs_cp_a (g, src, dest);
3936   if (r == -1) {
3937     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3938     return NULL;
3939   }
3940
3941   Py_INCREF (Py_None);
3942   py_r = Py_None;
3943   return py_r;
3944 }
3945
3946 static PyObject *
3947 py_guestfs_mv (PyObject *self, PyObject *args)
3948 {
3949   PyObject *py_g;
3950   guestfs_h *g;
3951   PyObject *py_r;
3952   int r;
3953   const char *src;
3954   const char *dest;
3955
3956   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv",
3957                          &py_g, &src, &dest))
3958     return NULL;
3959   g = get_handle (py_g);
3960
3961   r = guestfs_mv (g, src, dest);
3962   if (r == -1) {
3963     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3964     return NULL;
3965   }
3966
3967   Py_INCREF (Py_None);
3968   py_r = Py_None;
3969   return py_r;
3970 }
3971
3972 static PyObject *
3973 py_guestfs_drop_caches (PyObject *self, PyObject *args)
3974 {
3975   PyObject *py_g;
3976   guestfs_h *g;
3977   PyObject *py_r;
3978   int r;
3979   int whattodrop;
3980
3981   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches",
3982                          &py_g, &whattodrop))
3983     return NULL;
3984   g = get_handle (py_g);
3985
3986   r = guestfs_drop_caches (g, whattodrop);
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_dmesg (PyObject *self, PyObject *args)
3999 {
4000   PyObject *py_g;
4001   guestfs_h *g;
4002   PyObject *py_r;
4003   char *r;
4004
4005   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_dmesg",
4006                          &py_g))
4007     return NULL;
4008   g = get_handle (py_g);
4009
4010   r = guestfs_dmesg (g);
4011   if (r == NULL) {
4012     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4013     return NULL;
4014   }
4015
4016   py_r = PyString_FromString (r);
4017   free (r);
4018   return py_r;
4019 }
4020
4021 static PyObject *
4022 py_guestfs_ping_daemon (PyObject *self, PyObject *args)
4023 {
4024   PyObject *py_g;
4025   guestfs_h *g;
4026   PyObject *py_r;
4027   int r;
4028
4029   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_ping_daemon",
4030                          &py_g))
4031     return NULL;
4032   g = get_handle (py_g);
4033
4034   r = guestfs_ping_daemon (g);
4035   if (r == -1) {
4036     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4037     return NULL;
4038   }
4039
4040   Py_INCREF (Py_None);
4041   py_r = Py_None;
4042   return py_r;
4043 }
4044
4045 static PyObject *
4046 py_guestfs_equal (PyObject *self, PyObject *args)
4047 {
4048   PyObject *py_g;
4049   guestfs_h *g;
4050   PyObject *py_r;
4051   int r;
4052   const char *file1;
4053   const char *file2;
4054
4055   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_equal",
4056                          &py_g, &file1, &file2))
4057     return NULL;
4058   g = get_handle (py_g);
4059
4060   r = guestfs_equal (g, file1, file2);
4061   if (r == -1) {
4062     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4063     return NULL;
4064   }
4065
4066   py_r = PyInt_FromLong ((long) r);
4067   return py_r;
4068 }
4069
4070 static PyObject *
4071 py_guestfs_strings (PyObject *self, PyObject *args)
4072 {
4073   PyObject *py_g;
4074   guestfs_h *g;
4075   PyObject *py_r;
4076   char **r;
4077   const char *path;
4078
4079   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_strings",
4080                          &py_g, &path))
4081     return NULL;
4082   g = get_handle (py_g);
4083
4084   r = guestfs_strings (g, path);
4085   if (r == NULL) {
4086     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4087     return NULL;
4088   }
4089
4090   py_r = put_string_list (r);
4091   free_strings (r);
4092   return py_r;
4093 }
4094
4095 static PyObject *
4096 py_guestfs_strings_e (PyObject *self, PyObject *args)
4097 {
4098   PyObject *py_g;
4099   guestfs_h *g;
4100   PyObject *py_r;
4101   char **r;
4102   const char *encoding;
4103   const char *path;
4104
4105   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_strings_e",
4106                          &py_g, &encoding, &path))
4107     return NULL;
4108   g = get_handle (py_g);
4109
4110   r = guestfs_strings_e (g, encoding, path);
4111   if (r == NULL) {
4112     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4113     return NULL;
4114   }
4115
4116   py_r = put_string_list (r);
4117   free_strings (r);
4118   return py_r;
4119 }
4120
4121 static PyObject *
4122 py_guestfs_hexdump (PyObject *self, PyObject *args)
4123 {
4124   PyObject *py_g;
4125   guestfs_h *g;
4126   PyObject *py_r;
4127   char *r;
4128   const char *path;
4129
4130   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_hexdump",
4131                          &py_g, &path))
4132     return NULL;
4133   g = get_handle (py_g);
4134
4135   r = guestfs_hexdump (g, path);
4136   if (r == NULL) {
4137     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4138     return NULL;
4139   }
4140
4141   py_r = PyString_FromString (r);
4142   free (r);
4143   return py_r;
4144 }
4145
4146 static PyObject *
4147 py_guestfs_zerofree (PyObject *self, PyObject *args)
4148 {
4149   PyObject *py_g;
4150   guestfs_h *g;
4151   PyObject *py_r;
4152   int r;
4153   const char *device;
4154
4155   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zerofree",
4156                          &py_g, &device))
4157     return NULL;
4158   g = get_handle (py_g);
4159
4160   r = guestfs_zerofree (g, device);
4161   if (r == -1) {
4162     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4163     return NULL;
4164   }
4165
4166   Py_INCREF (Py_None);
4167   py_r = Py_None;
4168   return py_r;
4169 }
4170
4171 static PyObject *
4172 py_guestfs_pvresize (PyObject *self, PyObject *args)
4173 {
4174   PyObject *py_g;
4175   guestfs_h *g;
4176   PyObject *py_r;
4177   int r;
4178   const char *device;
4179
4180   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvresize",
4181                          &py_g, &device))
4182     return NULL;
4183   g = get_handle (py_g);
4184
4185   r = guestfs_pvresize (g, device);
4186   if (r == -1) {
4187     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4188     return NULL;
4189   }
4190
4191   Py_INCREF (Py_None);
4192   py_r = Py_None;
4193   return py_r;
4194 }
4195
4196 static PyObject *
4197 py_guestfs_sfdisk_N (PyObject *self, PyObject *args)
4198 {
4199   PyObject *py_g;
4200   guestfs_h *g;
4201   PyObject *py_r;
4202   int r;
4203   const char *device;
4204   int partnum;
4205   int cyls;
4206   int heads;
4207   int sectors;
4208   const char *line;
4209
4210   if (!PyArg_ParseTuple (args, (char *) "Osiiiis:guestfs_sfdisk_N",
4211                          &py_g, &device, &partnum, &cyls, &heads, &sectors, &line))
4212     return NULL;
4213   g = get_handle (py_g);
4214
4215   r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
4216   if (r == -1) {
4217     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4218     return NULL;
4219   }
4220
4221   Py_INCREF (Py_None);
4222   py_r = Py_None;
4223   return py_r;
4224 }
4225
4226 static PyObject *
4227 py_guestfs_sfdisk_l (PyObject *self, PyObject *args)
4228 {
4229   PyObject *py_g;
4230   guestfs_h *g;
4231   PyObject *py_r;
4232   char *r;
4233   const char *device;
4234
4235   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_l",
4236                          &py_g, &device))
4237     return NULL;
4238   g = get_handle (py_g);
4239
4240   r = guestfs_sfdisk_l (g, device);
4241   if (r == NULL) {
4242     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4243     return NULL;
4244   }
4245
4246   py_r = PyString_FromString (r);
4247   free (r);
4248   return py_r;
4249 }
4250
4251 static PyObject *
4252 py_guestfs_sfdisk_kernel_geometry (PyObject *self, PyObject *args)
4253 {
4254   PyObject *py_g;
4255   guestfs_h *g;
4256   PyObject *py_r;
4257   char *r;
4258   const char *device;
4259
4260   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_kernel_geometry",
4261                          &py_g, &device))
4262     return NULL;
4263   g = get_handle (py_g);
4264
4265   r = guestfs_sfdisk_kernel_geometry (g, device);
4266   if (r == NULL) {
4267     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4268     return NULL;
4269   }
4270
4271   py_r = PyString_FromString (r);
4272   free (r);
4273   return py_r;
4274 }
4275
4276 static PyObject *
4277 py_guestfs_sfdisk_disk_geometry (PyObject *self, PyObject *args)
4278 {
4279   PyObject *py_g;
4280   guestfs_h *g;
4281   PyObject *py_r;
4282   char *r;
4283   const char *device;
4284
4285   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_disk_geometry",
4286                          &py_g, &device))
4287     return NULL;
4288   g = get_handle (py_g);
4289
4290   r = guestfs_sfdisk_disk_geometry (g, device);
4291   if (r == NULL) {
4292     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4293     return NULL;
4294   }
4295
4296   py_r = PyString_FromString (r);
4297   free (r);
4298   return py_r;
4299 }
4300
4301 static PyObject *
4302 py_guestfs_vg_activate_all (PyObject *self, PyObject *args)
4303 {
4304   PyObject *py_g;
4305   guestfs_h *g;
4306   PyObject *py_r;
4307   int r;
4308   int activate;
4309
4310   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_vg_activate_all",
4311                          &py_g, &activate))
4312     return NULL;
4313   g = get_handle (py_g);
4314
4315   r = guestfs_vg_activate_all (g, activate);
4316   if (r == -1) {
4317     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4318     return NULL;
4319   }
4320
4321   Py_INCREF (Py_None);
4322   py_r = Py_None;
4323   return py_r;
4324 }
4325
4326 static PyObject *
4327 py_guestfs_vg_activate (PyObject *self, PyObject *args)
4328 {
4329   PyObject *py_g;
4330   guestfs_h *g;
4331   PyObject *py_r;
4332   int r;
4333   int activate;
4334   PyObject *py_volgroups;
4335   const char **volgroups;
4336
4337   if (!PyArg_ParseTuple (args, (char *) "OiO:guestfs_vg_activate",
4338                          &py_g, &activate, &py_volgroups))
4339     return NULL;
4340   g = get_handle (py_g);
4341   volgroups = get_string_list (py_volgroups);
4342   if (!volgroups) return NULL;
4343
4344   r = guestfs_vg_activate (g, activate, volgroups);
4345   free (volgroups);
4346   if (r == -1) {
4347     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4348     return NULL;
4349   }
4350
4351   Py_INCREF (Py_None);
4352   py_r = Py_None;
4353   return py_r;
4354 }
4355
4356 static PyObject *
4357 py_guestfs_lvresize (PyObject *self, PyObject *args)
4358 {
4359   PyObject *py_g;
4360   guestfs_h *g;
4361   PyObject *py_r;
4362   int r;
4363   const char *device;
4364   int mbytes;
4365
4366   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_lvresize",
4367                          &py_g, &device, &mbytes))
4368     return NULL;
4369   g = get_handle (py_g);
4370
4371   r = guestfs_lvresize (g, device, mbytes);
4372   if (r == -1) {
4373     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4374     return NULL;
4375   }
4376
4377   Py_INCREF (Py_None);
4378   py_r = Py_None;
4379   return py_r;
4380 }
4381
4382 static PyObject *
4383 py_guestfs_resize2fs (PyObject *self, PyObject *args)
4384 {
4385   PyObject *py_g;
4386   guestfs_h *g;
4387   PyObject *py_r;
4388   int r;
4389   const char *device;
4390
4391   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_resize2fs",
4392                          &py_g, &device))
4393     return NULL;
4394   g = get_handle (py_g);
4395
4396   r = guestfs_resize2fs (g, device);
4397   if (r == -1) {
4398     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4399     return NULL;
4400   }
4401
4402   Py_INCREF (Py_None);
4403   py_r = Py_None;
4404   return py_r;
4405 }
4406
4407 static PyObject *
4408 py_guestfs_find (PyObject *self, PyObject *args)
4409 {
4410   PyObject *py_g;
4411   guestfs_h *g;
4412   PyObject *py_r;
4413   char **r;
4414   const char *directory;
4415
4416   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_find",
4417                          &py_g, &directory))
4418     return NULL;
4419   g = get_handle (py_g);
4420
4421   r = guestfs_find (g, directory);
4422   if (r == NULL) {
4423     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4424     return NULL;
4425   }
4426
4427   py_r = put_string_list (r);
4428   free_strings (r);
4429   return py_r;
4430 }
4431
4432 static PyObject *
4433 py_guestfs_e2fsck_f (PyObject *self, PyObject *args)
4434 {
4435   PyObject *py_g;
4436   guestfs_h *g;
4437   PyObject *py_r;
4438   int r;
4439   const char *device;
4440
4441   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_e2fsck_f",
4442                          &py_g, &device))
4443     return NULL;
4444   g = get_handle (py_g);
4445
4446   r = guestfs_e2fsck_f (g, device);
4447   if (r == -1) {
4448     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4449     return NULL;
4450   }
4451
4452   Py_INCREF (Py_None);
4453   py_r = Py_None;
4454   return py_r;
4455 }
4456
4457 static PyObject *
4458 py_guestfs_sleep (PyObject *self, PyObject *args)
4459 {
4460   PyObject *py_g;
4461   guestfs_h *g;
4462   PyObject *py_r;
4463   int r;
4464   int secs;
4465
4466   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_sleep",
4467                          &py_g, &secs))
4468     return NULL;
4469   g = get_handle (py_g);
4470
4471   r = guestfs_sleep (g, secs);
4472   if (r == -1) {
4473     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4474     return NULL;
4475   }
4476
4477   Py_INCREF (Py_None);
4478   py_r = Py_None;
4479   return py_r;
4480 }
4481
4482 static PyObject *
4483 py_guestfs_ntfs_3g_probe (PyObject *self, PyObject *args)
4484 {
4485   PyObject *py_g;
4486   guestfs_h *g;
4487   PyObject *py_r;
4488   int r;
4489   int rw;
4490   const char *device;
4491
4492   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_ntfs_3g_probe",
4493                          &py_g, &rw, &device))
4494     return NULL;
4495   g = get_handle (py_g);
4496
4497   r = guestfs_ntfs_3g_probe (g, rw, device);
4498   if (r == -1) {
4499     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4500     return NULL;
4501   }
4502
4503   py_r = PyInt_FromLong ((long) r);
4504   return py_r;
4505 }
4506
4507 static PyObject *
4508 py_guestfs_sh (PyObject *self, PyObject *args)
4509 {
4510   PyObject *py_g;
4511   guestfs_h *g;
4512   PyObject *py_r;
4513   char *r;
4514   const char *command;
4515
4516   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sh",
4517                          &py_g, &command))
4518     return NULL;
4519   g = get_handle (py_g);
4520
4521   r = guestfs_sh (g, command);
4522   if (r == NULL) {
4523     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4524     return NULL;
4525   }
4526
4527   py_r = PyString_FromString (r);
4528   free (r);
4529   return py_r;
4530 }
4531
4532 static PyObject *
4533 py_guestfs_sh_lines (PyObject *self, PyObject *args)
4534 {
4535   PyObject *py_g;
4536   guestfs_h *g;
4537   PyObject *py_r;
4538   char **r;
4539   const char *command;
4540
4541   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sh_lines",
4542                          &py_g, &command))
4543     return NULL;
4544   g = get_handle (py_g);
4545
4546   r = guestfs_sh_lines (g, command);
4547   if (r == NULL) {
4548     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4549     return NULL;
4550   }
4551
4552   py_r = put_string_list (r);
4553   free_strings (r);
4554   return py_r;
4555 }
4556
4557 static PyObject *
4558 py_guestfs_glob_expand (PyObject *self, PyObject *args)
4559 {
4560   PyObject *py_g;
4561   guestfs_h *g;
4562   PyObject *py_r;
4563   char **r;
4564   const char *pattern;
4565
4566   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_glob_expand",
4567                          &py_g, &pattern))
4568     return NULL;
4569   g = get_handle (py_g);
4570
4571   r = guestfs_glob_expand (g, pattern);
4572   if (r == NULL) {
4573     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4574     return NULL;
4575   }
4576
4577   py_r = put_string_list (r);
4578   free_strings (r);
4579   return py_r;
4580 }
4581
4582 static PyObject *
4583 py_guestfs_scrub_device (PyObject *self, PyObject *args)
4584 {
4585   PyObject *py_g;
4586   guestfs_h *g;
4587   PyObject *py_r;
4588   int r;
4589   const char *device;
4590
4591   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_device",
4592                          &py_g, &device))
4593     return NULL;
4594   g = get_handle (py_g);
4595
4596   r = guestfs_scrub_device (g, device);
4597   if (r == -1) {
4598     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4599     return NULL;
4600   }
4601
4602   Py_INCREF (Py_None);
4603   py_r = Py_None;
4604   return py_r;
4605 }
4606
4607 static PyObject *
4608 py_guestfs_scrub_file (PyObject *self, PyObject *args)
4609 {
4610   PyObject *py_g;
4611   guestfs_h *g;
4612   PyObject *py_r;
4613   int r;
4614   const char *file;
4615
4616   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_file",
4617                          &py_g, &file))
4618     return NULL;
4619   g = get_handle (py_g);
4620
4621   r = guestfs_scrub_file (g, file);
4622   if (r == -1) {
4623     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4624     return NULL;
4625   }
4626
4627   Py_INCREF (Py_None);
4628   py_r = Py_None;
4629   return py_r;
4630 }
4631
4632 static PyObject *
4633 py_guestfs_scrub_freespace (PyObject *self, PyObject *args)
4634 {
4635   PyObject *py_g;
4636   guestfs_h *g;
4637   PyObject *py_r;
4638   int r;
4639   const char *dir;
4640
4641   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_freespace",
4642                          &py_g, &dir))
4643     return NULL;
4644   g = get_handle (py_g);
4645
4646   r = guestfs_scrub_freespace (g, dir);
4647   if (r == -1) {
4648     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4649     return NULL;
4650   }
4651
4652   Py_INCREF (Py_None);
4653   py_r = Py_None;
4654   return py_r;
4655 }
4656
4657 static PyObject *
4658 py_guestfs_mkdtemp (PyObject *self, PyObject *args)
4659 {
4660   PyObject *py_g;
4661   guestfs_h *g;
4662   PyObject *py_r;
4663   char *r;
4664   const char *template;
4665
4666   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdtemp",
4667                          &py_g, &template))
4668     return NULL;
4669   g = get_handle (py_g);
4670
4671   r = guestfs_mkdtemp (g, template);
4672   if (r == NULL) {
4673     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4674     return NULL;
4675   }
4676
4677   py_r = PyString_FromString (r);
4678   free (r);
4679   return py_r;
4680 }
4681
4682 static PyObject *
4683 py_guestfs_wc_l (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_l",
4692                          &py_g, &path))
4693     return NULL;
4694   g = get_handle (py_g);
4695
4696   r = guestfs_wc_l (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_wc_w (PyObject *self, PyObject *args)
4708 {
4709   PyObject *py_g;
4710   guestfs_h *g;
4711   PyObject *py_r;
4712   int r;
4713   const char *path;
4714
4715   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_wc_w",
4716                          &py_g, &path))
4717     return NULL;
4718   g = get_handle (py_g);
4719
4720   r = guestfs_wc_w (g, path);
4721   if (r == -1) {
4722     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4723     return NULL;
4724   }
4725
4726   py_r = PyInt_FromLong ((long) r);
4727   return py_r;
4728 }
4729
4730 static PyObject *
4731 py_guestfs_wc_c (PyObject *self, PyObject *args)
4732 {
4733   PyObject *py_g;
4734   guestfs_h *g;
4735   PyObject *py_r;
4736   int r;
4737   const char *path;
4738
4739   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_wc_c",
4740                          &py_g, &path))
4741     return NULL;
4742   g = get_handle (py_g);
4743
4744   r = guestfs_wc_c (g, path);
4745   if (r == -1) {
4746     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4747     return NULL;
4748   }
4749
4750   py_r = PyInt_FromLong ((long) r);
4751   return py_r;
4752 }
4753
4754 static PyObject *
4755 py_guestfs_head (PyObject *self, PyObject *args)
4756 {
4757   PyObject *py_g;
4758   guestfs_h *g;
4759   PyObject *py_r;
4760   char **r;
4761   const char *path;
4762
4763   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_head",
4764                          &py_g, &path))
4765     return NULL;
4766   g = get_handle (py_g);
4767
4768   r = guestfs_head (g, path);
4769   if (r == NULL) {
4770     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4771     return NULL;
4772   }
4773
4774   py_r = put_string_list (r);
4775   free_strings (r);
4776   return py_r;
4777 }
4778
4779 static PyObject *
4780 py_guestfs_head_n (PyObject *self, PyObject *args)
4781 {
4782   PyObject *py_g;
4783   guestfs_h *g;
4784   PyObject *py_r;
4785   char **r;
4786   int nrlines;
4787   const char *path;
4788
4789   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_head_n",
4790                          &py_g, &nrlines, &path))
4791     return NULL;
4792   g = get_handle (py_g);
4793
4794   r = guestfs_head_n (g, nrlines, path);
4795   if (r == NULL) {
4796     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4797     return NULL;
4798   }
4799
4800   py_r = put_string_list (r);
4801   free_strings (r);
4802   return py_r;
4803 }
4804
4805 static PyObject *
4806 py_guestfs_tail (PyObject *self, PyObject *args)
4807 {
4808   PyObject *py_g;
4809   guestfs_h *g;
4810   PyObject *py_r;
4811   char **r;
4812   const char *path;
4813
4814   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tail",
4815                          &py_g, &path))
4816     return NULL;
4817   g = get_handle (py_g);
4818
4819   r = guestfs_tail (g, path);
4820   if (r == NULL) {
4821     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4822     return NULL;
4823   }
4824
4825   py_r = put_string_list (r);
4826   free_strings (r);
4827   return py_r;
4828 }
4829
4830 static PyObject *
4831 py_guestfs_tail_n (PyObject *self, PyObject *args)
4832 {
4833   PyObject *py_g;
4834   guestfs_h *g;
4835   PyObject *py_r;
4836   char **r;
4837   int nrlines;
4838   const char *path;
4839
4840   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_tail_n",
4841                          &py_g, &nrlines, &path))
4842     return NULL;
4843   g = get_handle (py_g);
4844
4845   r = guestfs_tail_n (g, nrlines, path);
4846   if (r == NULL) {
4847     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4848     return NULL;
4849   }
4850
4851   py_r = put_string_list (r);
4852   free_strings (r);
4853   return py_r;
4854 }
4855
4856 static PyObject *
4857 py_guestfs_df (PyObject *self, PyObject *args)
4858 {
4859   PyObject *py_g;
4860   guestfs_h *g;
4861   PyObject *py_r;
4862   char *r;
4863
4864   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_df",
4865                          &py_g))
4866     return NULL;
4867   g = get_handle (py_g);
4868
4869   r = guestfs_df (g);
4870   if (r == NULL) {
4871     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4872     return NULL;
4873   }
4874
4875   py_r = PyString_FromString (r);
4876   free (r);
4877   return py_r;
4878 }
4879
4880 static PyObject *
4881 py_guestfs_df_h (PyObject *self, PyObject *args)
4882 {
4883   PyObject *py_g;
4884   guestfs_h *g;
4885   PyObject *py_r;
4886   char *r;
4887
4888   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_df_h",
4889                          &py_g))
4890     return NULL;
4891   g = get_handle (py_g);
4892
4893   r = guestfs_df_h (g);
4894   if (r == NULL) {
4895     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4896     return NULL;
4897   }
4898
4899   py_r = PyString_FromString (r);
4900   free (r);
4901   return py_r;
4902 }
4903
4904 static PyObject *
4905 py_guestfs_du (PyObject *self, PyObject *args)
4906 {
4907   PyObject *py_g;
4908   guestfs_h *g;
4909   PyObject *py_r;
4910   int64_t r;
4911   const char *path;
4912
4913   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_du",
4914                          &py_g, &path))
4915     return NULL;
4916   g = get_handle (py_g);
4917
4918   r = guestfs_du (g, path);
4919   if (r == -1) {
4920     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4921     return NULL;
4922   }
4923
4924   py_r = PyLong_FromLongLong (r);
4925   return py_r;
4926 }
4927
4928 static PyObject *
4929 py_guestfs_initrd_list (PyObject *self, PyObject *args)
4930 {
4931   PyObject *py_g;
4932   guestfs_h *g;
4933   PyObject *py_r;
4934   char **r;
4935   const char *path;
4936
4937   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_initrd_list",
4938                          &py_g, &path))
4939     return NULL;
4940   g = get_handle (py_g);
4941
4942   r = guestfs_initrd_list (g, path);
4943   if (r == NULL) {
4944     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4945     return NULL;
4946   }
4947
4948   py_r = put_string_list (r);
4949   free_strings (r);
4950   return py_r;
4951 }
4952
4953 static PyObject *
4954 py_guestfs_mount_loop (PyObject *self, PyObject *args)
4955 {
4956   PyObject *py_g;
4957   guestfs_h *g;
4958   PyObject *py_r;
4959   int r;
4960   const char *file;
4961   const char *mountpoint;
4962
4963   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_loop",
4964                          &py_g, &file, &mountpoint))
4965     return NULL;
4966   g = get_handle (py_g);
4967
4968   r = guestfs_mount_loop (g, file, mountpoint);
4969   if (r == -1) {
4970     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4971     return NULL;
4972   }
4973
4974   Py_INCREF (Py_None);
4975   py_r = Py_None;
4976   return py_r;
4977 }
4978
4979 static PyObject *
4980 py_guestfs_mkswap (PyObject *self, PyObject *args)
4981 {
4982   PyObject *py_g;
4983   guestfs_h *g;
4984   PyObject *py_r;
4985   int r;
4986   const char *device;
4987
4988   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkswap",
4989                          &py_g, &device))
4990     return NULL;
4991   g = get_handle (py_g);
4992
4993   r = guestfs_mkswap (g, device);
4994   if (r == -1) {
4995     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4996     return NULL;
4997   }
4998
4999   Py_INCREF (Py_None);
5000   py_r = Py_None;
5001   return py_r;
5002 }
5003
5004 static PyObject *
5005 py_guestfs_mkswap_L (PyObject *self, PyObject *args)
5006 {
5007   PyObject *py_g;
5008   guestfs_h *g;
5009   PyObject *py_r;
5010   int r;
5011   const char *label;
5012   const char *device;
5013
5014   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkswap_L",
5015                          &py_g, &label, &device))
5016     return NULL;
5017   g = get_handle (py_g);
5018
5019   r = guestfs_mkswap_L (g, label, device);
5020   if (r == -1) {
5021     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5022     return NULL;
5023   }
5024
5025   Py_INCREF (Py_None);
5026   py_r = Py_None;
5027   return py_r;
5028 }
5029
5030 static PyObject *
5031 py_guestfs_mkswap_U (PyObject *self, PyObject *args)
5032 {
5033   PyObject *py_g;
5034   guestfs_h *g;
5035   PyObject *py_r;
5036   int r;
5037   const char *uuid;
5038   const char *device;
5039
5040   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkswap_U",
5041                          &py_g, &uuid, &device))
5042     return NULL;
5043   g = get_handle (py_g);
5044
5045   r = guestfs_mkswap_U (g, uuid, device);
5046   if (r == -1) {
5047     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5048     return NULL;
5049   }
5050
5051   Py_INCREF (Py_None);
5052   py_r = Py_None;
5053   return py_r;
5054 }
5055
5056 static PyMethodDef methods[] = {
5057   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
5058   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
5059   { (char *) "test0", py_guestfs_test0, METH_VARARGS, NULL },
5060   { (char *) "test0rint", py_guestfs_test0rint, METH_VARARGS, NULL },
5061   { (char *) "test0rinterr", py_guestfs_test0rinterr, METH_VARARGS, NULL },
5062   { (char *) "test0rint64", py_guestfs_test0rint64, METH_VARARGS, NULL },
5063   { (char *) "test0rint64err", py_guestfs_test0rint64err, METH_VARARGS, NULL },
5064   { (char *) "test0rbool", py_guestfs_test0rbool, METH_VARARGS, NULL },
5065   { (char *) "test0rboolerr", py_guestfs_test0rboolerr, METH_VARARGS, NULL },
5066   { (char *) "test0rconststring", py_guestfs_test0rconststring, METH_VARARGS, NULL },
5067   { (char *) "test0rconststringerr", py_guestfs_test0rconststringerr, METH_VARARGS, NULL },
5068   { (char *) "test0rstring", py_guestfs_test0rstring, METH_VARARGS, NULL },
5069   { (char *) "test0rstringerr", py_guestfs_test0rstringerr, METH_VARARGS, NULL },
5070   { (char *) "test0rstringlist", py_guestfs_test0rstringlist, METH_VARARGS, NULL },
5071   { (char *) "test0rstringlisterr", py_guestfs_test0rstringlisterr, METH_VARARGS, NULL },
5072   { (char *) "test0rintbool", py_guestfs_test0rintbool, METH_VARARGS, NULL },
5073   { (char *) "test0rintboolerr", py_guestfs_test0rintboolerr, METH_VARARGS, NULL },
5074   { (char *) "test0rpvlist", py_guestfs_test0rpvlist, METH_VARARGS, NULL },
5075   { (char *) "test0rpvlisterr", py_guestfs_test0rpvlisterr, METH_VARARGS, NULL },
5076   { (char *) "test0rvglist", py_guestfs_test0rvglist, METH_VARARGS, NULL },
5077   { (char *) "test0rvglisterr", py_guestfs_test0rvglisterr, METH_VARARGS, NULL },
5078   { (char *) "test0rlvlist", py_guestfs_test0rlvlist, METH_VARARGS, NULL },
5079   { (char *) "test0rlvlisterr", py_guestfs_test0rlvlisterr, METH_VARARGS, NULL },
5080   { (char *) "test0rstat", py_guestfs_test0rstat, METH_VARARGS, NULL },
5081   { (char *) "test0rstaterr", py_guestfs_test0rstaterr, METH_VARARGS, NULL },
5082   { (char *) "test0rstatvfs", py_guestfs_test0rstatvfs, METH_VARARGS, NULL },
5083   { (char *) "test0rstatvfserr", py_guestfs_test0rstatvfserr, METH_VARARGS, NULL },
5084   { (char *) "test0rhashtable", py_guestfs_test0rhashtable, METH_VARARGS, NULL },
5085   { (char *) "test0rhashtableerr", py_guestfs_test0rhashtableerr, METH_VARARGS, NULL },
5086   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
5087   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
5088   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
5089   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
5090   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
5091   { (char *) "add_drive_ro", py_guestfs_add_drive_ro, METH_VARARGS, NULL },
5092   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
5093   { (char *) "set_qemu", py_guestfs_set_qemu, METH_VARARGS, NULL },
5094   { (char *) "get_qemu", py_guestfs_get_qemu, METH_VARARGS, NULL },
5095   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
5096   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
5097   { (char *) "set_append", py_guestfs_set_append, METH_VARARGS, NULL },
5098   { (char *) "get_append", py_guestfs_get_append, METH_VARARGS, NULL },
5099   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
5100   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
5101   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
5102   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
5103   { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
5104   { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
5105   { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
5106   { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
5107   { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
5108   { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL },
5109   { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL },
5110   { (char *) "end_busy", py_guestfs_end_busy, METH_VARARGS, NULL },
5111   { (char *) "set_memsize", py_guestfs_set_memsize, METH_VARARGS, NULL },
5112   { (char *) "get_memsize", py_guestfs_get_memsize, METH_VARARGS, NULL },
5113   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
5114   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
5115   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
5116   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
5117   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
5118   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
5119   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
5120   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
5121   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
5122   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
5123   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
5124   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
5125   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
5126   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
5127   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
5128   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
5129   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
5130   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
5131   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
5132   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
5133   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
5134   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
5135   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
5136   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
5137   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
5138   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
5139   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
5140   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
5141   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
5142   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
5143   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
5144   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
5145   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
5146   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
5147   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
5148   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
5149   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
5150   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
5151   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
5152   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
5153   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
5154   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
5155   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
5156   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
5157   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
5158   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
5159   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
5160   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
5161   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
5162   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
5163   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
5164   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
5165   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
5166   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
5167   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
5168   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
5169   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
5170   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
5171   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
5172   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
5173   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
5174   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
5175   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
5176   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
5177   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
5178   { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
5179   { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
5180   { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL },
5181   { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL },
5182   { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL },
5183   { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL },
5184   { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL },
5185   { (char *) "mount_ro", py_guestfs_mount_ro, METH_VARARGS, NULL },
5186   { (char *) "mount_options", py_guestfs_mount_options, METH_VARARGS, NULL },
5187   { (char *) "mount_vfs", py_guestfs_mount_vfs, METH_VARARGS, NULL },
5188   { (char *) "debug", py_guestfs_debug, METH_VARARGS, NULL },
5189   { (char *) "lvremove", py_guestfs_lvremove, METH_VARARGS, NULL },
5190   { (char *) "vgremove", py_guestfs_vgremove, METH_VARARGS, NULL },
5191   { (char *) "pvremove", py_guestfs_pvremove, METH_VARARGS, NULL },
5192   { (char *) "set_e2label", py_guestfs_set_e2label, METH_VARARGS, NULL },
5193   { (char *) "get_e2label", py_guestfs_get_e2label, METH_VARARGS, NULL },
5194   { (char *) "set_e2uuid", py_guestfs_set_e2uuid, METH_VARARGS, NULL },
5195   { (char *) "get_e2uuid", py_guestfs_get_e2uuid, METH_VARARGS, NULL },
5196   { (char *) "fsck", py_guestfs_fsck, METH_VARARGS, NULL },
5197   { (char *) "zero", py_guestfs_zero, METH_VARARGS, NULL },
5198   { (char *) "grub_install", py_guestfs_grub_install, METH_VARARGS, NULL },
5199   { (char *) "cp", py_guestfs_cp, METH_VARARGS, NULL },
5200   { (char *) "cp_a", py_guestfs_cp_a, METH_VARARGS, NULL },
5201   { (char *) "mv", py_guestfs_mv, METH_VARARGS, NULL },
5202   { (char *) "drop_caches", py_guestfs_drop_caches, METH_VARARGS, NULL },
5203   { (char *) "dmesg", py_guestfs_dmesg, METH_VARARGS, NULL },
5204   { (char *) "ping_daemon", py_guestfs_ping_daemon, METH_VARARGS, NULL },
5205   { (char *) "equal", py_guestfs_equal, METH_VARARGS, NULL },
5206   { (char *) "strings", py_guestfs_strings, METH_VARARGS, NULL },
5207   { (char *) "strings_e", py_guestfs_strings_e, METH_VARARGS, NULL },
5208   { (char *) "hexdump", py_guestfs_hexdump, METH_VARARGS, NULL },
5209   { (char *) "zerofree", py_guestfs_zerofree, METH_VARARGS, NULL },
5210   { (char *) "pvresize", py_guestfs_pvresize, METH_VARARGS, NULL },
5211   { (char *) "sfdisk_N", py_guestfs_sfdisk_N, METH_VARARGS, NULL },
5212   { (char *) "sfdisk_l", py_guestfs_sfdisk_l, METH_VARARGS, NULL },
5213   { (char *) "sfdisk_kernel_geometry", py_guestfs_sfdisk_kernel_geometry, METH_VARARGS, NULL },
5214   { (char *) "sfdisk_disk_geometry", py_guestfs_sfdisk_disk_geometry, METH_VARARGS, NULL },
5215   { (char *) "vg_activate_all", py_guestfs_vg_activate_all, METH_VARARGS, NULL },
5216   { (char *) "vg_activate", py_guestfs_vg_activate, METH_VARARGS, NULL },
5217   { (char *) "lvresize", py_guestfs_lvresize, METH_VARARGS, NULL },
5218   { (char *) "resize2fs", py_guestfs_resize2fs, METH_VARARGS, NULL },
5219   { (char *) "find", py_guestfs_find, METH_VARARGS, NULL },
5220   { (char *) "e2fsck_f", py_guestfs_e2fsck_f, METH_VARARGS, NULL },
5221   { (char *) "sleep", py_guestfs_sleep, METH_VARARGS, NULL },
5222   { (char *) "ntfs_3g_probe", py_guestfs_ntfs_3g_probe, METH_VARARGS, NULL },
5223   { (char *) "sh", py_guestfs_sh, METH_VARARGS, NULL },
5224   { (char *) "sh_lines", py_guestfs_sh_lines, METH_VARARGS, NULL },
5225   { (char *) "glob_expand", py_guestfs_glob_expand, METH_VARARGS, NULL },
5226   { (char *) "scrub_device", py_guestfs_scrub_device, METH_VARARGS, NULL },
5227   { (char *) "scrub_file", py_guestfs_scrub_file, METH_VARARGS, NULL },
5228   { (char *) "scrub_freespace", py_guestfs_scrub_freespace, METH_VARARGS, NULL },
5229   { (char *) "mkdtemp", py_guestfs_mkdtemp, METH_VARARGS, NULL },
5230   { (char *) "wc_l", py_guestfs_wc_l, METH_VARARGS, NULL },
5231   { (char *) "wc_w", py_guestfs_wc_w, METH_VARARGS, NULL },
5232   { (char *) "wc_c", py_guestfs_wc_c, METH_VARARGS, NULL },
5233   { (char *) "head", py_guestfs_head, METH_VARARGS, NULL },
5234   { (char *) "head_n", py_guestfs_head_n, METH_VARARGS, NULL },
5235   { (char *) "tail", py_guestfs_tail, METH_VARARGS, NULL },
5236   { (char *) "tail_n", py_guestfs_tail_n, METH_VARARGS, NULL },
5237   { (char *) "df", py_guestfs_df, METH_VARARGS, NULL },
5238   { (char *) "df_h", py_guestfs_df_h, METH_VARARGS, NULL },
5239   { (char *) "du", py_guestfs_du, METH_VARARGS, NULL },
5240   { (char *) "initrd_list", py_guestfs_initrd_list, METH_VARARGS, NULL },
5241   { (char *) "mount_loop", py_guestfs_mount_loop, METH_VARARGS, NULL },
5242   { (char *) "mkswap", py_guestfs_mkswap, METH_VARARGS, NULL },
5243   { (char *) "mkswap_L", py_guestfs_mkswap_L, METH_VARARGS, NULL },
5244   { (char *) "mkswap_U", py_guestfs_mkswap_U, METH_VARARGS, NULL },
5245   { NULL, NULL, 0, NULL }
5246 };
5247
5248 void
5249 initlibguestfsmod (void)
5250 {
5251   static int initialized = 0;
5252
5253   if (initialized) return;
5254   Py_InitModule ((char *) "libguestfsmod", methods);
5255   initialized = 1;
5256 }