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 put_dirent (struct guestfs_dirent *dirent)
 393 {
 394   PyObject *dict;
 395
 396   dict = PyDict_New ();
 397   PyDict_SetItemString (dict, "ino",
 398                         PyLong_FromLongLong (dirent->ino));
 399   PyDict_SetItemString (dict, "ftyp",
 400                         PyString_FromStringAndSize (&dirent->ftyp, 1));
 401   PyDict_SetItemString (dict, "name",
 402                         PyString_FromString (dirent->name));
 403   return dict;
 404 };
 405
 406 static PyObject *
 407 put_dirent_list (struct guestfs_dirent_list *dirents)
 408 {
 409   PyObject *list;
 410   int i;
 411
 412   list = PyList_New (dirents->len);
 413   for (i = 0; i < dirents->len; ++i)
 414     PyList_SetItem (list, i, put_dirent (&dirents->val[i]));
 415   return list;
 416 };
 417
 418 static PyObject *
 419 py_guestfs_test0 (PyObject *self, PyObject *args)
 420 {
 421   PyObject *py_g;
 422   guestfs_h *g;
 423   PyObject *py_r;
 424   int r;
 425   const char *str;
 426   const char *optstr;
 427   PyObject *py_strlist;
 428   const char **strlist;
 429   int b;
 430   int integer;
 431   const char *filein;
 432   const char *fileout;
 433
 434   if (!PyArg_ParseTuple (args, (char *) "OszOiiss:guestfs_test0",
 435                          &py_g, &str, &optstr, &py_strlist, &b, &integer, &filein, &fileout))
 436     return NULL;
 437   g = get_handle (py_g);
 438   strlist = get_string_list (py_strlist);
 439   if (!strlist) return NULL;
 440
 441   r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
 442   free (strlist);
 443   if (r == -1) {
 444     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 445     return NULL;
 446   }
 447
 448   Py_INCREF (Py_None);
 449   py_r = Py_None;
 450   return py_r;
 451 }
 452
 453 static PyObject *
 454 py_guestfs_test0rint (PyObject *self, PyObject *args)
 455 {
 456   PyObject *py_g;
 457   guestfs_h *g;
 458   PyObject *py_r;
 459   int r;
 460   const char *val;
 461
 462   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rint",
 463                          &py_g, &val))
 464     return NULL;
 465   g = get_handle (py_g);
 466
 467   r = guestfs_test0rint (g, val);
 468   if (r == -1) {
 469     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 470     return NULL;
 471   }
 472
 473   py_r = PyInt_FromLong ((long) r);
 474   return py_r;
 475 }
 476
 477 static PyObject *
 478 py_guestfs_test0rinterr (PyObject *self, PyObject *args)
 479 {
 480   PyObject *py_g;
 481   guestfs_h *g;
 482   PyObject *py_r;
 483   int r;
 484
 485   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rinterr",
 486                          &py_g))
 487     return NULL;
 488   g = get_handle (py_g);
 489
 490   r = guestfs_test0rinterr (g);
 491   if (r == -1) {
 492     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 493     return NULL;
 494   }
 495
 496   py_r = PyInt_FromLong ((long) r);
 497   return py_r;
 498 }
 499
 500 static PyObject *
 501 py_guestfs_test0rint64 (PyObject *self, PyObject *args)
 502 {
 503   PyObject *py_g;
 504   guestfs_h *g;
 505   PyObject *py_r;
 506   int64_t r;
 507   const char *val;
 508
 509   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rint64",
 510                          &py_g, &val))
 511     return NULL;
 512   g = get_handle (py_g);
 513
 514   r = guestfs_test0rint64 (g, val);
 515   if (r == -1) {
 516     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 517     return NULL;
 518   }
 519
 520   py_r = PyLong_FromLongLong (r);
 521   return py_r;
 522 }
 523
 524 static PyObject *
 525 py_guestfs_test0rint64err (PyObject *self, PyObject *args)
 526 {
 527   PyObject *py_g;
 528   guestfs_h *g;
 529   PyObject *py_r;
 530   int64_t r;
 531
 532   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rint64err",
 533                          &py_g))
 534     return NULL;
 535   g = get_handle (py_g);
 536
 537   r = guestfs_test0rint64err (g);
 538   if (r == -1) {
 539     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 540     return NULL;
 541   }
 542
 543   py_r = PyLong_FromLongLong (r);
 544   return py_r;
 545 }
 546
 547 static PyObject *
 548 py_guestfs_test0rbool (PyObject *self, PyObject *args)
 549 {
 550   PyObject *py_g;
 551   guestfs_h *g;
 552   PyObject *py_r;
 553   int r;
 554   const char *val;
 555
 556   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rbool",
 557                          &py_g, &val))
 558     return NULL;
 559   g = get_handle (py_g);
 560
 561   r = guestfs_test0rbool (g, val);
 562   if (r == -1) {
 563     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 564     return NULL;
 565   }
 566
 567   py_r = PyInt_FromLong ((long) r);
 568   return py_r;
 569 }
 570
 571 static PyObject *
 572 py_guestfs_test0rboolerr (PyObject *self, PyObject *args)
 573 {
 574   PyObject *py_g;
 575   guestfs_h *g;
 576   PyObject *py_r;
 577   int r;
 578
 579   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rboolerr",
 580                          &py_g))
 581     return NULL;
 582   g = get_handle (py_g);
 583
 584   r = guestfs_test0rboolerr (g);
 585   if (r == -1) {
 586     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 587     return NULL;
 588   }
 589
 590   py_r = PyInt_FromLong ((long) r);
 591   return py_r;
 592 }
 593
 594 static PyObject *
 595 py_guestfs_test0rconststring (PyObject *self, PyObject *args)
 596 {
 597   PyObject *py_g;
 598   guestfs_h *g;
 599   PyObject *py_r;
 600   const char *r;
 601   const char *val;
 602
 603   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rconststring",
 604                          &py_g, &val))
 605     return NULL;
 606   g = get_handle (py_g);
 607
 608   r = guestfs_test0rconststring (g, val);
 609   if (r == NULL) {
 610     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 611     return NULL;
 612   }
 613
 614   py_r = PyString_FromString (r);
 615   return py_r;
 616 }
 617
 618 static PyObject *
 619 py_guestfs_test0rconststringerr (PyObject *self, PyObject *args)
 620 {
 621   PyObject *py_g;
 622   guestfs_h *g;
 623   PyObject *py_r;
 624   const char *r;
 625
 626   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rconststringerr",
 627                          &py_g))
 628     return NULL;
 629   g = get_handle (py_g);
 630
 631   r = guestfs_test0rconststringerr (g);
 632   if (r == NULL) {
 633     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 634     return NULL;
 635   }
 636
 637   py_r = PyString_FromString (r);
 638   return py_r;
 639 }
 640
 641 static PyObject *
 642 py_guestfs_test0rstring (PyObject *self, PyObject *args)
 643 {
 644   PyObject *py_g;
 645   guestfs_h *g;
 646   PyObject *py_r;
 647   char *r;
 648   const char *val;
 649
 650   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstring",
 651                          &py_g, &val))
 652     return NULL;
 653   g = get_handle (py_g);
 654
 655   r = guestfs_test0rstring (g, val);
 656   if (r == NULL) {
 657     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 658     return NULL;
 659   }
 660
 661   py_r = PyString_FromString (r);
 662   free (r);
 663   return py_r;
 664 }
 665
 666 static PyObject *
 667 py_guestfs_test0rstringerr (PyObject *self, PyObject *args)
 668 {
 669   PyObject *py_g;
 670   guestfs_h *g;
 671   PyObject *py_r;
 672   char *r;
 673
 674   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstringerr",
 675                          &py_g))
 676     return NULL;
 677   g = get_handle (py_g);
 678
 679   r = guestfs_test0rstringerr (g);
 680   if (r == NULL) {
 681     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 682     return NULL;
 683   }
 684
 685   py_r = PyString_FromString (r);
 686   free (r);
 687   return py_r;
 688 }
 689
 690 static PyObject *
 691 py_guestfs_test0rstringlist (PyObject *self, PyObject *args)
 692 {
 693   PyObject *py_g;
 694   guestfs_h *g;
 695   PyObject *py_r;
 696   char **r;
 697   const char *val;
 698
 699   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstringlist",
 700                          &py_g, &val))
 701     return NULL;
 702   g = get_handle (py_g);
 703
 704   r = guestfs_test0rstringlist (g, val);
 705   if (r == NULL) {
 706     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 707     return NULL;
 708   }
 709
 710   py_r = put_string_list (r);
 711   free_strings (r);
 712   return py_r;
 713 }
 714
 715 static PyObject *
 716 py_guestfs_test0rstringlisterr (PyObject *self, PyObject *args)
 717 {
 718   PyObject *py_g;
 719   guestfs_h *g;
 720   PyObject *py_r;
 721   char **r;
 722
 723   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstringlisterr",
 724                          &py_g))
 725     return NULL;
 726   g = get_handle (py_g);
 727
 728   r = guestfs_test0rstringlisterr (g);
 729   if (r == NULL) {
 730     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 731     return NULL;
 732   }
 733
 734   py_r = put_string_list (r);
 735   free_strings (r);
 736   return py_r;
 737 }
 738
 739 static PyObject *
 740 py_guestfs_test0rintbool (PyObject *self, PyObject *args)
 741 {
 742   PyObject *py_g;
 743   guestfs_h *g;
 744   PyObject *py_r;
 745   struct guestfs_int_bool *r;
 746   const char *val;
 747
 748   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rintbool",
 749                          &py_g, &val))
 750     return NULL;
 751   g = get_handle (py_g);
 752
 753   r = guestfs_test0rintbool (g, val);
 754   if (r == NULL) {
 755     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 756     return NULL;
 757   }
 758
 759   py_r = PyTuple_New (2);
 760   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
 761   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
 762   guestfs_free_int_bool (r);
 763   return py_r;
 764 }
 765
 766 static PyObject *
 767 py_guestfs_test0rintboolerr (PyObject *self, PyObject *args)
 768 {
 769   PyObject *py_g;
 770   guestfs_h *g;
 771   PyObject *py_r;
 772   struct guestfs_int_bool *r;
 773
 774   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rintboolerr",
 775                          &py_g))
 776     return NULL;
 777   g = get_handle (py_g);
 778
 779   r = guestfs_test0rintboolerr (g);
 780   if (r == NULL) {
 781     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 782     return NULL;
 783   }
 784
 785   py_r = PyTuple_New (2);
 786   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
 787   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
 788   guestfs_free_int_bool (r);
 789   return py_r;
 790 }
 791
 792 static PyObject *
 793 py_guestfs_test0rpvlist (PyObject *self, PyObject *args)
 794 {
 795   PyObject *py_g;
 796   guestfs_h *g;
 797   PyObject *py_r;
 798   struct guestfs_lvm_pv_list *r;
 799   const char *val;
 800
 801   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rpvlist",
 802                          &py_g, &val))
 803     return NULL;
 804   g = get_handle (py_g);
 805
 806   r = guestfs_test0rpvlist (g, val);
 807   if (r == NULL) {
 808     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 809     return NULL;
 810   }
 811
 812   py_r = put_lvm_pv_list (r);
 813   guestfs_free_lvm_pv_list (r);
 814   return py_r;
 815 }
 816
 817 static PyObject *
 818 py_guestfs_test0rpvlisterr (PyObject *self, PyObject *args)
 819 {
 820   PyObject *py_g;
 821   guestfs_h *g;
 822   PyObject *py_r;
 823   struct guestfs_lvm_pv_list *r;
 824
 825   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rpvlisterr",
 826                          &py_g))
 827     return NULL;
 828   g = get_handle (py_g);
 829
 830   r = guestfs_test0rpvlisterr (g);
 831   if (r == NULL) {
 832     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 833     return NULL;
 834   }
 835
 836   py_r = put_lvm_pv_list (r);
 837   guestfs_free_lvm_pv_list (r);
 838   return py_r;
 839 }
 840
 841 static PyObject *
 842 py_guestfs_test0rvglist (PyObject *self, PyObject *args)
 843 {
 844   PyObject *py_g;
 845   guestfs_h *g;
 846   PyObject *py_r;
 847   struct guestfs_lvm_vg_list *r;
 848   const char *val;
 849
 850   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rvglist",
 851                          &py_g, &val))
 852     return NULL;
 853   g = get_handle (py_g);
 854
 855   r = guestfs_test0rvglist (g, val);
 856   if (r == NULL) {
 857     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 858     return NULL;
 859   }
 860
 861   py_r = put_lvm_vg_list (r);
 862   guestfs_free_lvm_vg_list (r);
 863   return py_r;
 864 }
 865
 866 static PyObject *
 867 py_guestfs_test0rvglisterr (PyObject *self, PyObject *args)
 868 {
 869   PyObject *py_g;
 870   guestfs_h *g;
 871   PyObject *py_r;
 872   struct guestfs_lvm_vg_list *r;
 873
 874   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rvglisterr",
 875                          &py_g))
 876     return NULL;
 877   g = get_handle (py_g);
 878
 879   r = guestfs_test0rvglisterr (g);
 880   if (r == NULL) {
 881     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 882     return NULL;
 883   }
 884
 885   py_r = put_lvm_vg_list (r);
 886   guestfs_free_lvm_vg_list (r);
 887   return py_r;
 888 }
 889
 890 static PyObject *
 891 py_guestfs_test0rlvlist (PyObject *self, PyObject *args)
 892 {
 893   PyObject *py_g;
 894   guestfs_h *g;
 895   PyObject *py_r;
 896   struct guestfs_lvm_lv_list *r;
 897   const char *val;
 898
 899   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rlvlist",
 900                          &py_g, &val))
 901     return NULL;
 902   g = get_handle (py_g);
 903
 904   r = guestfs_test0rlvlist (g, val);
 905   if (r == NULL) {
 906     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 907     return NULL;
 908   }
 909
 910   py_r = put_lvm_lv_list (r);
 911   guestfs_free_lvm_lv_list (r);
 912   return py_r;
 913 }
 914
 915 static PyObject *
 916 py_guestfs_test0rlvlisterr (PyObject *self, PyObject *args)
 917 {
 918   PyObject *py_g;
 919   guestfs_h *g;
 920   PyObject *py_r;
 921   struct guestfs_lvm_lv_list *r;
 922
 923   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rlvlisterr",
 924                          &py_g))
 925     return NULL;
 926   g = get_handle (py_g);
 927
 928   r = guestfs_test0rlvlisterr (g);
 929   if (r == NULL) {
 930     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 931     return NULL;
 932   }
 933
 934   py_r = put_lvm_lv_list (r);
 935   guestfs_free_lvm_lv_list (r);
 936   return py_r;
 937 }
 938
 939 static PyObject *
 940 py_guestfs_test0rstat (PyObject *self, PyObject *args)
 941 {
 942   PyObject *py_g;
 943   guestfs_h *g;
 944   PyObject *py_r;
 945   struct guestfs_stat *r;
 946   const char *val;
 947
 948   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstat",
 949                          &py_g, &val))
 950     return NULL;
 951   g = get_handle (py_g);
 952
 953   r = guestfs_test0rstat (g, val);
 954   if (r == NULL) {
 955     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 956     return NULL;
 957   }
 958
 959   py_r = put_stat (r);
 960   free (r);
 961   return py_r;
 962 }
 963
 964 static PyObject *
 965 py_guestfs_test0rstaterr (PyObject *self, PyObject *args)
 966 {
 967   PyObject *py_g;
 968   guestfs_h *g;
 969   PyObject *py_r;
 970   struct guestfs_stat *r;
 971
 972   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstaterr",
 973                          &py_g))
 974     return NULL;
 975   g = get_handle (py_g);
 976
 977   r = guestfs_test0rstaterr (g);
 978   if (r == NULL) {
 979     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 980     return NULL;
 981   }
 982
 983   py_r = put_stat (r);
 984   free (r);
 985   return py_r;
 986 }
 987
 988 static PyObject *
 989 py_guestfs_test0rstatvfs (PyObject *self, PyObject *args)
 990 {
 991   PyObject *py_g;
 992   guestfs_h *g;
 993   PyObject *py_r;
 994   struct guestfs_statvfs *r;
 995   const char *val;
 996
 997   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstatvfs",
 998                          &py_g, &val))
 999     return NULL;
