python/guestfs-py.c

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