1000   g = get_handle (py_g);
1001
1002   r = guestfs_test0rstatvfs (g, val);
1003   if (r == NULL) {
1004     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1005     return NULL;
1006   }
1007
1008   py_r = put_statvfs (r);
1009   free (r);
1010   return py_r;
1011 }
1012
1013 static PyObject *
1014 py_guestfs_test0rstatvfserr (PyObject *self, PyObject *args)
1015 {
1016   PyObject *py_g;
1017   guestfs_h *g;
1018   PyObject *py_r;
1019   struct guestfs_statvfs *r;
1020
1021   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstatvfserr",
1022                          &py_g))
1023     return NULL;
1024   g = get_handle (py_g);
1025
1026   r = guestfs_test0rstatvfserr (g);
1027   if (r == NULL) {
1028     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1029     return NULL;
1030   }
1031
1032   py_r = put_statvfs (r);
1033   free (r);
1034   return py_r;
1035 }
1036
1037 static PyObject *
1038 py_guestfs_test0rhashtable (PyObject *self, PyObject *args)
1039 {
1040   PyObject *py_g;
1041   guestfs_h *g;
1042   PyObject *py_r;
1043   char **r;
1044   const char *val;
1045
1046   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rhashtable",
1047                          &py_g, &val))
1048     return NULL;
1049   g = get_handle (py_g);
1050
1051   r = guestfs_test0rhashtable (g, val);
1052   if (r == NULL) {
1053     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1054     return NULL;
1055   }
1056
1057   py_r = put_table (r);
1058   free_strings (r);
1059   return py_r;
1060 }
1061
1062 static PyObject *
1063 py_guestfs_test0rhashtableerr (PyObject *self, PyObject *args)
1064 {
1065   PyObject *py_g;
1066   guestfs_h *g;
1067   PyObject *py_r;
1068   char **r;
1069
1070   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rhashtableerr",
1071                          &py_g))
1072     return NULL;
1073   g = get_handle (py_g);
1074
1075   r = guestfs_test0rhashtableerr (g);
1076   if (r == NULL) {
1077     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1078     return NULL;
1079   }
1080
1081   py_r = put_table (r);
1082   free_strings (r);
1083   return py_r;
1084 }
1085
1086 static PyObject *
1087 py_guestfs_launch (PyObject *self, PyObject *args)
1088 {
1089   PyObject *py_g;
1090   guestfs_h *g;
1091   PyObject *py_r;
1092   int r;
1093
1094   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch",
1095                          &py_g))
1096     return NULL;
1097   g = get_handle (py_g);
1098
1099   r = guestfs_launch (g);
1100   if (r == -1) {
1101     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1102     return NULL;
1103   }
1104
1105   Py_INCREF (Py_None);
1106   py_r = Py_None;
1107   return py_r;
1108 }
1109
1110 static PyObject *
1111 py_guestfs_wait_ready (PyObject *self, PyObject *args)
1112 {
1113   PyObject *py_g;
1114   guestfs_h *g;
1115   PyObject *py_r;
1116   int r;
1117
1118   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready",
1119                          &py_g))
1120     return NULL;
1121   g = get_handle (py_g);
1122
1123   r = guestfs_wait_ready (g);
1124   if (r == -1) {
1125     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1126     return NULL;
1127   }
1128
1129   Py_INCREF (Py_None);
1130   py_r = Py_None;
1131   return py_r;
1132 }
1133
1134 static PyObject *
1135 py_guestfs_kill_subprocess (PyObject *self, PyObject *args)
1136 {
1137   PyObject *py_g;
1138   guestfs_h *g;
1139   PyObject *py_r;
1140   int r;
1141
1142   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess",
1143                          &py_g))
1144     return NULL;
1145   g = get_handle (py_g);
1146
1147   r = guestfs_kill_subprocess (g);
1148   if (r == -1) {
1149     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1150     return NULL;
1151   }
1152
1153   Py_INCREF (Py_None);
1154   py_r = Py_None;
1155   return py_r;
1156 }
1157
1158 static PyObject *
1159 py_guestfs_add_drive (PyObject *self, PyObject *args)
1160 {
1161   PyObject *py_g;
1162   guestfs_h *g;
1163   PyObject *py_r;
1164   int r;
1165   const char *filename;
1166
1167   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive",
1168                          &py_g, &filename))
1169     return NULL;
1170   g = get_handle (py_g);
1171
1172   r = guestfs_add_drive (g, filename);
1173   if (r == -1) {
1174     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1175     return NULL;
1176   }
1177
1178   Py_INCREF (Py_None);
1179   py_r = Py_None;
1180   return py_r;
1181 }
1182
1183 static PyObject *
1184 py_guestfs_add_cdrom (PyObject *self, PyObject *args)
1185 {
1186   PyObject *py_g;
1187   guestfs_h *g;
1188   PyObject *py_r;
1189   int r;
1190   const char *filename;
1191
1192   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom",
1193                          &py_g, &filename))
1194     return NULL;
1195   g = get_handle (py_g);
1196
1197   r = guestfs_add_cdrom (g, filename);
1198   if (r == -1) {
1199     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1200     return NULL;
1201   }
1202
1203   Py_INCREF (Py_None);
1204   py_r = Py_None;
1205   return py_r;
1206 }
1207
1208 static PyObject *
1209 py_guestfs_add_drive_ro (PyObject *self, PyObject *args)
1210 {
1211   PyObject *py_g;
1212   guestfs_h *g;
1213   PyObject *py_r;
1214   int r;
1215   const char *filename;
1216
1217   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive_ro",
1218                          &py_g, &filename))
1219     return NULL;
1220   g = get_handle (py_g);
1221
1222   r = guestfs_add_drive_ro (g, filename);
1223   if (r == -1) {
1224     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1225     return NULL;
1226   }
1227
1228   Py_INCREF (Py_None);
1229   py_r = Py_None;
1230   return py_r;
1231 }
1232
1233 static PyObject *
1234 py_guestfs_config (PyObject *self, PyObject *args)
1235 {
1236   PyObject *py_g;
1237   guestfs_h *g;
1238   PyObject *py_r;
1239   int r;
1240   const char *qemuparam;
1241   const char *qemuvalue;
1242
1243   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config",
1244                          &py_g, &qemuparam, &qemuvalue))
1245     return NULL;
1246   g = get_handle (py_g);
1247
1248   r = guestfs_config (g, qemuparam, qemuvalue);
1249   if (r == -1) {
1250     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1251     return NULL;
1252   }
1253
1254   Py_INCREF (Py_None);
1255   py_r = Py_None;
1256   return py_r;
1257 }
1258
1259 static PyObject *
1260 py_guestfs_set_qemu (PyObject *self, PyObject *args)
1261 {
1262   PyObject *py_g;
1263   guestfs_h *g;
1264   PyObject *py_r;
1265   int r;
1266   const char *qemu;
1267
1268   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_qemu",
1269                          &py_g, &qemu))
1270     return NULL;
1271   g = get_handle (py_g);
1272
1273   r = guestfs_set_qemu (g, qemu);
1274   if (r == -1) {
1275     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1276     return NULL;
1277   }
1278
1279   Py_INCREF (Py_None);
1280   py_r = Py_None;
1281   return py_r;
1282 }
1283
1284 static PyObject *
1285 py_guestfs_get_qemu (PyObject *self, PyObject *args)
1286 {
1287   PyObject *py_g;
1288   guestfs_h *g;
1289   PyObject *py_r;
1290   const char *r;
1291
1292   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_qemu",
1293                          &py_g))
1294     return NULL;
1295   g = get_handle (py_g);
1296
1297   r = guestfs_get_qemu (g);
1298   if (r == NULL) {
1299     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1300     return NULL;
1301   }
1302
1303   py_r = PyString_FromString (r);
1304   return py_r;
1305 }
1306
1307 static PyObject *
1308 py_guestfs_set_path (PyObject *self, PyObject *args)
1309 {
1310   PyObject *py_g;
1311   guestfs_h *g;
1312   PyObject *py_r;
1313   int r;
1314   const char *path;
1315
1316   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
1317                          &py_g, &path))
1318     return NULL;
1319   g = get_handle (py_g);
1320
1321   r = guestfs_set_path (g, path);
1322   if (r == -1) {
1323     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1324     return NULL;
1325   }
1326
1327   Py_INCREF (Py_None);
1328   py_r = Py_None;
1329   return py_r;
1330 }
1331
1332 static PyObject *
1333 py_guestfs_get_path (PyObject *self, PyObject *args)
1334 {
1335   PyObject *py_g;
1336   guestfs_h *g;
1337   PyObject *py_r;
1338   const char *r;
1339
1340   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
1341                          &py_g))
1342     return NULL;
1343   g = get_handle (py_g);
1344
1345   r = guestfs_get_path (g);
1346   if (r == NULL) {
1347     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1348     return NULL;
1349   }
1350
1351   py_r = PyString_FromString (r);
1352   return py_r;
1353 }
1354
1355 static PyObject *
1356 py_guestfs_set_append (PyObject *self, PyObject *args)
1357 {
1358   PyObject *py_g;
1359   guestfs_h *g;
1360   PyObject *py_r;
1361   int r;
1362   const char *append;
1363
1364   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_append",
1365                          &py_g, &append))
1366     return NULL;
1367   g = get_handle (py_g);
1368
1369   r = guestfs_set_append (g, append);
1370   if (r == -1) {
1371     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1372     return NULL;
1373   }
1374
1375   Py_INCREF (Py_None);
1376   py_r = Py_None;
1377   return py_r;
1378 }
1379
1380 static PyObject *
1381 py_guestfs_get_append (PyObject *self, PyObject *args)
1382 {
1383   PyObject *py_g;
1384   guestfs_h *g;
1385   PyObject *py_r;
1386   const char *r;
1387
1388   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_append",
1389                          &py_g))
1390     return NULL;
1391   g = get_handle (py_g);
1392
1393   r = guestfs_get_append (g);
1394   if (r == NULL) {
1395     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1396     return NULL;
1397   }
1398
1399   py_r = PyString_FromString (r);
1400   return py_r;
1401 }
1402
1403 static PyObject *
1404 py_guestfs_set_autosync (PyObject *self, PyObject *args)
1405 {
1406   PyObject *py_g;
1407   guestfs_h *g;
1408   PyObject *py_r;
1409   int r;
1410   int autosync;
1411
1412   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
1413                          &py_g, &autosync))
1414     return NULL;
1415   g = get_handle (py_g);
1416
1417   r = guestfs_set_autosync (g, autosync);
1418   if (r == -1) {
1419     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1420     return NULL;
1421   }
1422
1423   Py_INCREF (Py_None);
1424   py_r = Py_None;
1425   return py_r;
1426 }
1427
1428 static PyObject *
1429 py_guestfs_get_autosync (PyObject *self, PyObject *args)
1430 {
1431   PyObject *py_g;
1432   guestfs_h *g;
1433   PyObject *py_r;
1434   int r;
1435
1436   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
1437                          &py_g))
1438     return NULL;
1439   g = get_handle (py_g);
1440
1441   r = guestfs_get_autosync (g);
1442   if (r == -1) {
1443     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1444     return NULL;
1445   }
1446
1447   py_r = PyInt_FromLong ((long) r);
1448   return py_r;
1449 }
1450
1451 static PyObject *
1452 py_guestfs_set_verbose (PyObject *self, PyObject *args)
1453 {
1454   PyObject *py_g;
1455   guestfs_h *g;
1456   PyObject *py_r;
1457   int r;
1458   int verbose;
1459
1460   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
1461                          &py_g, &verbose))
1462     return NULL;
1463   g = get_handle (py_g);
1464
1465   r = guestfs_set_verbose (g, verbose);
1466   if (r == -1) {
1467     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1468     return NULL;
1469   }
1470
1471   Py_INCREF (Py_None);
1472   py_r = Py_None;
1473   return py_r;
1474 }
1475
1476 static PyObject *
1477 py_guestfs_get_verbose (PyObject *self, PyObject *args)
1478 {
1479   PyObject *py_g;
1480   guestfs_h *g;
1481   PyObject *py_r;
1482   int r;
1483
1484   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
1485                          &py_g))
1486     return NULL;
1487   g = get_handle (py_g);
1488
1489   r = guestfs_get_verbose (g);
1490   if (r == -1) {
1491     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1492     return NULL;
1493   }
1494
1495   py_r = PyInt_FromLong ((long) r);
1496   return py_r;
1497 }
1498
1499 static PyObject *
1500 py_guestfs_is_ready (PyObject *self, PyObject *args)
1501 {
1502   PyObject *py_g;
1503   guestfs_h *g;
1504   PyObject *py_r;
1505   int r;
1506
1507   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready",
1508                          &py_g))
1509     return NULL;
1510   g = get_handle (py_g);
1511
1512   r = guestfs_is_ready (g);
1513   if (r == -1) {
1514     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1515     return NULL;
1516   }
1517
1518   py_r = PyInt_FromLong ((long) r);
1519   return py_r;
1520 }
1521
1522 static PyObject *
1523 py_guestfs_is_config (PyObject *self, PyObject *args)
1524 {
1525   PyObject *py_g;
1526   guestfs_h *g;
1527   PyObject *py_r;
1528   int r;
1529
1530   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config",
1531                          &py_g))
1532     return NULL;
1533   g = get_handle (py_g);
1534
1535   r = guestfs_is_config (g);
1536   if (r == -1) {
1537     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1538     return NULL;
1539   }
1540
1541   py_r = PyInt_FromLong ((long) r);
1542   return py_r;
1543 }
1544
1545 static PyObject *
1546 py_guestfs_is_launching (PyObject *self, PyObject *args)
1547 {
1548   PyObject *py_g;
1549   guestfs_h *g;
1550   PyObject *py_r;
1551   int r;
1552
1553   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching",
1554                          &py_g))
1555     return NULL;
1556   g = get_handle (py_g);
1557
1558   r = guestfs_is_launching (g);
1559   if (r == -1) {
1560     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1561     return NULL;
1562   }
1563
1564   py_r = PyInt_FromLong ((long) r);
1565   return py_r;
1566 }
1567
1568 static PyObject *
1569 py_guestfs_is_busy (PyObject *self, PyObject *args)
1570 {
1571   PyObject *py_g;
1572   guestfs_h *g;
1573   PyObject *py_r;
1574   int r;
1575
1576   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy",
1577                          &py_g))
1578     return NULL;
1579   g = get_handle (py_g);
1580
1581   r = guestfs_is_busy (g);
1582   if (r == -1) {
1583     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1584     return NULL;
1585   }
1586
1587   py_r = PyInt_FromLong ((long) r);
1588   return py_r;
1589 }
1590
1591 static PyObject *
1592 py_guestfs_get_state (PyObject *self, PyObject *args)
1593 {
1594   PyObject *py_g;
1595   guestfs_h *g;
1596   PyObject *py_r;
1597   int r;
1598
1599   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state",
1600                          &py_g))
1601     return NULL;
1602   g = get_handle (py_g);
1603
1604   r = guestfs_get_state (g);
1605   if (r == -1) {
1606     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1607     return NULL;
1608   }
1609
1610   py_r = PyInt_FromLong ((long) r);
1611   return py_r;
1612 }
1613
1614 static PyObject *
1615 py_guestfs_set_busy (PyObject *self, PyObject *args)
1616 {
1617   PyObject *py_g;
1618   guestfs_h *g;
1619   PyObject *py_r;
1620   int r;
1621
1622   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy",
1623                          &py_g))
1624     return NULL;
1625   g = get_handle (py_g);
1626
1627   r = guestfs_set_busy (g);
1628   if (r == -1) {
1629     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1630     return NULL;
1631   }
1632
1633   Py_INCREF (Py_None);
1634   py_r = Py_None;
1635   return py_r;
1636 }
1637
1638 static PyObject *
1639 py_guestfs_set_ready (PyObject *self, PyObject *args)
1640 {
1641   PyObject *py_g;
1642   guestfs_h *g;
1643   PyObject *py_r;
1644   int r;
1645
1646   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_ready",
1647                          &py_g))
1648     return NULL;
1649   g = get_handle (py_g);
1650
1651   r = guestfs_set_ready (g);
1652   if (r == -1) {
1653     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1654     return NULL;
1655   }
1656
1657   Py_INCREF (Py_None);
1658   py_r = Py_None;
1659   return py_r;
1660 }
1661
1662 static PyObject *
1663 py_guestfs_end_busy (PyObject *self, PyObject *args)
1664 {
1665   PyObject *py_g;
1666   guestfs_h *g;
1667   PyObject *py_r;
1668   int r;
1669
1670   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_end_busy",
1671                          &py_g))
1672     return NULL;
1673   g = get_handle (py_g);
1674
1675   r = guestfs_end_busy (g);
1676   if (r == -1) {
1677     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1678     return NULL;
1679   }
1680
1681   Py_INCREF (Py_None);
1682   py_r = Py_None;
1683   return py_r;
1684 }
1685
1686 static PyObject *
1687 py_guestfs_set_memsize (PyObject *self, PyObject *args)
1688 {
1689   PyObject *py_g;
1690   guestfs_h *g;
1691   PyObject *py_r;
1692   int r;
1693   int memsize;
1694
1695   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_memsize",
1696                          &py_g, &memsize))
1697     return NULL;
1698   g = get_handle (py_g);
1699
1700   r = guestfs_set_memsize (g, memsize);
1701   if (r == -1) {
1702     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1703     return NULL;
1704   }
1705
1706   Py_INCREF (Py_None);
1707   py_r = Py_None;
1708   return py_r;
1709 }
1710
1711 static PyObject *
1712 py_guestfs_get_memsize (PyObject *self, PyObject *args)
1713 {
1714   PyObject *py_g;
1715   guestfs_h *g;
1716   PyObject *py_r;
1717   int r;
1718
1719   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_memsize",
1720                          &py_g))
1721     return NULL;
1722   g = get_handle (py_g);
1723
1724   r = guestfs_get_memsize (g);
1725   if (r == -1) {
1726     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1727     return NULL;
1728   }
1729
1730   py_r = PyInt_FromLong ((long) r);
1731   return py_r;
1732 }
1733
1734 static PyObject *
1735 py_guestfs_mount (PyObject *self, PyObject *args)
1736 {
1737   PyObject *py_g;
1738   guestfs_h *g;
1739   PyObject *py_r;
1740   int r;
1741   const char *device;
1742   const char *mountpoint;
1743
1744   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
1745                          &py_g, &device, &mountpoint))
1746     return NULL;
1747   g = get_handle (py_g);
1748
1749   r = guestfs_mount (g, device, mountpoint);
1750   if (r == -1) {
1751     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1752     return NULL;
1753   }
1754
1755   Py_INCREF (Py_None);
1756   py_r = Py_None;
1757   return py_r;
1758 }
1759
1760 static PyObject *
1761 py_guestfs_sync (PyObject *self, PyObject *args)
1762 {
1763   PyObject *py_g;
1764   guestfs_h *g;
1765   PyObject *py_r;
1766   int r;
1767
1768   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
1769                          &py_g))
1770     return NULL;
1771   g = get_handle (py_g);
1772
1773   r = guestfs_sync (g);
1774   if (r == -1) {
1775     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1776     return NULL;
1777   }
1778
1779   Py_INCREF (Py_None);
1780   py_r = Py_None;
1781   return py_r;
1782 }
1783
1784 static PyObject *
1785 py_guestfs_touch (PyObject *self, PyObject *args)
1786 {
1787   PyObject *py_g;
1788   guestfs_h *g;
1789   PyObject *py_r;
1790   int r;
1791   const char *path;
1792
1793   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
1794                          &py_g, &path))
1795     return NULL;
1796   g = get_handle (py_g);
1797
1798   r = guestfs_touch (g, path);
1799   if (r == -1) {
1800     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1801     return NULL;
1802   }
1803
1804   Py_INCREF (Py_None);
1805   py_r = Py_None;
1806   return py_r;
1807 }
1808
1809 static PyObject *
1810 py_guestfs_cat (PyObject *self, PyObject *args)
1811 {
1812   PyObject *py_g;
1813   guestfs_h *g;
1814   PyObject *py_r;
1815   char *r;
1816   const char *path;
1817
1818   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
1819                          &py_g, &path))
1820     return NULL;
1821   g = get_handle (py_g);
1822
1823   r = guestfs_cat (g, path);
1824   if (r == NULL) {
1825     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1826     return NULL;
1827   }
1828
1829   py_r = PyString_FromString (r);
1830   free (r);
1831   return py_r;
1832 }
1833
1834 static PyObject *
1835 py_guestfs_ll (PyObject *self, PyObject *args)
1836 {
1837   PyObject *py_g;
1838   guestfs_h *g;
1839   PyObject *py_r;
1840   char *r;
1841   const char *directory;
1842
1843   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
1844                          &py_g, &directory))
1845     return NULL;
1846   g = get_handle (py_g);
1847
1848   r = guestfs_ll (g, directory);
1849   if (r == NULL) {
1850     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1851     return NULL;
1852   }
1853
1854   py_r = PyString_FromString (r);
1855   free (r);
1856   return py_r;
1857 }
1858
1859 static PyObject *
1860 py_guestfs_ls (PyObject *self, PyObject *args)
1861 {
1862   PyObject *py_g;
1863   guestfs_h *g;
1864   PyObject *py_r;
1865   char **r;
1866   const char *directory;
1867
1868   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
1869                          &py_g, &directory))
1870     return NULL;
1871   g = get_handle (py_g);
1872
1873   r = guestfs_ls (g, directory);
1874   if (r == NULL) {
1875     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1876     return NULL;
1877   }
1878
1879   py_r = put_string_list (r);
1880   free_strings (r);
1881   return py_r;
1882 }
1883
1884 static PyObject *
1885 py_guestfs_list_devices (PyObject *self, PyObject *args)
1886 {
1887   PyObject *py_g;
1888   guestfs_h *g;
1889   PyObject *py_r;
1890   char **r;
1891
1892   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
1893                          &py_g))
1894     return NULL;
1895   g = get_handle (py_g);
1896
1897   r = guestfs_list_devices (g);
1898   if (r == NULL) {
1899     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1900     return NULL;
1901   }
1902
1903   py_r = put_string_list (r);
1904   free_strings (r);
1905   return py_r;
1906 }
1907
1908 static PyObject *
1909 py_guestfs_list_partitions (PyObject *self, PyObject *args)
1910 {
1911   PyObject *py_g;
1912   guestfs_h *g;
1913   PyObject *py_r;
1914   char **r;
1915
1916   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
1917                          &py_g))
1918     return NULL;
1919   g = get_handle (py_g);
1920
1921   r = guestfs_list_partitions (g);
1922   if (r == NULL) {
1923     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1924     return NULL;
1925   }
1926
1927   py_r = put_string_list (r);
1928   free_strings (r);
1929   return py_r;
1930 }
1931
1932 static PyObject *
1933 py_guestfs_pvs (PyObject *self, PyObject *args)
1934 {
1935   PyObject *py_g;
1936   guestfs_h *g;
1937   PyObject *py_r;
1938   char **r;
1939
1940   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
1941                          &py_g))
1942     return NULL;
1943   g = get_handle (py_g);
1944
1945   r = guestfs_pvs (g);
1946   if (r == NULL) {
1947     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1948     return NULL;
1949   }
1950
1951   py_r = put_string_list (r);
1952   free_strings (r);
1953   return py_r;
1954 }
1955
1956 static PyObject *
1957 py_guestfs_vgs (PyObject *self, PyObject *args)
1958 {
1959   PyObject *py_g;
1960   guestfs_h *g;
1961   PyObject *py_r;
1962   char **r;
1963
1964   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
1965                          &py_g))
1966     return NULL;
1967   g = get_handle (py_g);
1968
1969   r = guestfs_vgs (g);
1970   if (r == NULL) {
1971     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1972     return NULL;
1973   }
1974
1975   py_r = put_string_list (r);
1976   free_strings (r);
1977   return py_r;
1978 }
1979
1980 static PyObject *
1981 py_guestfs_lvs (PyObject *self, PyObject *args)
1982 {
1983   PyObject *py_g;
1984   guestfs_h *g;
1985   PyObject *py_r;
1986   char **r;
1987
1988   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
1989                          &py_g))
1990     return NULL;
1991   g = get_handle (py_g);
1992
1993   r = guestfs_lvs (g);
1994   if (r == NULL) {
1995     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1996     return NULL;
1997   }
1998
1999   py_r = put_string_list (r);
2000   free_strings (r);
2001   return py_r;
2002 }
2003
2004 static PyObject *
2005 py_guestfs_pvs_full (PyObject *self, PyObject *args)
2006 {
2007   PyObject *py_g;
2008   guestfs_h *g;
2009   PyObject *py_r;
2010   struct guestfs_lvm_pv_list *r;
2011
2012   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
2013                          &py_g))
2014     return NULL;
2015   g = get_handle (py_g);
2016
2017   r = guestfs_pvs_full (g);
2018   if (r == NULL) {
2019     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2020     return NULL;
2021   }
2022
2023   py_r = put_lvm_pv_list (r);
2024   guestfs_free_lvm_pv_list (r);
2025   return py_r;
2026 }
2027
2028 static PyObject *
2029 py_guestfs_vgs_full (PyObject *self, PyObject *args)
2030 {
2031   PyObject *py_g;
2032   guestfs_h *g;
2033   PyObject *py_r;
2034   struct guestfs_lvm_vg_list *r;
2035
2036   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
2037                          &py_g))
2038     return NULL;
2039   g = get_handle (py_g);
2040
2041   r = guestfs_vgs_full (g);
2042   if (r == NULL) {
2043     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2044     return NULL;
2045   }
2046
2047   py_r = put_lvm_vg_list (r);
2048   guestfs_free_lvm_vg_list (r);
2049   return py_r;
2050 }
2051
2052 static PyObject *
2053 py_guestfs_lvs_full (PyObject *self, PyObject *args)
2054 {
2055   PyObject *py_g;
2056   guestfs_h *g;
2057   PyObject *py_r;
2058   struct guestfs_lvm_lv_list *r;
2059
2060   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
2061                          &py_g))
2062     return NULL;
2063   g = get_handle (py_g);
2064
2065   r = guestfs_lvs_full (g);
2066   if (r == NULL) {
2067     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2068     return NULL;
2069   }
2070
2071   py_r = put_lvm_lv_list (r);
2072   guestfs_free_lvm_lv_list (r);
2073   return py_r;
2074 }
2075
2076 static PyObject *
2077 py_guestfs_read_lines (PyObject *self, PyObject *args)
2078 {
2079   PyObject *py_g;
2080   guestfs_h *g;
2081   PyObject *py_r;
2082   char **r;
2083   const char *path;
2084
2085   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
2086                          &py_g, &path))
2087     return NULL;
2088   g = get_handle (py_g);
2089
2090   r = guestfs_read_lines (g, path);
2091   if (r == NULL) {
2092     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2093     return NULL;
2094   }
2095
2096   py_r = put_string_list (r);
2097   free_strings (r);
2098   return py_r;
2099 }
2100
2101 static PyObject *
2102 py_guestfs_aug_init (PyObject *self, PyObject *args)
2103 {
2104   PyObject *py_g;
2105   guestfs_h *g;
2106   PyObject *py_r;
2107   int r;
2108   const char *root;
2109   int flags;
2110
2111   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
2112                          &py_g, &root, &flags))
2113     return NULL;
2114   g = get_handle (py_g);
2115
2116   r = guestfs_aug_init (g, root, flags);
2117   if (r == -1) {
2118     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2119     return NULL;
2120   }
2121
2122   Py_INCREF (Py_None);
2123   py_r = Py_None;
2124   return py_r;
2125 }
2126
2127 static PyObject *
2128 py_guestfs_aug_close (PyObject *self, PyObject *args)
2129 {
2130   PyObject *py_g;
2131   guestfs_h *g;
2132   PyObject *py_r;
2133   int r;
2134
2135   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
2136                          &py_g))
2137     return NULL;
2138   g = get_handle (py_g);
2139
2140   r = guestfs_aug_close (g);
2141   if (r == -1) {
2142     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2143     return NULL;
2144   }
2145
2146   Py_INCREF (Py_None);
2147   py_r = Py_None;
2148   return py_r;
2149 }
2150
2151 static PyObject *
2152 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
2153 {
2154   PyObject *py_g;
2155   guestfs_h *g;
2156   PyObject *py_r;
2157   int r;
2158   const char *name;
2159   const char *expr;
2160
2161   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
2162                          &py_g, &name, &expr))
2163     return NULL;
2164   g = get_handle (py_g);
2165
2166   r = guestfs_aug_defvar (g, name, expr);
2167   if (r == -1) {
2168     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2169     return NULL;
2170   }
2171
2172   py_r = PyInt_FromLong ((long) r);
2173   return py_r;
2174 }
2175
2176 static PyObject *
2177 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
2178 {
2179   PyObject *py_g;
2180   guestfs_h *g;
2181   PyObject *py_r;
2182   struct guestfs_int_bool *r;
2183   const char *name;
2184   const char *expr;
2185   const char *val;
2186
2187   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
2188                          &py_g, &name, &expr, &val))
2189     return NULL;
2190   g = get_handle (py_g);
2191
2192   r = guestfs_aug_defnode (g, name, expr, val);
2193   if (r == NULL) {
2194     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2195     return NULL;
2196   }
2197
2198   py_r = PyTuple_New (2);
2199   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
2200   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
2201   guestfs_free_int_bool (r);
2202   return py_r;
2203 }
2204
2205 static PyObject *
2206 py_guestfs_aug_get (PyObject *self, PyObject *args)
2207 {
2208   PyObject *py_g;
2209   guestfs_h *g;
2210   PyObject *py_r;
2211   char *r;
2212   const char *path;
2213
2214   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
2215                          &py_g, &path))
2216     return NULL;
2217   g = get_handle (py_g);
2218
2219   r = guestfs_aug_get (g, path);
2220   if (r == NULL) {
2221     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2222     return NULL;
2223   }
2224
2225   py_r = PyString_FromString (r);
2226   free (r);
2227   return py_r;
2228 }
2229
2230 static PyObject *
2231 py_guestfs_aug_set (PyObject *self, PyObject *args)
2232 {
2233   PyObject *py_g;
2234   guestfs_h *g;
2235   PyObject *py_r;
2236   int r;
2237   const char *path;
2238   const char *val;
2239
2240   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
2241                          &py_g, &path, &val))
2242     return NULL;
2243   g = get_handle (py_g);
2244
2245   r = guestfs_aug_set (g, path, val);
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_insert (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   const char *label;
2265   int before;
2266
2267   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
2268                          &py_g, &path, &label, &before))
2269     return NULL;
2270   g = get_handle (py_g);
2271
2272   r = guestfs_aug_insert (g, path, label, before);
2273   if (r == -1) {
2274     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2275     return NULL;
2276   }
2277
2278   Py_INCREF (Py_None);
2279   py_r = Py_None;
2280   return py_r;
2281 }
2282
2283 static PyObject *
2284 py_guestfs_aug_rm (PyObject *self, PyObject *args)
2285 {
2286   PyObject *py_g;
2287   guestfs_h *g;
2288   PyObject *py_r;
2289   int r;
2290   const char *path;
2291
2292   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
2293                          &py_g, &path))
2294     return NULL;
2295   g = get_handle (py_g);
2296
2297   r = guestfs_aug_rm (g, path);
2298   if (r == -1) {
2299     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2300     return NULL;
2301   }
2302
2303   py_r = PyInt_FromLong ((long) r);
2304   return py_r;
2305 }
2306
2307 static PyObject *
2308 py_guestfs_aug_mv (PyObject *self, PyObject *args)
2309 {
2310   PyObject *py_g;
2311   guestfs_h *g;
2312   PyObject *py_r;
2313   int r;
2314   const char *src;
2315   const char *dest;
2316
2317   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
2318                          &py_g, &src, &dest))
2319     return NULL;
2320   g = get_handle (py_g);
2321
2322   r = guestfs_aug_mv (g, src, dest);
2323   if (r == -1) {
2324     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2325     return NULL;
2326   }
2327
2328   Py_INCREF (Py_None);
2329   py_r = Py_None;
2330   return py_r;
2331 }
2332
2333 static PyObject *
2334 py_guestfs_aug_match (PyObject *self, PyObject *args)
2335 {
2336   PyObject *py_g;
2337   guestfs_h *g;
2338   PyObject *py_r;
2339   char **r;
2340   const char *path;
2341
2342   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
2343                          &py_g, &path))
2344     return NULL;
2345   g = get_handle (py_g);
2346
2347   r = guestfs_aug_match (g, path);
2348   if (r == NULL) {
2349     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2350     return NULL;
2351   }
2352
2353   py_r = put_string_list (r);
2354   free_strings (r);
2355   return py_r;
2356 }
2357
2358 static PyObject *
2359 py_guestfs_aug_save (PyObject *self, PyObject *args)
2360 {
2361   PyObject *py_g;
2362   guestfs_h *g;
2363   PyObject *py_r;
2364   int r;
2365
2366   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
2367                          &py_g))
2368     return NULL;
2369   g = get_handle (py_g);
2370
2371   r = guestfs_aug_save (g);
2372   if (r == -1) {
2373     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2374     return NULL;
2375   }
2376
2377   Py_INCREF (Py_None);
2378   py_r = Py_None;
2379   return py_r;
2380 }
2381
2382 static PyObject *
2383 py_guestfs_aug_load (PyObject *self, PyObject *args)
2384 {
2385   PyObject *py_g;
2386   guestfs_h *g;
2387   PyObject *py_r;
2388   int r;
2389
2390   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
2391                          &py_g))
2392     return NULL;
2393   g = get_handle (py_g);
2394
2395   r = guestfs_aug_load (g);
2396   if (r == -1) {
2397     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2398     return NULL;
2399   }
2400
2401   Py_INCREF (Py_None);
2402   py_r = Py_None;
2403   return py_r;
2404 }
2405
2406 static PyObject *
2407 py_guestfs_aug_ls (PyObject *self, PyObject *args)
2408 {
2409   PyObject *py_g;
2410   guestfs_h *g;
2411   PyObject *py_r;
2412   char **r;
2413   const char *path;
2414
2415   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
2416                          &py_g, &path))
2417     return NULL;
2418   g = get_handle (py_g);
2419
2420   r = guestfs_aug_ls (g, path);
2421   if (r == NULL) {
2422     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2423     return NULL;
2424   }
2425
2426   py_r = put_string_list (r);
2427   free_strings (r);
2428   return py_r;
2429 }
2430
2431 static PyObject *
2432 py_guestfs_rm (PyObject *self, PyObject *args)
2433 {
2434   PyObject *py_g;
2435   guestfs_h *g;
2436   PyObject *py_r;
2437   int r;
2438   const char *path;
2439
2440   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
2441                          &py_g, &path))
2442     return NULL;
2443   g = get_handle (py_g);
2444
2445   r = guestfs_rm (g, path);
2446   if (r == -1) {
2447     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2448     return NULL;
2449   }
2450
2451   Py_INCREF (Py_None);
2452   py_r = Py_None;
2453   return py_r;
2454 }
2455
2456 static PyObject *
2457 py_guestfs_rmdir (PyObject *self, PyObject *args)
2458 {
2459   PyObject *py_g;
2460   guestfs_h *g;
2461   PyObject *py_r;
2462   int r;
2463   const char *path;
2464
2465   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
2466                          &py_g, &path))
2467     return NULL;
2468   g = get_handle (py_g);
2469
2470   r = guestfs_rmdir (g, path);
2471   if (r == -1) {
2472     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2473     return NULL;
2474   }
2475
2476   Py_INCREF (Py_None);
2477   py_r = Py_None;
2478   return py_r;
2479 }
2480
2481 static PyObject *
2482 py_guestfs_rm_rf (PyObject *self, PyObject *args)
2483 {
2484   PyObject *py_g;
2485   guestfs_h *g;
2486   PyObject *py_r;
2487   int r;
2488   const char *path;
2489
2490   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
2491                          &py_g, &path))
2492     return NULL;
2493   g = get_handle (py_g);
2494
2495   r = guestfs_rm_rf (g, path);
2496   if (r == -1) {
2497     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2498     return NULL;
2499   }
2500
2501   Py_INCREF (Py_None);
2502   py_r = Py_None;
2503   return py_r;
2504 }
2505
2506 static PyObject *
2507 py_guestfs_mkdir (PyObject *self, PyObject *args)
2508 {
2509   PyObject *py_g;
2510   guestfs_h *g;
2511   PyObject *py_r;
2512   int r;
2513   const char *path;
2514
2515   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
2516                          &py_g, &path))
2517     return NULL;
2518   g = get_handle (py_g);
2519
2520   r = guestfs_mkdir (g, path);
2521   if (r == -1) {
2522     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2523     return NULL;
2524   }
2525
2526   Py_INCREF (Py_None);
2527   py_r = Py_None;
2528   return py_r;
2529 }
2530
2531 static PyObject *
2532 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
2533 {
2534   PyObject *py_g;
2535   guestfs_h *g;
2536   PyObject *py_r;
2537   int r;
2538   const char *path;
2539
2540   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
2541                          &py_g, &path))
2542     return NULL;
2543   g = get_handle (py_g);
2544
2545   r = guestfs_mkdir_p (g, path);
2546   if (r == -1) {
2547     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2548     return NULL;
2549   }
2550
2551   Py_INCREF (Py_None);
2552   py_r = Py_None;
2553   return py_r;
2554 }
2555
2556 static PyObject *
2557 py_guestfs_chmod (PyObject *self, PyObject *args)
2558 {
2559   PyObject *py_g;
2560   guestfs_h *g;
2561   PyObject *py_r;
2562   int r;
2563   int mode;
2564   const char *path;
2565
2566   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
2567                          &py_g, &mode, &path))
2568     return NULL;
2569   g = get_handle (py_g);
2570
2571   r = guestfs_chmod (g, mode, 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_chown (PyObject *self, PyObject *args)
2584 {
2585   PyObject *py_g;
2586   guestfs_h *g;
2587   PyObject *py_r;
2588   int r;
2589   int owner;
2590   int group;
2591   const char *path;
2592
2593   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
2594                          &py_g, &owner, &group, &path))
2595     return NULL;
2596   g = get_handle (py_g);
2597
2598   r = guestfs_chown (g, owner, group, path);
2599   if (r == -1) {
2600     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2601     return NULL;
2602   }
2603
2604   Py_INCREF (Py_None);
2605   py_r = Py_None;
2606   return py_r;
2607 }
2608
2609 static PyObject *
2610 py_guestfs_exists (PyObject *self, PyObject *args)
2611 {
2612   PyObject *py_g;
2613   guestfs_h *g;
2614   PyObject *py_r;
2615   int r;
2616   const char *path;
2617
2618   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
2619                          &py_g, &path))
2620     return NULL;
2621   g = get_handle (py_g);
2622
2623   r = guestfs_exists (g, path);
2624   if (r == -1) {
2625     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2626     return NULL;
2627   }
2628
2629   py_r = PyInt_FromLong ((long) r);
2630   return py_r;
2631 }
2632
2633 static PyObject *
2634 py_guestfs_is_file (PyObject *self, PyObject *args)
2635 {
2636   PyObject *py_g;
2637   guestfs_h *g;
2638   PyObject *py_r;
2639   int r;
2640   const char *path;
2641
2642   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
2643                          &py_g, &path))
2644     return NULL;
2645   g = get_handle (py_g);
2646
2647   r = guestfs_is_file (g, path);
2648   if (r == -1) {
2649     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2650     return NULL;
2651   }
2652
2653   py_r = PyInt_FromLong ((long) r);
2654   return py_r;
2655 }
2656
2657 static PyObject *
2658 py_guestfs_is_dir (PyObject *self, PyObject *args)
2659 {
2660   PyObject *py_g;
2661   guestfs_h *g;
2662   PyObject *py_r;
2663   int r;
2664   const char *path;
2665
2666   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
2667                          &py_g, &path))
2668     return NULL;
2669   g = get_handle (py_g);
2670
2671   r = guestfs_is_dir (g, path);
2672   if (r == -1) {
2673     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2674     return NULL;
2675   }
2676
2677   py_r = PyInt_FromLong ((long) r);
2678   return py_r;
2679 }
2680
2681 static PyObject *
2682 py_guestfs_pvcreate (PyObject *self, PyObject *args)
2683 {
2684   PyObject *py_g;
2685   guestfs_h *g;
2686   PyObject *py_r;
2687   int r;
2688   const char *device;
2689
2690   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
2691                          &py_g, &device))
2692     return NULL;
2693   g = get_handle (py_g);
2694
2695   r = guestfs_pvcreate (g, device);
2696   if (r == -1) {
2697     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2698     return NULL;
2699   }
2700
2701   Py_INCREF (Py_None);
2702   py_r = Py_None;
2703   return py_r;
2704 }
2705
2706 static PyObject *
2707 py_guestfs_vgcreate (PyObject *self, PyObject *args)
2708 {
2709   PyObject *py_g;
2710   guestfs_h *g;
2711   PyObject *py_r;
2712   int r;
2713   const char *volgroup;
2714   PyObject *py_physvols;
2715   const char **physvols;
2716
2717   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
2718                          &py_g, &volgroup, &py_physvols))
2719     return NULL;
2720   g = get_handle (py_g);
2721   physvols = get_string_list (py_physvols);
2722   if (!physvols) return NULL;
2723
2724   r = guestfs_vgcreate (g, volgroup, physvols);
2725   free (physvols);
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_lvcreate (PyObject *self, PyObject *args)
2738 {
2739   PyObject *py_g;
2740   guestfs_h *g;
2741   PyObject *py_r;
2742   int r;
2743   const char *logvol;
2744   const char *volgroup;
2745   int mbytes;
2746
2747   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
2748                          &py_g, &logvol, &volgroup, &mbytes))
2749     return NULL;
2750   g = get_handle (py_g);
2751
2752   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2753   if (r == -1) {
2754     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2755     return NULL;
2756   }
2757
2758   Py_INCREF (Py_None);
2759   py_r = Py_None;
2760   return py_r;
2761 }
2762
2763 static PyObject *
2764 py_guestfs_mkfs (PyObject *self, PyObject *args)
2765 {
2766   PyObject *py_g;
2767   guestfs_h *g;
2768   PyObject *py_r;
2769   int r;
2770   const char *fstype;
2771   const char *device;
2772
2773   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
2774                          &py_g, &fstype, &device))
2775     return NULL;
2776   g = get_handle (py_g);
2777
2778   r = guestfs_mkfs (g, fstype, device);
2779   if (r == -1) {
2780     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2781     return NULL;
2782   }
2783
2784   Py_INCREF (Py_None);
2785   py_r = Py_None;
2786   return py_r;
2787 }
2788
2789 static PyObject *
2790 py_guestfs_sfdisk (PyObject *self, PyObject *args)
2791 {
2792   PyObject *py_g;
2793   guestfs_h *g;
2794   PyObject *py_r;
2795   int r;
2796   const char *device;
2797   int cyls;
2798   int heads;
2799   int sectors;
2800   PyObject *py_lines;
2801   const char **lines;
2802
2803   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
2804                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
2805     return NULL;
2806   g = get_handle (py_g);
2807   lines = get_string_list (py_lines);
2808   if (!lines) return NULL;
2809
2810   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2811   free (lines);
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_write_file (PyObject *self, PyObject *args)
2824 {
2825   PyObject *py_g;
2826   guestfs_h *g;
2827   PyObject *py_r;
2828   int r;
2829   const char *path;
2830   const char *content;
2831   int size;
2832
2833   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
2834                          &py_g, &path, &content, &size))
2835     return NULL;
2836   g = get_handle (py_g);
2837
2838   r = guestfs_write_file (g, path, content, size);
2839   if (r == -1) {
2840     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2841     return NULL;
2842   }
2843
2844   Py_INCREF (Py_None);
2845   py_r = Py_None;
2846   return py_r;
2847 }
2848
2849 static PyObject *
2850 py_guestfs_umount (PyObject *self, PyObject *args)
2851 {
2852   PyObject *py_g;
2853   guestfs_h *g;
2854   PyObject *py_r;
2855   int r;
2856   const char *pathordevice;
2857
2858   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
2859                          &py_g, &pathordevice))
2860     return NULL;
2861   g = get_handle (py_g);
2862
2863   r = guestfs_umount (g, pathordevice);
2864   if (r == -1) {
2865     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2866     return NULL;
2867   }
2868
2869   Py_INCREF (Py_None);
2870   py_r = Py_None;
2871   return py_r;
2872 }
2873
2874 static PyObject *
2875 py_guestfs_mounts (PyObject *self, PyObject *args)
2876 {
2877   PyObject *py_g;
2878   guestfs_h *g;
2879   PyObject *py_r;
2880   char **r;
2881
2882   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
2883                          &py_g))
2884     return NULL;
2885   g = get_handle (py_g);
2886
2887   r = guestfs_mounts (g);
2888   if (r == NULL) {
2889     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2890     return NULL;
2891   }
2892
2893   py_r = put_string_list (r);
2894   free_strings (r);
2895   return py_r;
2896 }
2897
2898 static PyObject *
2899 py_guestfs_umount_all (PyObject *self, PyObject *args)
2900 {
2901   PyObject *py_g;
2902   guestfs_h *g;
2903   PyObject *py_r;
2904   int r;
2905
2906   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
2907                          &py_g))
2908     return NULL;
2909   g = get_handle (py_g);
2910
2911   r = guestfs_umount_all (g);
2912   if (r == -1) {
2913     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2914     return NULL;
2915   }
2916
2917   Py_INCREF (Py_None);
2918   py_r = Py_None;
2919   return py_r;
2920 }
2921
2922 static PyObject *
2923 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
2924 {
2925   PyObject *py_g;
2926   guestfs_h *g;
2927   PyObject *py_r;
2928   int r;
2929
2930   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
2931                          &py_g))
2932     return NULL;
2933   g = get_handle (py_g);
2934
2935   r = guestfs_lvm_remove_all (g);
2936   if (r == -1) {
2937     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2938     return NULL;
2939   }
2940
2941   Py_INCREF (Py_None);
2942   py_r = Py_None;
2943   return py_r;
2944 }
2945
2946 static PyObject *
2947 py_guestfs_file (PyObject *self, PyObject *args)
2948 {
2949   PyObject *py_g;
2950   guestfs_h *g;
2951   PyObject *py_r;
2952   char *r;
2953   const char *path;
2954
2955   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
2956                          &py_g, &path))
2957     return NULL;
2958   g = get_handle (py_g);
2959
2960   r = guestfs_file (g, path);
2961   if (r == NULL) {
2962     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2963     return NULL;
2964   }
2965
2966   py_r = PyString_FromString (r);
2967   free (r);
2968   return py_r;
2969 }
2970
2971 static PyObject *
2972 py_guestfs_command (PyObject *self, PyObject *args)
2973 {
2974   PyObject *py_g;
2975   guestfs_h *g;
2976   PyObject *py_r;
2977   char *r;
2978   PyObject *py_arguments;
2979   const char **arguments;
2980
2981   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
2982                          &py_g, &py_arguments))
2983     return NULL;
2984   g = get_handle (py_g);
2985   arguments = get_string_list (py_arguments);
2986   if (!arguments) return NULL;
2987
2988   r = guestfs_command (g, arguments);
2989   free (arguments);
2990   if (r == NULL) {
2991     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2992     return NULL;
2993   }
2994
2995   py_r = PyString_FromString (r);
2996   free (r);
2997   return py_r;
2998 }
2999
3000 static PyObject *
3001 py_guestfs_command_lines (PyObject *self, PyObject *args)
3002 {
3003   PyObject *py_g;
3004   guestfs_h *g;
3005   PyObject *py_r;
3006   char **r;
3007   PyObject *py_arguments;
3008   const char **arguments;
3009
3010   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
3011                          &py_g, &py_arguments))
3012     return NULL;
3013   g = get_handle (py_g);
3014   arguments = get_string_list (py_arguments);
3015   if (!arguments) return NULL;
3016
3017   r = guestfs_command_lines (g, arguments);
3018   free (arguments);
3019   if (r == NULL) {
3020     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3021     return NULL;
3022   }
3023
3024   py_r = put_string_list (r);
3025   free_strings (r);
3026   return py_r;
3027 }
3028
3029 static PyObject *
3030 py_guestfs_stat (PyObject *self, PyObject *args)
3031 {
3032   PyObject *py_g;
3033   guestfs_h *g;
3034   PyObject *py_r;
3035   struct guestfs_stat *r;
3036   const char *path;
3037
3038   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
3039                          &py_g, &path))
3040     return NULL;
3041   g = get_handle (py_g);
3042
3043   r = guestfs_stat (g, path);
3044   if (r == NULL) {
3045     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3046     return NULL;
3047   }
3048
3049   py_r = put_stat (r);
3050   free (r);
3051   return py_r;
3052 }
3053
3054 static PyObject *
3055 py_guestfs_lstat (PyObject *self, PyObject *args)
3056 {
3057   PyObject *py_g;
3058   guestfs_h *g;
3059   PyObject *py_r;
3060   struct guestfs_stat *r;
3061   const char *path;
3062
3063   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
3064                          &py_g, &path))
3065     return NULL;
3066   g = get_handle (py_g);
3067
3068   r = guestfs_lstat (g, path);
3069   if (r == NULL) {
3070     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3071     return NULL;
3072   }
3073
3074   py_r = put_stat (r);
3075   free (r);
3076   return py_r;
3077 }
3078
3079 static PyObject *
3080 py_guestfs_statvfs (PyObject *self, PyObject *args)
3081 {
3082   PyObject *py_g;
3083   guestfs_h *g;
3084   PyObject *py_r;
3085   struct guestfs_statvfs *r;
3086   const char *path;
3087
3088   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
3089                          &py_g, &path))
3090     return NULL;
3091   g = get_handle (py_g);
3092
3093   r = guestfs_statvfs (g, path);
3094   if (r == NULL) {
3095     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3096     return NULL;
3097   }
3098
3099   py_r = put_statvfs (r);
3100   free (r);
3101   return py_r;
3102 }
3103
3104 static PyObject *
3105 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
3106 {
3107   PyObject *py_g;
3108   guestfs_h *g;
3109   PyObject *py_r;
3110   char **r;
3111   const char *device;
3112
3113   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
3114                          &py_g, &device))
3115     return NULL;
3116   g = get_handle (py_g);
3117
3118   r = guestfs_tune2fs_l (g, device);
3119   if (r == NULL) {
3120     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3121     return NULL;
3122   }
3123
3124   py_r = put_table (r);
3125   free_strings (r);
3126   return py_r;
3127 }
3128
3129 static PyObject *
3130 py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
3131 {
3132   PyObject *py_g;
3133   guestfs_h *g;
3134   PyObject *py_r;
3135   int r;
3136   const char *device;
3137
3138   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
3139                          &py_g, &device))
3140     return NULL;
3141   g = get_handle (py_g);
3142
3143   r = guestfs_blockdev_setro (g, device);
3144   if (r == -1) {
3145     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3146     return NULL;
3147   }
3148
3149   Py_INCREF (Py_None);
3150   py_r = Py_None;
3151   return py_r;
3152 }
3153
3154 static PyObject *
3155 py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
3156 {
3157   PyObject *py_g;
3158   guestfs_h *g;
3159   PyObject *py_r;
3160   int r;
3161   const char *device;
3162
3163   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
3164                          &py_g, &device))
3165     return NULL;
3166   g = get_handle (py_g);
3167
3168   r = guestfs_blockdev_setrw (g, device);
3169   if (r == -1) {
3170     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3171     return NULL;
3172   }
3173
3174   Py_INCREF (Py_None);
3175   py_r = Py_None;
3176   return py_r;
3177 }
3178
3179 static PyObject *
3180 py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
3181 {
3182   PyObject *py_g;
3183   guestfs_h *g;
3184   PyObject *py_r;
3185   int r;
3186   const char *device;
3187
3188   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
3189                          &py_g, &device))
3190     return NULL;
3191   g = get_handle (py_g);
3192
3193   r = guestfs_blockdev_getro (g, device);
3194   if (r == -1) {
3195     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3196     return NULL;
3197   }
3198
3199   py_r = PyInt_FromLong ((long) r);
3200   return py_r;
3201 }
3202
3203 static PyObject *
3204 py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
3205 {
3206   PyObject *py_g;
3207   guestfs_h *g;
3208   PyObject *py_r;
3209   int r;
3210   const char *device;
3211
3212   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
3213                          &py_g, &device))
3214     return NULL;
3215   g = get_handle (py_g);
3216
3217   r = guestfs_blockdev_getss (g, device);
3218   if (r == -1) {
3219     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3220     return NULL;
3221   }
3222
3223   py_r = PyInt_FromLong ((long) r);
3224   return py_r;
3225 }
3226
3227 static PyObject *
3228 py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
3229 {
3230   PyObject *py_g;
3231   guestfs_h *g;
3232   PyObject *py_r;
3233   int r;
3234   const char *device;
3235
3236   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
3237                          &py_g, &device))
3238     return NULL;
3239   g = get_handle (py_g);
3240
3241   r = guestfs_blockdev_getbsz (g, device);
3242   if (r == -1) {
3243     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3244     return NULL;
3245   }
3246
3247   py_r = PyInt_FromLong ((long) r);
3248   return py_r;
3249 }
3250
3251 static PyObject *
3252 py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
3253 {
3254   PyObject *py_g;
3255   guestfs_h *g;
3256   PyObject *py_r;
3257   int r;
3258   const char *device;
3259   int blocksize;
3260
3261   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
3262                          &py_g, &device, &blocksize))
3263     return NULL;
3264   g = get_handle (py_g);
3265
3266   r = guestfs_blockdev_setbsz (g, device, blocksize);
3267   if (r == -1) {
3268     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3269     return NULL;
3270   }
3271
3272   Py_INCREF (Py_None);
3273   py_r = Py_None;
3274   return py_r;
3275 }
3276
3277 static PyObject *
3278 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
3279 {
3280   PyObject *py_g;
3281   guestfs_h *g;
3282   PyObject *py_r;
3283   int64_t r;
3284   const char *device;
3285
3286   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
3287                          &py_g, &device))
3288     return NULL;
3289   g = get_handle (py_g);
3290
3291   r = guestfs_blockdev_getsz (g, device);
3292   if (r == -1) {
3293     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3294     return NULL;
3295   }
3296
3297   py_r = PyLong_FromLongLong (r);
3298   return py_r;
3299 }
3300
3301 static PyObject *
3302 py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
3303 {
3304   PyObject *py_g;
3305   guestfs_h *g;
3306   PyObject *py_r;
3307   int64_t r;
3308   const char *device;
3309
3310   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
3311                          &py_g, &device))
3312     return NULL;
3313   g = get_handle (py_g);
3314
3315   r = guestfs_blockdev_getsize64 (g, device);
3316   if (r == -1) {
3317     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3318     return NULL;
3319   }
3320
3321   py_r = PyLong_FromLongLong (r);
3322   return py_r;
3323 }
3324
3325 static PyObject *
3326 py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
3327 {
3328   PyObject *py_g;
3329   guestfs_h *g;
3330   PyObject *py_r;
3331   int r;
3332   const char *device;
3333
3334   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
3335                          &py_g, &device))
3336     return NULL;
3337   g = get_handle (py_g);
3338
3339   r = guestfs_blockdev_flushbufs (g, device);
3340   if (r == -1) {
3341     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3342     return NULL;
3343   }
3344
3345   Py_INCREF (Py_None);
3346   py_r = Py_None;
3347   return py_r;
3348 }
3349
3350 static PyObject *
3351 py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
3352 {
3353   PyObject *py_g;
3354   guestfs_h *g;
3355   PyObject *py_r;
3356   int r;
3357   const char *device;
3358
3359   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
3360                          &py_g, &device))
3361     return NULL;
3362   g = get_handle (py_g);
3363
3364   r = guestfs_blockdev_rereadpt (g, device);
3365   if (r == -1) {
3366     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3367     return NULL;
3368   }
3369
3370   Py_INCREF (Py_None);
3371   py_r = Py_None;
3372   return py_r;
3373 }
3374
3375 static PyObject *
3376 py_guestfs_upload (PyObject *self, PyObject *args)
3377 {
3378   PyObject *py_g;
3379   guestfs_h *g;
3380   PyObject *py_r;
3381   int r;
3382   const char *filename;
3383   const char *remotefilename;
3384
3385   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
3386                          &py_g, &filename, &remotefilename))
3387     return NULL;
3388   g = get_handle (py_g);
3389
3390   r = guestfs_upload (g, filename, remotefilename);
3391   if (r == -1) {
3392     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3393     return NULL;
3394   }
3395
3396   Py_INCREF (Py_None);
3397   py_r = Py_None;
3398   return py_r;
3399 }
3400
3401 static PyObject *
3402 py_guestfs_download (PyObject *self, PyObject *args)
3403 {
3404   PyObject *py_g;
3405   guestfs_h *g;
3406   PyObject *py_r;
3407   int r;
3408   const char *remotefilename;
3409   const char *filename;
3410
3411   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
3412                          &py_g, &remotefilename, &filename))
3413     return NULL;
3414   g = get_handle (py_g);
3415
3416   r = guestfs_download (g, remotefilename, filename);
3417   if (r == -1) {
3418     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3419     return NULL;
3420   }
3421
3422   Py_INCREF (Py_None);
3423   py_r = Py_None;
3424   return py_r;
3425 }
3426
3427 static PyObject *
3428 py_guestfs_checksum (PyObject *self, PyObject *args)
3429 {
3430   PyObject *py_g;
3431   guestfs_h *g;
3432   PyObject *py_r;
3433   char *r;
3434   const char *csumtype;
3435   const char *path;
3436
3437   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum",
3438                          &py_g, &csumtype, &path))
3439     return NULL;
3440   g = get_handle (py_g);
3441
3442   r = guestfs_checksum (g, csumtype, path);
3443   if (r == NULL) {
3444     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3445     return NULL;
3446   }
3447
3448   py_r = PyString_FromString (r);
3449   free (r);
3450   return py_r;
3451 }
3452
3453 static PyObject *
3454 py_guestfs_tar_in (PyObject *self, PyObject *args)
3455 {
3456   PyObject *py_g;
3457   guestfs_h *g;
3458   PyObject *py_r;
3459   int r;
3460   const char *tarfile;
3461   const char *directory;
3462
3463   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in",
3464                          &py_g, &tarfile, &directory))
3465     return NULL;
3466   g = get_handle (py_g);
3467
3468   r = guestfs_tar_in (g, tarfile, directory);
3469   if (r == -1) {
3470     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3471     return NULL;
3472   }
3473
3474   Py_INCREF (Py_None);
3475   py_r = Py_None;
3476   return py_r;
3477 }
3478
3479 static PyObject *
3480 py_guestfs_tar_out (PyObject *self, PyObject *args)
3481 {
3482   PyObject *py_g;
3483   guestfs_h *g;
3484   PyObject *py_r;
3485   int r;
3486   const char *directory;
3487   const char *tarfile;
3488
3489   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out",
3490                          &py_g, &directory, &tarfile))
3491     return NULL;
3492   g = get_handle (py_g);
3493
3494   r = guestfs_tar_out (g, directory, tarfile);
3495   if (r == -1) {
3496     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3497     return NULL;
3498   }
3499
3500   Py_INCREF (Py_None);
3501   py_r = Py_None;
3502   return py_r;
3503 }
3504
3505 static PyObject *
3506 py_guestfs_tgz_in (PyObject *self, PyObject *args)
3507 {
3508   PyObject *py_g;
3509   guestfs_h *g;
3510   PyObject *py_r;
3511   int r;
3512   const char *tarball;
3513   const char *directory;
3514
3515   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in",
3516                          &py_g, &tarball, &directory))
3517     return NULL;
3518   g = get_handle (py_g);
3519
3520   r = guestfs_tgz_in (g, tarball, directory);
3521   if (r == -1) {
3522     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3523     return NULL;
3524   }
3525
3526   Py_INCREF (Py_None);
3527   py_r = Py_None;
3528   return py_r;
3529 }
3530
3531 static PyObject *
3532 py_guestfs_tgz_out (PyObject *self, PyObject *args)
3533 {
3534   PyObject *py_g;
3535   guestfs_h *g;
3536   PyObject *py_r;
3537   int r;
3538   const char *directory;
3539   const char *tarball;
3540
3541   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out",
3542                          &py_g, &directory, &tarball))
3543     return NULL;
3544   g = get_handle (py_g);
3545
3546   r = guestfs_tgz_out (g, directory, tarball);
3547   if (r == -1) {
3548     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3549     return NULL;
3550   }
3551
3552   Py_INCREF (Py_None);
3553   py_r = Py_None;
3554   return py_r;
3555 }
3556
3557 static PyObject *
3558 py_guestfs_mount_ro (PyObject *self, PyObject *args)
3559 {
3560   PyObject *py_g;
3561   guestfs_h *g;
3562   PyObject *py_r;
3563   int r;
3564   const char *device;
3565   const char *mountpoint;
3566
3567   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro",
3568                          &py_g, &device, &mountpoint))
3569     return NULL;
3570   g = get_handle (py_g);
3571
3572   r = guestfs_mount_ro (g, 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_options (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 *device;
3592   const char *mountpoint;
3593
3594   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options",
3595                          &py_g, &options, &device, &mountpoint))
3596     return NULL;
3597   g = get_handle (py_g);
3598
3599   r = guestfs_mount_options (g, options, device, mountpoint);
3600   if (r == -1) {
3601     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3602     return NULL;
3603   }
3604
3605   Py_INCREF (Py_None);
3606   py_r = Py_None;
3607   return py_r;
3608 }
3609
3610 static PyObject *
3611 py_guestfs_mount_vfs (PyObject *self, PyObject *args)
3612 {
3613   PyObject *py_g;
3614   guestfs_h *g;
3615   PyObject *py_r;
3616   int r;
3617   const char *options;
3618   const char *vfstype;
3619   const char *device;
3620   const char *mountpoint;
3621
3622   if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs",
3623                          &py_g, &options, &vfstype, &device, &mountpoint))
3624     return NULL;
3625   g = get_handle (py_g);
3626
3627   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3628   if (r == -1) {
3629     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3630     return NULL;
3631   }
3632
3633   Py_INCREF (Py_None);
3634   py_r = Py_None;
3635   return py_r;
3636 }
3637
3638 static PyObject *
3639 py_guestfs_debug (PyObject *self, PyObject *args)
3640 {
3641   PyObject *py_g;
3642   guestfs_h *g;
3643   PyObject *py_r;
3644   char *r;
3645   const char *subcmd;
3646   PyObject *py_extraargs;
3647   const char **extraargs;
3648
3649   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug",
3650                          &py_g, &subcmd, &py_extraargs))
3651     return NULL;
3652   g = get_handle (py_g);
3653   extraargs = get_string_list (py_extraargs);
3654   if (!extraargs) return NULL;
3655
3656   r = guestfs_debug (g, subcmd, extraargs);
3657   free (extraargs);
3658   if (r == NULL) {
3659     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3660     return NULL;
3661   }
3662
3663   py_r = PyString_FromString (r);
3664   free (r);
3665   return py_r;
3666 }
3667
3668 static PyObject *
3669 py_guestfs_lvremove (PyObject *self, PyObject *args)
3670 {
3671   PyObject *py_g;
3672   guestfs_h *g;
3673   PyObject *py_r;
3674   int r;
3675   const char *device;
3676
3677   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove",
3678                          &py_g, &device))
3679     return NULL;
3680   g = get_handle (py_g);
3681
3682   r = guestfs_lvremove (g, device);
3683   if (r == -1) {
3684     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3685     return NULL;
3686   }
3687
3688   Py_INCREF (Py_None);
3689   py_r = Py_None;
3690   return py_r;
3691 }
3692
3693 static PyObject *
3694 py_guestfs_vgremove (PyObject *self, PyObject *args)
3695 {
3696   PyObject *py_g;
3697   guestfs_h *g;
3698   PyObject *py_r;
3699   int r;
3700   const char *vgname;
3701
3702   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove",
3703                          &py_g, &vgname))
3704     return NULL;
3705   g = get_handle (py_g);
3706
3707   r = guestfs_vgremove (g, vgname);
3708   if (r == -1) {
3709     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3710     return NULL;
3711   }
3712
3713   Py_INCREF (Py_None);
3714   py_r = Py_None;
3715   return py_r;
3716 }
3717
3718 static PyObject *
3719 py_guestfs_pvremove (PyObject *self, PyObject *args)
3720 {
3721   PyObject *py_g;
3722   guestfs_h *g;
3723   PyObject *py_r;
3724   int r;
3725   const char *device;
3726
3727   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove",
3728                          &py_g, &device))
3729     return NULL;
3730   g = get_handle (py_g);
3731
3732   r = guestfs_pvremove (g, device);
3733   if (r == -1) {
3734     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3735     return NULL;
3736   }
3737
3738   Py_INCREF (Py_None);
3739   py_r = Py_None;
3740   return py_r;
3741 }
3742
3743 static PyObject *
3744 py_guestfs_set_e2label (PyObject *self, PyObject *args)
3745 {
3746   PyObject *py_g;
3747   guestfs_h *g;
3748   PyObject *py_r;
3749   int r;
3750   const char *device;
3751   const char *label;
3752
3753   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label",
3754                          &py_g, &device, &label))
3755     return NULL;
3756   g = get_handle (py_g);
3757
3758   r = guestfs_set_e2label (g, device, label);
3759   if (r == -1) {
3760     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3761     return NULL;
3762   }
3763
3764   Py_INCREF (Py_None);
3765   py_r = Py_None;
3766   return py_r;
3767 }
3768
3769 static PyObject *
3770 py_guestfs_get_e2label (PyObject *self, PyObject *args)
3771 {
3772   PyObject *py_g;
3773   guestfs_h *g;
3774   PyObject *py_r;
3775   char *r;
3776   const char *device;
3777
3778   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label",
3779                          &py_g, &device))
3780     return NULL;
3781   g = get_handle (py_g);
3782
3783   r = guestfs_get_e2label (g, device);
3784   if (r == NULL) {
3785     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3786     return NULL;
3787   }
3788
3789   py_r = PyString_FromString (r);
3790   free (r);
3791   return py_r;
3792 }
3793
3794 static PyObject *
3795 py_guestfs_set_e2uuid (PyObject *self, PyObject *args)
3796 {
3797   PyObject *py_g;
3798   guestfs_h *g;
3799   PyObject *py_r;
3800   int r;
3801   const char *device;
3802   const char *uuid;
3803
3804   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid",
3805                          &py_g, &device, &uuid))
3806     return NULL;
3807   g = get_handle (py_g);
3808
3809   r = guestfs_set_e2uuid (g, device, uuid);
3810   if (r == -1) {
3811     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3812     return NULL;
3813   }
3814
3815   Py_INCREF (Py_None);
3816   py_r = Py_None;
3817   return py_r;
3818 }
3819
3820 static PyObject *
3821 py_guestfs_get_e2uuid (PyObject *self, PyObject *args)
3822 {
3823   PyObject *py_g;
3824   guestfs_h *g;
3825   PyObject *py_r;
3826   char *r;
3827   const char *device;
3828
3829   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid",
3830                          &py_g, &device))
3831     return NULL;
3832   g = get_handle (py_g);
3833
3834   r = guestfs_get_e2uuid (g, device);
3835   if (r == NULL) {
3836     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3837     return NULL;
3838   }
3839
3840   py_r = PyString_FromString (r);
3841   free (r);
3842   return py_r;
3843 }
3844
3845 static PyObject *
3846 py_guestfs_fsck (PyObject *self, PyObject *args)
3847 {
3848   PyObject *py_g;
3849   guestfs_h *g;
3850   PyObject *py_r;
3851   int r;
3852   const char *fstype;
3853   const char *device;
3854
3855   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck",
3856                          &py_g, &fstype, &device))
3857     return NULL;
3858   g = get_handle (py_g);
3859
3860   r = guestfs_fsck (g, fstype, device);
3861   if (r == -1) {
3862     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3863     return NULL;
3864   }
3865
3866   py_r = PyInt_FromLong ((long) r);
3867   return py_r;
3868 }
3869
3870 static PyObject *
3871 py_guestfs_zero (PyObject *self, PyObject *args)
3872 {
3873   PyObject *py_g;
3874   guestfs_h *g;
3875   PyObject *py_r;
3876   int r;
3877   const char *device;
3878
3879   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero",
3880                          &py_g, &device))
3881     return NULL;
3882   g = get_handle (py_g);
3883
3884   r = guestfs_zero (g, device);
3885   if (r == -1) {
3886     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3887     return NULL;
3888   }
3889
3890   Py_INCREF (Py_None);
3891   py_r = Py_None;
3892   return py_r;
3893 }
3894
3895 static PyObject *
3896 py_guestfs_grub_install (PyObject *self, PyObject *args)
3897 {
3898   PyObject *py_g;
3899   guestfs_h *g;
3900   PyObject *py_r;
3901   int r;
3902   const char *root;
3903   const char *device;
3904
3905   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install",
3906                          &py_g, &root, &device))
3907     return NULL;
3908   g = get_handle (py_g);
3909
3910   r = guestfs_grub_install (g, root, device);
3911   if (r == -1) {
3912     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3913     return NULL;
3914   }
3915
3916   Py_INCREF (Py_None);
3917   py_r = Py_None;
3918   return py_r;
3919 }
3920
3921 static PyObject *
3922 py_guestfs_cp (PyObject *self, PyObject *args)
3923 {
3924   PyObject *py_g;
3925   guestfs_h *g;
3926   PyObject *py_r;
3927   int r;
3928   const char *src;
3929   const char *dest;
3930
3931   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp",
3932                          &py_g, &src, &dest))
3933     return NULL;
3934   g = get_handle (py_g);
3935
3936   r = guestfs_cp (g, src, dest);
3937   if (r == -1) {
3938     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3939     return NULL;
3940   }
3941
3942   Py_INCREF (Py_None);
3943   py_r = Py_None;
3944   return py_r;
3945 }
3946
3947 static PyObject *
3948 py_guestfs_cp_a (PyObject *self, PyObject *args)
3949 {
3950   PyObject *py_g;
3951   guestfs_h *g;
3952   PyObject *py_r;
3953   int r;
3954   const char *src;
3955   const char *dest;
3956
3957   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a",
3958                          &py_g, &src, &dest))
3959     return NULL;
3960   g = get_handle (py_g);
3961
3962   r = guestfs_cp_a (g, src, dest);
3963   if (r == -1) {
3964     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3965     return NULL;
3966   }
3967
3968   Py_INCREF (Py_None);
3969   py_r = Py_None;
3970   return py_r;
3971 }
3972
3973 static PyObject *
3974 py_guestfs_mv (PyObject *self, PyObject *args)
3975 {
3976   PyObject *py_g;
3977   guestfs_h *g;
3978   PyObject *py_r;
3979   int r;
3980   const char *src;
3981   const char *dest;
3982
3983   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv",
3984                          &py_g, &src, &dest))
3985     return NULL;
3986   g = get_handle (py_g);
3987
3988   r = guestfs_mv (g, src, dest);
3989   if (r == -1) {
3990     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3991     return NULL;
3992   }
3993
3994   Py_INCREF (Py_None);
3995   py_r = Py_None;
3996   return py_r;
3997 }
3998
3999 static PyObject *
4000 py_guestfs_drop_caches (PyObject *self, PyObject *args)
4001 {
4002   PyObject *py_g;
4003   guestfs_h *g;
4004   PyObject *py_r;
4005   int r;
4006   int whattodrop;
4007
4008   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches",
4009                          &py_g, &whattodrop))
4010     return NULL;
4011   g = get_handle (py_g);
4012
4013   r = guestfs_drop_caches (g, whattodrop);
4014   if (r == -1) {
4015     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4016     return NULL;
4017   }
4018
4019   Py_INCREF (Py_None);
4020   py_r = Py_None;
4021   return py_r;
4022 }
4023
4024 static PyObject *
4025 py_guestfs_dmesg (PyObject *self, PyObject *args)
4026 {
4027   PyObject *py_g;
4028   guestfs_h *g;
4029   PyObject *py_r;
4030   char *r;
4031
4032   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_dmesg",
4033                          &py_g))
4034     return NULL;
4035   g = get_handle (py_g);
4036
4037   r = guestfs_dmesg (g);
4038   if (r == NULL) {
4039     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4040     return NULL;
4041   }
4042
4043   py_r = PyString_FromString (r);
4044   free (r);
4045   return py_r;
4046 }
4047
4048 static PyObject *
4049 py_guestfs_ping_daemon (PyObject *self, PyObject *args)
4050 {
4051   PyObject *py_g;
4052   guestfs_h *g;
4053   PyObject *py_r;
4054   int r;
4055
4056   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_ping_daemon",
4057                          &py_g))
4058     return NULL;
4059   g = get_handle (py_g);
4060
4061   r = guestfs_ping_daemon (g);
4062   if (r == -1) {
4063     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4064     return NULL;
4065   }
4066
4067   Py_INCREF (Py_None);
4068   py_r = Py_None;
4069   return py_r;
4070 }
4071
4072 static PyObject *
4073 py_guestfs_equal (PyObject *self, PyObject *args)
4074 {
4075   PyObject *py_g;
4076   guestfs_h *g;
4077   PyObject *py_r;
4078   int r;
4079   const char *file1;
4080   const char *file2;
4081
4082   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_equal",
4083                          &py_g, &file1, &file2))
4084     return NULL;
4085   g = get_handle (py_g);
4086
4087   r = guestfs_equal (g, file1, file2);
4088   if (r == -1) {
4089     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4090     return NULL;
4091   }
4092
4093   py_r = PyInt_FromLong ((long) r);
4094   return py_r;
4095 }
4096
4097 static PyObject *
4098 py_guestfs_strings (PyObject *self, PyObject *args)
4099 {
4100   PyObject *py_g;
4101   guestfs_h *g;
4102   PyObject *py_r;
4103   char **r;
4104   const char *path;
4105
4106   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_strings",
4107                          &py_g, &path))
4108     return NULL;
4109   g = get_handle (py_g);
4110
4111   r = guestfs_strings (g, path);
4112   if (r == NULL) {
4113     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4114     return NULL;
4115   }
4116
4117   py_r = put_string_list (r);
4118   free_strings (r);
4119   return py_r;
4120 }
4121
4122 static PyObject *
4123 py_guestfs_strings_e (PyObject *self, PyObject *args)
4124 {
4125   PyObject *py_g;
4126   guestfs_h *g;
4127   PyObject *py_r;
4128   char **r;
4129   const char *encoding;
4130   const char *path;
4131
4132   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_strings_e",
4133                          &py_g, &encoding, &path))
4134     return NULL;
4135   g = get_handle (py_g);
4136
4137   r = guestfs_strings_e (g, encoding, path);
4138   if (r == NULL) {
4139     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4140     return NULL;
4141   }
4142
4143   py_r = put_string_list (r);
4144   free_strings (r);
4145   return py_r;
4146 }
4147
4148 static PyObject *
4149 py_guestfs_hexdump (PyObject *self, PyObject *args)
4150 {
4151   PyObject *py_g;
4152   guestfs_h *g;
4153   PyObject *py_r;
4154   char *r;
4155   const char *path;
4156
4157   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_hexdump",
4158                          &py_g, &path))
4159     return NULL;
4160   g = get_handle (py_g);
4161
4162   r = guestfs_hexdump (g, path);
4163   if (r == NULL) {
4164     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4165     return NULL;
4166   }
4167
4168   py_r = PyString_FromString (r);
4169   free (r);
4170   return py_r;
4171 }
4172
4173 static PyObject *
4174 py_guestfs_zerofree (PyObject *self, PyObject *args)
4175 {
4176   PyObject *py_g;
4177   guestfs_h *g;
4178   PyObject *py_r;
4179   int r;
4180   const char *device;
4181
4182   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zerofree",
4183                          &py_g, &device))
4184     return NULL;
4185   g = get_handle (py_g);
4186
4187   r = guestfs_zerofree (g, device);
4188   if (r == -1) {
4189     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4190     return NULL;
4191   }
4192
4193   Py_INCREF (Py_None);
4194   py_r = Py_None;
4195   return py_r;
4196 }
4197
4198 static PyObject *
4199 py_guestfs_pvresize (PyObject *self, PyObject *args)
4200 {
4201   PyObject *py_g;
4202   guestfs_h *g;
4203   PyObject *py_r;
4204   int r;
4205   const char *device;
4206
4207   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvresize",
4208                          &py_g, &device))
4209     return NULL;
4210   g = get_handle (py_g);
4211
4212   r = guestfs_pvresize (g, device);
4213   if (r == -1) {
4214     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4215     return NULL;
4216   }
4217
4218   Py_INCREF (Py_None);
4219   py_r = Py_None;
4220   return py_r;
4221 }
4222
4223 static PyObject *
4224 py_guestfs_sfdisk_N (PyObject *self, PyObject *args)
4225 {
4226   PyObject *py_g;
4227   guestfs_h *g;
4228   PyObject *py_r;
4229   int r;
4230   const char *device;
4231   int partnum;
4232   int cyls;
4233   int heads;
4234   int sectors;
4235   const char *line;
4236
4237   if (!PyArg_ParseTuple (args, (char *) "Osiiiis:guestfs_sfdisk_N",
4238                          &py_g, &device, &partnum, &cyls, &heads, &sectors, &line))
4239     return NULL;
4240   g = get_handle (py_g);
4241
4242   r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
4243   if (r == -1) {
4244     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4245     return NULL;
4246   }
4247
4248   Py_INCREF (Py_None);
4249   py_r = Py_None;
4250   return py_r;
4251 }
4252
4253 static PyObject *
4254 py_guestfs_sfdisk_l (PyObject *self, PyObject *args)
4255 {
4256   PyObject *py_g;
4257   guestfs_h *g;
4258   PyObject *py_r;
4259   char *r;
4260   const char *device;
4261
4262   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_l",
4263                          &py_g, &device))
4264     return NULL;
4265   g = get_handle (py_g);
4266
4267   r = guestfs_sfdisk_l (g, device);
4268   if (r == NULL) {
4269     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4270     return NULL;
4271   }
4272
4273   py_r = PyString_FromString (r);
4274   free (r);
4275   return py_r;
4276 }
4277
4278 static PyObject *
4279 py_guestfs_sfdisk_kernel_geometry (PyObject *self, PyObject *args)
4280 {
4281   PyObject *py_g;
4282   guestfs_h *g;
4283   PyObject *py_r;
4284   char *r;
4285   const char *device;
4286
4287   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_kernel_geometry",
4288                          &py_g, &device))
4289     return NULL;
4290   g = get_handle (py_g);
4291
4292   r = guestfs_sfdisk_kernel_geometry (g, device);
4293   if (r == NULL) {
4294     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4295     return NULL;
4296   }
4297
4298   py_r = PyString_FromString (r);
4299   free (r);
4300   return py_r;
4301 }
4302
4303 static PyObject *
4304 py_guestfs_sfdisk_disk_geometry (PyObject *self, PyObject *args)
4305 {
4306   PyObject *py_g;
4307   guestfs_h *g;
4308   PyObject *py_r;
4309   char *r;
4310   const char *device;
4311
4312   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_disk_geometry",
4313                          &py_g, &device))
4314     return NULL;
4315   g = get_handle (py_g);
4316
4317   r = guestfs_sfdisk_disk_geometry (g, device);
4318   if (r == NULL) {
4319     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4320     return NULL;
4321   }
4322
4323   py_r = PyString_FromString (r);
4324   free (r);
4325   return py_r;
4326 }
4327
4328 static PyObject *
4329 py_guestfs_vg_activate_all (PyObject *self, PyObject *args)
4330 {
4331   PyObject *py_g;
4332   guestfs_h *g;
4333   PyObject *py_r;
4334   int r;
4335   int activate;
4336
4337   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_vg_activate_all",
4338                          &py_g, &activate))
4339     return NULL;
4340   g = get_handle (py_g);
4341
4342   r = guestfs_vg_activate_all (g, activate);
4343   if (r == -1) {
4344     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4345     return NULL;
4346   }
4347
4348   Py_INCREF (Py_None);
4349   py_r = Py_None;
4350   return py_r;
4351 }
4352
4353 static PyObject *
4354 py_guestfs_vg_activate (PyObject *self, PyObject *args)
4355 {
4356   PyObject *py_g;
4357   guestfs_h *g;
4358   PyObject *py_r;
4359   int r;
4360   int activate;
4361   PyObject *py_volgroups;
4362   const char **volgroups;
4363
4364   if (!PyArg_ParseTuple (args, (char *) "OiO:guestfs_vg_activate",
4365                          &py_g, &activate, &py_volgroups))
4366     return NULL;
4367   g = get_handle (py_g);
4368   volgroups = get_string_list (py_volgroups);
4369   if (!volgroups) return NULL;
4370
4371   r = guestfs_vg_activate (g, activate, volgroups);
4372   free (volgroups);
4373   if (r == -1) {
4374     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4375     return NULL;
4376   }
4377
4378   Py_INCREF (Py_None);
4379   py_r = Py_None;
4380   return py_r;
4381 }
4382
4383 static PyObject *
4384 py_guestfs_lvresize (PyObject *self, PyObject *args)
4385 {
4386   PyObject *py_g;
4387   guestfs_h *g;
4388   PyObject *py_r;
4389   int r;
4390   const char *device;
4391   int mbytes;
4392
4393   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_lvresize",
4394                          &py_g, &device, &mbytes))
4395     return NULL;
4396   g = get_handle (py_g);
4397
4398   r = guestfs_lvresize (g, device, mbytes);
4399   if (r == -1) {
4400     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4401     return NULL;
4402   }
4403
4404   Py_INCREF (Py_None);
4405   py_r = Py_None;
4406   return py_r;
4407 }
4408
4409 static PyObject *
4410 py_guestfs_resize2fs (PyObject *self, PyObject *args)
4411 {
4412   PyObject *py_g;
4413   guestfs_h *g;
4414   PyObject *py_r;
4415   int r;
4416   const char *device;
4417
4418   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_resize2fs",
4419                          &py_g, &device))
4420     return NULL;
4421   g = get_handle (py_g);
4422
4423   r = guestfs_resize2fs (g, device);
4424   if (r == -1) {
4425     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4426     return NULL;
4427   }
4428
4429   Py_INCREF (Py_None);
4430   py_r = Py_None;
4431   return py_r;
4432 }
4433
4434 static PyObject *
4435 py_guestfs_find (PyObject *self, PyObject *args)
4436 {
4437   PyObject *py_g;
4438   guestfs_h *g;
4439   PyObject *py_r;
4440   char **r;
4441   const char *directory;
4442
4443   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_find",
4444                          &py_g, &directory))
4445     return NULL;
4446   g = get_handle (py_g);
4447
4448   r = guestfs_find (g, directory);
4449   if (r == NULL) {
4450     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4451     return NULL;
4452   }
4453
4454   py_r = put_string_list (r);
4455   free_strings (r);
4456   return py_r;
4457 }
4458
4459 static PyObject *
4460 py_guestfs_e2fsck_f (PyObject *self, PyObject *args)
4461 {
4462   PyObject *py_g;
4463   guestfs_h *g;
4464   PyObject *py_r;
4465   int r;
4466   const char *device;
4467
4468   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_e2fsck_f",
4469                          &py_g, &device))
4470     return NULL;
4471   g = get_handle (py_g);
4472
4473   r = guestfs_e2fsck_f (g, device);
4474   if (r == -1) {
4475     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4476     return NULL;
4477   }
4478
4479   Py_INCREF (Py_None);
4480   py_r = Py_None;
4481   return py_r;
4482 }
4483
4484 static PyObject *
4485 py_guestfs_sleep (PyObject *self, PyObject *args)
4486 {
4487   PyObject *py_g;
4488   guestfs_h *g;
4489   PyObject *py_r;
4490   int r;
4491   int secs;
4492
4493   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_sleep",
4494                          &py_g, &secs))
4495     return NULL;
4496   g = get_handle (py_g);
4497
4498   r = guestfs_sleep (g, secs);
4499   if (r == -1) {
4500     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4501     return NULL;
4502   }
4503
4504   Py_INCREF (Py_None);
4505   py_r = Py_None;
4506   return py_r;
4507 }
4508
4509 static PyObject *
4510 py_guestfs_ntfs_3g_probe (PyObject *self, PyObject *args)
4511 {
4512   PyObject *py_g;
4513   guestfs_h *g;
4514   PyObject *py_r;
4515   int r;
4516   int rw;
4517   const char *device;
4518
4519   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_ntfs_3g_probe",
4520                          &py_g, &rw, &device))
4521     return NULL;
4522   g = get_handle (py_g);
4523
4524   r = guestfs_ntfs_3g_probe (g, rw, device);
4525   if (r == -1) {
4526     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4527     return NULL;
4528   }
4529
4530   py_r = PyInt_FromLong ((long) r);
4531   return py_r;
4532 }
4533
4534 static PyObject *
4535 py_guestfs_sh (PyObject *self, PyObject *args)
4536 {
4537   PyObject *py_g;
4538   guestfs_h *g;
4539   PyObject *py_r;
4540   char *r;
4541   const char *command;
4542
4543   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sh",
4544                          &py_g, &command))
4545     return NULL;
4546   g = get_handle (py_g);
4547
4548   r = guestfs_sh (g, command);
4549   if (r == NULL) {
4550     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4551     return NULL;
4552   }
4553
4554   py_r = PyString_FromString (r);
4555   free (r);
4556   return py_r;
4557 }
4558
4559 static PyObject *
4560 py_guestfs_sh_lines (PyObject *self, PyObject *args)
4561 {
4562   PyObject *py_g;
4563   guestfs_h *g;
4564   PyObject *py_r;
4565   char **r;
4566   const char *command;
4567
4568   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sh_lines",
4569                          &py_g, &command))
4570     return NULL;
4571   g = get_handle (py_g);
4572
4573   r = guestfs_sh_lines (g, command);
4574   if (r == NULL) {
4575     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4576     return NULL;
4577   }
4578
4579   py_r = put_string_list (r);
4580   free_strings (r);
4581   return py_r;
4582 }
4583
4584 static PyObject *
4585 py_guestfs_glob_expand (PyObject *self, PyObject *args)
4586 {
4587   PyObject *py_g;
4588   guestfs_h *g;
4589   PyObject *py_r;
4590   char **r;
4591   const char *pattern;
4592
4593   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_glob_expand",
4594                          &py_g, &pattern))
4595     return NULL;
4596   g = get_handle (py_g);
4597
4598   r = guestfs_glob_expand (g, pattern);
4599   if (r == NULL) {
4600     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4601     return NULL;
4602   }
4603
4604   py_r = put_string_list (r);
4605   free_strings (r);
4606   return py_r;
4607 }
4608
4609 static PyObject *
4610 py_guestfs_scrub_device (PyObject *self, PyObject *args)
4611 {
4612   PyObject *py_g;
4613   guestfs_h *g;
4614   PyObject *py_r;
4615   int r;
4616   const char *device;
4617
4618   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_device",
4619                          &py_g, &device))
4620     return NULL;
4621   g = get_handle (py_g);
4622
4623   r = guestfs_scrub_device (g, device);
4624   if (r == -1) {
4625     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4626     return NULL;
4627   }
4628
4629   Py_INCREF (Py_None);
4630   py_r = Py_None;
4631   return py_r;
4632 }
4633
4634 static PyObject *
4635 py_guestfs_scrub_file (PyObject *self, PyObject *args)
4636 {
4637   PyObject *py_g;
4638   guestfs_h *g;
4639   PyObject *py_r;
4640   int r;
4641   const char *file;
4642
4643   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_file",
4644                          &py_g, &file))
4645     return NULL;
4646   g = get_handle (py_g);
4647
4648   r = guestfs_scrub_file (g, file);
4649   if (r == -1) {
4650     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4651     return NULL;
4652   }
4653
4654   Py_INCREF (Py_None);
4655   py_r = Py_None;
4656   return py_r;
4657 }
4658
4659 static PyObject *
4660 py_guestfs_scrub_freespace (PyObject *self, PyObject *args)
4661 {
4662   PyObject *py_g;
4663   guestfs_h *g;
4664   PyObject *py_r;
4665   int r;
4666   const char *dir;
4667
4668   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_freespace",
4669                          &py_g, &dir))
4670     return NULL;
4671   g = get_handle (py_g);
4672
4673   r = guestfs_scrub_freespace (g, dir);
4674   if (r == -1) {
4675     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4676     return NULL;
4677   }
4678
4679   Py_INCREF (Py_None);
4680   py_r = Py_None;
4681   return py_r;
4682 }
4683
4684 static PyObject *
4685 py_guestfs_mkdtemp (PyObject *self, PyObject *args)
4686 {
4687   PyObject *py_g;
4688   guestfs_h *g;
4689   PyObject *py_r;
4690   char *r;
4691   const char *template;
4692
4693   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdtemp",
4694                          &py_g, &template))
4695     return NULL;
4696   g = get_handle (py_g);
4697
4698   r = guestfs_mkdtemp (g, template);
4699   if (r == NULL) {
4700     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4701     return NULL;
4702   }
4703
4704   py_r = PyString_FromString (r);
4705   free (r);
4706   return py_r;
4707 }
4708
4709 static PyObject *
4710 py_guestfs_wc_l (PyObject *self, PyObject *args)
4711 {
4712   PyObject *py_g;
4713   guestfs_h *g;
4714   PyObject *py_r;
4715   int r;
4716   const char *path;
4717
4718   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_wc_l",
4719                          &py_g, &path))
4720     return NULL;
4721   g = get_handle (py_g);
4722
4723   r = guestfs_wc_l (g, path);
4724   if (r == -1) {
4725     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4726     return NULL;
4727   }
4728
4729   py_r = PyInt_FromLong ((long) r);
4730   return py_r;
4731 }
4732
4733 static PyObject *
4734 py_guestfs_wc_w (PyObject *self, PyObject *args)
4735 {
4736   PyObject *py_g;
4737   guestfs_h *g;
4738   PyObject *py_r;
4739   int r;
4740   const char *path;
4741
4742   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_wc_w",
4743                          &py_g, &path))
4744     return NULL;
4745   g = get_handle (py_g);
4746
4747   r = guestfs_wc_w (g, path);
4748   if (r == -1) {
4749     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4750     return NULL;
4751   }
4752
4753   py_r = PyInt_FromLong ((long) r);
4754   return py_r;
4755 }
4756
4757 static PyObject *
4758 py_guestfs_wc_c (PyObject *self, PyObject *args)
4759 {
4760   PyObject *py_g;
4761   guestfs_h *g;
4762   PyObject *py_r;
4763   int r;
4764   const char *path;
4765
4766   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_wc_c",
4767                          &py_g, &path))
4768     return NULL;
4769   g = get_handle (py_g);
4770
4771   r = guestfs_wc_c (g, path);
4772   if (r == -1) {
4773     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4774     return NULL;
4775   }
4776
4777   py_r = PyInt_FromLong ((long) r);
4778   return py_r;
4779 }
4780
4781 static PyObject *
4782 py_guestfs_head (PyObject *self, PyObject *args)
4783 {
4784   PyObject *py_g;
4785   guestfs_h *g;
4786   PyObject *py_r;
4787   char **r;
4788   const char *path;
4789
4790   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_head",
4791                          &py_g, &path))
4792     return NULL;
4793   g = get_handle (py_g);
4794
4795   r = guestfs_head (g, path);
4796   if (r == NULL) {
4797     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4798     return NULL;
4799   }
4800
4801   py_r = put_string_list (r);
4802   free_strings (r);
4803   return py_r;
4804 }
4805
4806 static PyObject *
4807 py_guestfs_head_n (PyObject *self, PyObject *args)
4808 {
4809   PyObject *py_g;
4810   guestfs_h *g;
4811   PyObject *py_r;
4812   char **r;
4813   int nrlines;
4814   const char *path;
4815
4816   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_head_n",
4817                          &py_g, &nrlines, &path))
4818     return NULL;
4819   g = get_handle (py_g);
4820
4821   r = guestfs_head_n (g, nrlines, path);
4822   if (r == NULL) {
4823     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4824     return NULL;
4825   }
4826
4827   py_r = put_string_list (r);
4828   free_strings (r);
4829   return py_r;
4830 }
4831
4832 static PyObject *
4833 py_guestfs_tail (PyObject *self, PyObject *args)
4834 {
4835   PyObject *py_g;
4836   guestfs_h *g;
4837   PyObject *py_r;
4838   char **r;
4839   const char *path;
4840
4841   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tail",
4842                          &py_g, &path))
4843     return NULL;
4844   g = get_handle (py_g);
4845
4846   r = guestfs_tail (g, path);
4847   if (r == NULL) {
4848     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4849     return NULL;
4850   }
4851
4852   py_r = put_string_list (r);
4853   free_strings (r);
4854   return py_r;
4855 }
4856
4857 static PyObject *
4858 py_guestfs_tail_n (PyObject *self, PyObject *args)
4859 {
4860   PyObject *py_g;
4861   guestfs_h *g;
4862   PyObject *py_r;
4863   char **r;
4864   int nrlines;
4865   const char *path;
4866
4867   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_tail_n",
4868                          &py_g, &nrlines, &path))
4869     return NULL;
4870   g = get_handle (py_g);
4871
4872   r = guestfs_tail_n (g, nrlines, path);
4873   if (r == NULL) {
4874     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4875     return NULL;
4876   }
4877
4878   py_r = put_string_list (r);
4879   free_strings (r);
4880   return py_r;
4881 }
4882
4883 static PyObject *
4884 py_guestfs_df (PyObject *self, PyObject *args)
4885 {
4886   PyObject *py_g;
4887   guestfs_h *g;
4888   PyObject *py_r;
4889   char *r;
4890
4891   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_df",
4892                          &py_g))
4893     return NULL;
4894   g = get_handle (py_g);
4895
4896   r = guestfs_df (g);
4897   if (r == NULL) {
4898     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4899     return NULL;
4900   }
4901
4902   py_r = PyString_FromString (r);
4903   free (r);
4904   return py_r;
4905 }
4906
4907 static PyObject *
4908 py_guestfs_df_h (PyObject *self, PyObject *args)
4909 {
4910   PyObject *py_g;
4911   guestfs_h *g;
4912   PyObject *py_r;
4913   char *r;
4914
4915   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_df_h",
4916                          &py_g))
4917     return NULL;
4918   g = get_handle (py_g);
4919
4920   r = guestfs_df_h (g);
4921   if (r == NULL) {
4922     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4923     return NULL;
4924   }
4925
4926   py_r = PyString_FromString (r);
4927   free (r);
4928   return py_r;
4929 }
4930
4931 static PyObject *
4932 py_guestfs_du (PyObject *self, PyObject *args)
4933 {
4934   PyObject *py_g;
4935   guestfs_h *g;
4936   PyObject *py_r;
4937   int64_t r;
4938   const char *path;
4939
4940   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_du",
4941                          &py_g, &path))
4942     return NULL;
4943   g = get_handle (py_g);
4944
4945   r = guestfs_du (g, path);
4946   if (r == -1) {
4947     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4948     return NULL;
4949   }
4950
4951   py_r = PyLong_FromLongLong (r);
4952   return py_r;
4953 }
4954
4955 static PyObject *
4956 py_guestfs_initrd_list (PyObject *self, PyObject *args)
4957 {
4958   PyObject *py_g;
4959   guestfs_h *g;
4960   PyObject *py_r;
4961   char **r;
4962   const char *path;
4963
4964   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_initrd_list",
4965                          &py_g, &path))
4966     return NULL;
4967   g = get_handle (py_g);
4968
4969   r = guestfs_initrd_list (g, path);
4970   if (r == NULL) {
4971     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4972     return NULL;
4973   }
4974
4975   py_r = put_string_list (r);
4976   free_strings (r);
4977   return py_r;
4978 }
4979
4980 static PyObject *
4981 py_guestfs_mount_loop (PyObject *self, PyObject *args)
4982 {
4983   PyObject *py_g;
4984   guestfs_h *g;
4985   PyObject *py_r;
4986   int r;
4987   const char *file;
4988   const char *mountpoint;
4989
4990   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_loop",
4991                          &py_g, &file, &mountpoint))
4992     return NULL;
4993   g = get_handle (py_g);
4994
4995   r = guestfs_mount_loop (g, file, mountpoint);
4996   if (r == -1) {
4997     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
4998     return NULL;
4999   }
5000
5001   Py_INCREF (Py_None);
5002   py_r = Py_None;
5003   return py_r;
5004 }
5005
5006 static PyObject *
5007 py_guestfs_mkswap (PyObject *self, PyObject *args)
5008 {
5009   PyObject *py_g;
5010   guestfs_h *g;
5011   PyObject *py_r;
5012   int r;
5013   const char *device;
5014
5015   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkswap",
5016                          &py_g, &device))
5017     return NULL;
5018   g = get_handle (py_g);
5019
5020   r = guestfs_mkswap (g, device);
5021   if (r == -1) {
5022     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5023     return NULL;
5024   }
5025
5026   Py_INCREF (Py_None);
5027   py_r = Py_None;
5028   return py_r;
5029 }
5030
5031 static PyObject *
5032 py_guestfs_mkswap_L (PyObject *self, PyObject *args)
5033 {
5034   PyObject *py_g;
5035   guestfs_h *g;
5036   PyObject *py_r;
5037   int r;
5038   const char *label;
5039   const char *device;
5040
5041   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkswap_L",
5042                          &py_g, &label, &device))
5043     return NULL;
5044   g = get_handle (py_g);
5045
5046   r = guestfs_mkswap_L (g, label, device);
5047   if (r == -1) {
5048     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5049     return NULL;
5050   }
5051
5052   Py_INCREF (Py_None);
5053   py_r = Py_None;
5054   return py_r;
5055 }
5056
5057 static PyObject *
5058 py_guestfs_mkswap_U (PyObject *self, PyObject *args)
5059 {
5060   PyObject *py_g;
5061   guestfs_h *g;
5062   PyObject *py_r;
5063   int r;
5064   const char *uuid;
5065   const char *device;
5066
5067   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkswap_U",
5068                          &py_g, &uuid, &device))
5069     return NULL;
5070   g = get_handle (py_g);
5071
5072   r = guestfs_mkswap_U (g, uuid, device);
5073   if (r == -1) {
5074     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5075     return NULL;
5076   }
5077
5078   Py_INCREF (Py_None);
5079   py_r = Py_None;
5080   return py_r;
5081 }
5082
5083 static PyObject *
5084 py_guestfs_mknod (PyObject *self, PyObject *args)
5085 {
5086   PyObject *py_g;
5087   guestfs_h *g;
5088   PyObject *py_r;
5089   int r;
5090   int mode;
5091   int devmajor;
5092   int devminor;
5093   const char *path;
5094
5095   if (!PyArg_ParseTuple (args, (char *) "Oiiis:guestfs_mknod",
5096                          &py_g, &mode, &devmajor, &devminor, &path))
5097     return NULL;
5098   g = get_handle (py_g);
5099
5100   r = guestfs_mknod (g, mode, devmajor, devminor, path);
5101   if (r == -1) {
5102     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5103     return NULL;
5104   }
5105
5106   Py_INCREF (Py_None);
5107   py_r = Py_None;
5108   return py_r;
5109 }
5110
5111 static PyObject *
5112 py_guestfs_mkfifo (PyObject *self, PyObject *args)
5113 {
5114   PyObject *py_g;
5115   guestfs_h *g;
5116   PyObject *py_r;
5117   int r;
5118   int mode;
5119   const char *path;
5120
5121   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_mkfifo",
5122                          &py_g, &mode, &path))
5123     return NULL;
5124   g = get_handle (py_g);
5125
5126   r = guestfs_mkfifo (g, mode, path);
5127   if (r == -1) {
5128     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5129     return NULL;
5130   }
5131
5132   Py_INCREF (Py_None);
5133   py_r = Py_None;
5134   return py_r;
5135 }
5136
5137 static PyObject *
5138 py_guestfs_mknod_b (PyObject *self, PyObject *args)
5139 {
5140   PyObject *py_g;
5141   guestfs_h *g;
5142   PyObject *py_r;
5143   int r;
5144   int mode;
5145   int devmajor;
5146   int devminor;
5147   const char *path;
5148
5149   if (!PyArg_ParseTuple (args, (char *) "Oiiis:guestfs_mknod_b",
5150                          &py_g, &mode, &devmajor, &devminor, &path))
5151     return NULL;
5152   g = get_handle (py_g);
5153
5154   r = guestfs_mknod_b (g, mode, devmajor, devminor, path);
5155   if (r == -1) {
5156     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5157     return NULL;
5158   }
5159
5160   Py_INCREF (Py_None);
5161   py_r = Py_None;
5162   return py_r;
5163 }
5164
5165 static PyObject *
5166 py_guestfs_mknod_c (PyObject *self, PyObject *args)
5167 {
5168   PyObject *py_g;
5169   guestfs_h *g;
5170   PyObject *py_r;
5171   int r;
5172   int mode;
5173   int devmajor;
5174   int devminor;
5175   const char *path;
5176
5177   if (!PyArg_ParseTuple (args, (char *) "Oiiis:guestfs_mknod_c",
5178                          &py_g, &mode, &devmajor, &devminor, &path))
5179     return NULL;
5180   g = get_handle (py_g);
5181
5182   r = guestfs_mknod_c (g, mode, devmajor, devminor, path);
5183   if (r == -1) {
5184     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5185     return NULL;
5186   }
5187
5188   Py_INCREF (Py_None);
5189   py_r = Py_None;
5190   return py_r;
5191 }
5192
5193 static PyObject *
5194 py_guestfs_umask (PyObject *self, PyObject *args)
5195 {
5196   PyObject *py_g;
5197   guestfs_h *g;
5198   PyObject *py_r;
5199   int r;
5200   int mask;
5201
5202   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_umask",
5203                          &py_g, &mask))
5204     return NULL;
5205   g = get_handle (py_g);
5206
5207   r = guestfs_umask (g, mask);
5208   if (r == -1) {
5209     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5210     return NULL;
5211   }
5212
5213   py_r = PyInt_FromLong ((long) r);
5214   return py_r;
5215 }
5216
5217 static PyObject *
5218 py_guestfs_readdir (PyObject *self, PyObject *args)
5219 {
5220   PyObject *py_g;
5221   guestfs_h *g;
5222   PyObject *py_r;
5223   struct guestfs_dirent_list *r;
5224   const char *dir;
5225
5226   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_readdir",
5227                          &py_g, &dir))
5228     return NULL;
5229   g = get_handle (py_g);
5230
5231   r = guestfs_readdir (g, dir);
5232   if (r == NULL) {
5233     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
5234     return NULL;
5235   }
5236
5237   py_r = put_dirent_list (r);
5238   guestfs_free_dirent_list (r);
5239   return py_r;
5240 }
5241
5242 static PyMethodDef methods[] = {
5243   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
5244   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
5245   { (char *) "test0", py_guestfs_test0, METH_VARARGS, NULL },
5246   { (char *) "test0rint", py_guestfs_test0rint, METH_VARARGS, NULL },
5247   { (char *) "test0rinterr", py_guestfs_test0rinterr, METH_VARARGS, NULL },
5248   { (char *) "test0rint64", py_guestfs_test0rint64, METH_VARARGS, NULL },
5249   { (char *) "test0rint64err", py_guestfs_test0rint64err, METH_VARARGS, NULL },
5250   { (char *) "test0rbool", py_guestfs_test0rbool, METH_VARARGS, NULL },
5251   { (char *) "test0rboolerr", py_guestfs_test0rboolerr, METH_VARARGS, NULL },
5252   { (char *) "test0rconststring", py_guestfs_test0rconststring, METH_VARARGS, NULL },
5253   { (char *) "test0rconststringerr", py_guestfs_test0rconststringerr, METH_VARARGS, NULL },
5254   { (char *) "test0rstring", py_guestfs_test0rstring, METH_VARARGS, NULL },
5255   { (char *) "test0rstringerr", py_guestfs_test0rstringerr, METH_VARARGS, NULL },
5256   { (char *) "test0rstringlist", py_guestfs_test0rstringlist, METH_VARARGS, NULL },
5257   { (char *) "test0rstringlisterr", py_guestfs_test0rstringlisterr, METH_VARARGS, NULL },
5258   { (char *) "test0rintbool", py_guestfs_test0rintbool, METH_VARARGS, NULL },
5259   { (char *) "test0rintboolerr", py_guestfs_test0rintboolerr, METH_VARARGS, NULL },
5260   { (char *) "test0rpvlist", py_guestfs_test0rpvlist, METH_VARARGS, NULL },
5261   { (char *) "test0rpvlisterr", py_guestfs_test0rpvlisterr, METH_VARARGS, NULL },
5262   { (char *) "test0rvglist", py_guestfs_test0rvglist, METH_VARARGS, NULL },
5263   { (char *) "test0rvglisterr", py_guestfs_test0rvglisterr, METH_VARARGS, NULL },
5264   { (char *) "test0rlvlist", py_guestfs_test0rlvlist, METH_VARARGS, NULL },
5265   { (char *) "test0rlvlisterr", py_guestfs_test0rlvlisterr, METH_VARARGS, NULL },
5266   { (char *) "test0rstat", py_guestfs_test0rstat, METH_VARARGS, NULL },
5267   { (char *) "test0rstaterr", py_guestfs_test0rstaterr, METH_VARARGS, NULL },
5268   { (char *) "test0rstatvfs", py_guestfs_test0rstatvfs, METH_VARARGS, NULL },
5269   { (char *) "test0rstatvfserr", py_guestfs_test0rstatvfserr, METH_VARARGS, NULL },
5270   { (char *) "test0rhashtable", py_guestfs_test0rhashtable, METH_VARARGS, NULL },
5271   { (char *) "test0rhashtableerr", py_guestfs_test0rhashtableerr, METH_VARARGS, NULL },
5272   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
5273   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
5274   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
5275   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
5276   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
5277   { (char *) "add_drive_ro", py_guestfs_add_drive_ro, METH_VARARGS, NULL },
5278   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
5279   { (char *) "set_qemu", py_guestfs_set_qemu, METH_VARARGS, NULL },
5280   { (char *) "get_qemu", py_guestfs_get_qemu, METH_VARARGS, NULL },
5281   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
5282   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
5283   { (char *) "set_append", py_guestfs_set_append, METH_VARARGS, NULL },
5284   { (char *) "get_append", py_guestfs_get_append, METH_VARARGS, NULL },
5285   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
5286   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
5287   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
5288   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
5289   { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
5290   { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
5291   { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
5292   { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
5293   { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
5294   { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL },
5295   { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL },
5296   { (char *) "end_busy", py_guestfs_end_busy, METH_VARARGS, NULL },
5297   { (char *) "set_memsize", py_guestfs_set_memsize, METH_VARARGS, NULL },
5298   { (char *) "get_memsize", py_guestfs_get_memsize, METH_VARARGS, NULL },
5299   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
5300   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
5301   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
5302   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
5303   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
5304   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
5305   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
5306   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
5307   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
5308   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
5309   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
5310   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
5311   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
5312   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
5313   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
5314   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
5315   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
5316   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
5317   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
5318   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
5319   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
5320   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
5321   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
5322   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
5323   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
5324   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
5325   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
5326   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
5327   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
5328   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
5329   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
5330   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
5331   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
5332   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
5333   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
5334   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
5335   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
5336   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
5337   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
5338   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
5339   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
5340   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
5341   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
5342   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
5343   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
5344   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
5345   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
5346   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
5347   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
5348   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
5349   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
5350   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
5351   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
5352   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
5353   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
5354   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
5355   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
5356   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
5357   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
5358   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
5359   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
5360   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
5361   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
5362   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
5363   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
5364   { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
5365   { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
5366   { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL },
5367   { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL },
5368   { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL },
5369   { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL },
5370   { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL },
5371   { (char *) "mount_ro", py_guestfs_mount_ro, METH_VARARGS, NULL },
5372   { (char *) "mount_options", py_guestfs_mount_options, METH_VARARGS, NULL },
5373   { (char *) "mount_vfs", py_guestfs_mount_vfs, METH_VARARGS, NULL },
5374   { (char *) "debug", py_guestfs_debug, METH_VARARGS, NULL },
5375   { (char *) "lvremove", py_guestfs_lvremove, METH_VARARGS, NULL },
5376   { (char *) "vgremove", py_guestfs_vgremove, METH_VARARGS, NULL },
5377   { (char *) "pvremove", py_guestfs_pvremove, METH_VARARGS, NULL },
5378   { (char *) "set_e2label", py_guestfs_set_e2label, METH_VARARGS, NULL },
5379   { (char *) "get_e2label", py_guestfs_get_e2label, METH_VARARGS, NULL },
5380   { (char *) "set_e2uuid", py_guestfs_set_e2uuid, METH_VARARGS, NULL },
5381   { (char *) "get_e2uuid", py_guestfs_get_e2uuid, METH_VARARGS, NULL },
5382   { (char *) "fsck", py_guestfs_fsck, METH_VARARGS, NULL },
5383   { (char *) "zero", py_guestfs_zero, METH_VARARGS, NULL },
5384   { (char *) "grub_install", py_guestfs_grub_install, METH_VARARGS, NULL },
5385   { (char *) "cp", py_guestfs_cp, METH_VARARGS, NULL },
5386   { (char *) "cp_a", py_guestfs_cp_a, METH_VARARGS, NULL },
5387   { (char *) "mv", py_guestfs_mv, METH_VARARGS, NULL },
5388   { (char *) "drop_caches", py_guestfs_drop_caches, METH_VARARGS, NULL },
5389   { (char *) "dmesg", py_guestfs_dmesg, METH_VARARGS, NULL },
5390   { (char *) "ping_daemon", py_guestfs_ping_daemon, METH_VARARGS, NULL },
5391   { (char *) "equal", py_guestfs_equal, METH_VARARGS, NULL },
5392   { (char *) "strings", py_guestfs_strings, METH_VARARGS, NULL },
5393   { (char *) "strings_e", py_guestfs_strings_e, METH_VARARGS, NULL },
5394   { (char *) "hexdump", py_guestfs_hexdump, METH_VARARGS, NULL },
5395   { (char *) "zerofree", py_guestfs_zerofree, METH_VARARGS, NULL },
5396   { (char *) "pvresize", py_guestfs_pvresize, METH_VARARGS, NULL },
5397   { (char *) "sfdisk_N", py_guestfs_sfdisk_N, METH_VARARGS, NULL },
5398   { (char *) "sfdisk_l", py_guestfs_sfdisk_l, METH_VARARGS, NULL },
5399   { (char *) "sfdisk_kernel_geometry", py_guestfs_sfdisk_kernel_geometry, METH_VARARGS, NULL },
5400   { (char *) "sfdisk_disk_geometry", py_guestfs_sfdisk_disk_geometry, METH_VARARGS, NULL },
5401   { (char *) "vg_activate_all", py_guestfs_vg_activate_all, METH_VARARGS, NULL },
5402   { (char *) "vg_activate", py_guestfs_vg_activate, METH_VARARGS, NULL },
5403   { (char *) "lvresize", py_guestfs_lvresize, METH_VARARGS, NULL },
5404   { (char *) "resize2fs", py_guestfs_resize2fs, METH_VARARGS, NULL },
5405   { (char *) "find", py_guestfs_find, METH_VARARGS, NULL },
5406   { (char *) "e2fsck_f", py_guestfs_e2fsck_f, METH_VARARGS, NULL },
5407   { (char *) "sleep", py_guestfs_sleep, METH_VARARGS, NULL },
5408   { (char *) "ntfs_3g_probe", py_guestfs_ntfs_3g_probe, METH_VARARGS, NULL },
5409   { (char *) "sh", py_guestfs_sh, METH_VARARGS, NULL },
5410   { (char *) "sh_lines", py_guestfs_sh_lines, METH_VARARGS, NULL },
5411   { (char *) "glob_expand", py_guestfs_glob_expand, METH_VARARGS, NULL },
5412   { (char *) "scrub_device", py_guestfs_scrub_device, METH_VARARGS, NULL },
5413   { (char *) "scrub_file", py_guestfs_scrub_file, METH_VARARGS, NULL },
5414   { (char *) "scrub_freespace", py_guestfs_scrub_freespace, METH_VARARGS, NULL },
5415   { (char *) "mkdtemp", py_guestfs_mkdtemp, METH_VARARGS, NULL },
5416   { (char *) "wc_l", py_guestfs_wc_l, METH_VARARGS, NULL },
5417   { (char *) "wc_w", py_guestfs_wc_w, METH_VARARGS, NULL },
5418   { (char *) "wc_c", py_guestfs_wc_c, METH_VARARGS, NULL },
5419   { (char *) "head", py_guestfs_head, METH_VARARGS, NULL },
5420   { (char *) "head_n", py_guestfs_head_n, METH_VARARGS, NULL },
5421   { (char *) "tail", py_guestfs_tail, METH_VARARGS, NULL },
5422   { (char *) "tail_n", py_guestfs_tail_n, METH_VARARGS, NULL },
5423   { (char *) "df", py_guestfs_df, METH_VARARGS, NULL },
5424   { (char *) "df_h", py_guestfs_df_h, METH_VARARGS, NULL },
5425   { (char *) "du", py_guestfs_du, METH_VARARGS, NULL },
5426   { (char *) "initrd_list", py_guestfs_initrd_list, METH_VARARGS, NULL },
5427   { (char *) "mount_loop", py_guestfs_mount_loop, METH_VARARGS, NULL },
5428   { (char *) "mkswap", py_guestfs_mkswap, METH_VARARGS, NULL },
5429   { (char *) "mkswap_L", py_guestfs_mkswap_L, METH_VARARGS, NULL },
5430   { (char *) "mkswap_U", py_guestfs_mkswap_U, METH_VARARGS, NULL },
5431   { (char *) "mknod", py_guestfs_mknod, METH_VARARGS, NULL },
5432   { (char *) "mkfifo", py_guestfs_mkfifo, METH_VARARGS, NULL },
5433   { (char *) "mknod_b", py_guestfs_mknod_b, METH_VARARGS, NULL },
5434   { (char *) "mknod_c", py_guestfs_mknod_c, METH_VARARGS, NULL },
5435   { (char *) "umask", py_guestfs_umask, METH_VARARGS, NULL },
5436   { (char *) "readdir", py_guestfs_readdir, METH_VARARGS, NULL },
5437   { NULL, NULL, 0, NULL }
5438 };
5439
5440 void
5441 initlibguestfsmod (void)
5442 {
5443   static int initialized = 0;
5444
5445   if (initialized) return;
5446   Py_InitModule ((char *) "libguestfsmod", methods);
5447   initialized = 1;
5448 }