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_autosync (PyObject *self, PyObject *args)
 637 {
 638   PyObject *py_g;
 639   guestfs_h *g;
 640   PyObject *py_r;
 641   int r;
 642   int autosync;
 643
 644   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
 645                          &py_g, &autosync))
 646     return NULL;
 647   g = get_handle (py_g);
 648
 649   r = guestfs_set_autosync (g, autosync);
 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_autosync (PyObject *self, PyObject *args)
 662 {
 663   PyObject *py_g;
 664   guestfs_h *g;
 665   PyObject *py_r;
 666   int r;
 667
 668   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
 669                          &py_g))
 670     return NULL;
 671   g = get_handle (py_g);
 672
 673   r = guestfs_get_autosync (g);
 674   if (r == -1) {
 675     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 676     return NULL;
 677   }
 678
 679   py_r = PyInt_FromLong ((long) r);
 680   return py_r;
 681 }
 682
 683 static PyObject *
 684 py_guestfs_set_verbose (PyObject *self, PyObject *args)
 685 {
 686   PyObject *py_g;
 687   guestfs_h *g;
 688   PyObject *py_r;
 689   int r;
 690   int verbose;
 691
 692   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
 693                          &py_g, &verbose))
 694     return NULL;
 695   g = get_handle (py_g);
 696
 697   r = guestfs_set_verbose (g, verbose);
 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_verbose (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_verbose",
 717                          &py_g))
 718     return NULL;
 719   g = get_handle (py_g);
 720
 721   r = guestfs_get_verbose (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_is_ready (PyObject *self, PyObject *args)
 733 {
 734   PyObject *py_g;
 735   guestfs_h *g;
 736   PyObject *py_r;
 737   int r;
 738
 739   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready",
 740                          &py_g))
 741     return NULL;
 742   g = get_handle (py_g);
 743
 744   r = guestfs_is_ready (g);
 745   if (r == -1) {
 746     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 747     return NULL;
 748   }
 749
 750   py_r = PyInt_FromLong ((long) r);
 751   return py_r;
 752 }
 753
 754 static PyObject *
 755 py_guestfs_is_config (PyObject *self, PyObject *args)
 756 {
 757   PyObject *py_g;
 758   guestfs_h *g;
 759   PyObject *py_r;
 760   int r;
 761
 762   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config",
 763                          &py_g))
 764     return NULL;
 765   g = get_handle (py_g);
 766
 767   r = guestfs_is_config (g);
 768   if (r == -1) {
 769     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 770     return NULL;
 771   }
 772
 773   py_r = PyInt_FromLong ((long) r);
 774   return py_r;
 775 }
 776
 777 static PyObject *
 778 py_guestfs_is_launching (PyObject *self, PyObject *args)
 779 {
 780   PyObject *py_g;
 781   guestfs_h *g;
 782   PyObject *py_r;
 783   int r;
 784
 785   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching",
 786                          &py_g))
 787     return NULL;
 788   g = get_handle (py_g);
 789
 790   r = guestfs_is_launching (g);
 791   if (r == -1) {
 792     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 793     return NULL;
 794   }
 795
 796   py_r = PyInt_FromLong ((long) r);
 797   return py_r;
 798 }
 799
 800 static PyObject *
 801 py_guestfs_is_busy (PyObject *self, PyObject *args)
 802 {
 803   PyObject *py_g;
 804   guestfs_h *g;
 805   PyObject *py_r;
 806   int r;
 807
 808   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy",
 809                          &py_g))
 810     return NULL;
 811   g = get_handle (py_g);
 812
 813   r = guestfs_is_busy (g);
 814   if (r == -1) {
 815     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 816     return NULL;
 817   }
 818
 819   py_r = PyInt_FromLong ((long) r);
 820   return py_r;
 821 }
 822
 823 static PyObject *
 824 py_guestfs_get_state (PyObject *self, PyObject *args)
 825 {
 826   PyObject *py_g;
 827   guestfs_h *g;
 828   PyObject *py_r;
 829   int r;
 830
 831   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state",
 832                          &py_g))
 833     return NULL;
 834   g = get_handle (py_g);
 835
 836   r = guestfs_get_state (g);
 837   if (r == -1) {
 838     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 839     return NULL;
 840   }
 841
 842   py_r = PyInt_FromLong ((long) r);
 843   return py_r;
 844 }
 845
 846 static PyObject *
 847 py_guestfs_set_busy (PyObject *self, PyObject *args)
 848 {
 849   PyObject *py_g;
 850   guestfs_h *g;
 851   PyObject *py_r;
 852   int r;
 853
 854   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy",
 855                          &py_g))
 856     return NULL;
 857   g = get_handle (py_g);
 858
 859   r = guestfs_set_busy (g);
 860   if (r == -1) {
 861     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 862     return NULL;
 863   }
 864
 865   Py_INCREF (Py_None);
 866   py_r = Py_None;
 867   return py_r;
 868 }
 869
 870 static PyObject *
 871 py_guestfs_set_ready (PyObject *self, PyObject *args)
 872 {
 873   PyObject *py_g;
 874   guestfs_h *g;
 875   PyObject *py_r;
 876   int r;
 877
 878   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_ready",
 879                          &py_g))
 880     return NULL;
 881   g = get_handle (py_g);
 882
 883   r = guestfs_set_ready (g);
 884   if (r == -1) {
 885     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 886     return NULL;
 887   }
 888
 889   Py_INCREF (Py_None);
 890   py_r = Py_None;
 891   return py_r;
 892 }
 893
 894 static PyObject *
 895 py_guestfs_end_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_end_busy",
 903                          &py_g))
 904     return NULL;
 905   g = get_handle (py_g);
 906
 907   r = guestfs_end_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_mount (PyObject *self, PyObject *args)
 920 {
 921   PyObject *py_g;
 922   guestfs_h *g;
 923   PyObject *py_r;
 924   int r;
 925   const char *device;
 926   const char *mountpoint;
 927
 928   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
 929                          &py_g, &device, &mountpoint))
 930     return NULL;
 931   g = get_handle (py_g);
 932
 933   r = guestfs_mount (g, device, mountpoint);
 934   if (r == -1) {
 935     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 936     return NULL;
 937   }
 938
 939   Py_INCREF (Py_None);
 940   py_r = Py_None;
 941   return py_r;
 942 }
 943
 944 static PyObject *
 945 py_guestfs_sync (PyObject *self, PyObject *args)
 946 {
 947   PyObject *py_g;
 948   guestfs_h *g;
 949   PyObject *py_r;
 950   int r;
 951
 952   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
 953                          &py_g))
 954     return NULL;
 955   g = get_handle (py_g);
 956
 957   r = guestfs_sync (g);
 958   if (r == -1) {
 959     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 960     return NULL;
 961   }
 962
 963   Py_INCREF (Py_None);
 964   py_r = Py_None;
 965   return py_r;
 966 }
 967
 968 static PyObject *
 969 py_guestfs_touch (PyObject *self, PyObject *args)
 970 {
 971   PyObject *py_g;
 972   guestfs_h *g;
 973   PyObject *py_r;
 974   int r;
 975   const char *path;
 976
 977   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
 978                          &py_g, &path))
 979     return NULL;
 980   g = get_handle (py_g);
 981
 982   r = guestfs_touch (g, path);
 983   if (r == -1) {
 984     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 985     return NULL;
 986   }
 987
 988   Py_INCREF (Py_None);
 989   py_r = Py_None;
 990   return py_r;
 991 }
 992
 993 static PyObject *
 994 py_guestfs_cat (PyObject *self, PyObject *args)
 995 {
 996   PyObject *py_g;
 997   guestfs_h *g;
 998   PyObject *py_r;
 999   char *r;
1000   const char *path;
1001
1002   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
1003                          &py_g, &path))
1004     return NULL;
1005   g = get_handle (py_g);
1006
1007   r = guestfs_cat (g, path);
1008   if (r == NULL) {
1009     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1010     return NULL;
1011   }
1012
1013   py_r = PyString_FromString (r);
1014   free (r);
1015   return py_r;
1016 }
1017
1018 static PyObject *
1019 py_guestfs_ll (PyObject *self, PyObject *args)
1020 {
1021   PyObject *py_g;
1022   guestfs_h *g;
1023   PyObject *py_r;
1024   char *r;
1025   const char *directory;
1026
1027   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
1028                          &py_g, &directory))
1029     return NULL;
1030   g = get_handle (py_g);
1031
1032   r = guestfs_ll (g, directory);
1033   if (r == NULL) {
1034     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1035     return NULL;
1036   }
1037
1038   py_r = PyString_FromString (r);
1039   free (r);
1040   return py_r;
1041 }
1042
1043 static PyObject *
1044 py_guestfs_ls (PyObject *self, PyObject *args)
1045 {
1046   PyObject *py_g;
1047   guestfs_h *g;
1048   PyObject *py_r;
1049   char **r;
1050   const char *directory;
1051
1052   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
1053                          &py_g, &directory))
1054     return NULL;
1055   g = get_handle (py_g);
1056
1057   r = guestfs_ls (g, directory);
1058   if (r == NULL) {
1059     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1060     return NULL;
1061   }
1062
1063   py_r = put_string_list (r);
1064   free_strings (r);
1065   return py_r;
1066 }
1067
1068 static PyObject *
1069 py_guestfs_list_devices (PyObject *self, PyObject *args)
1070 {
1071   PyObject *py_g;
1072   guestfs_h *g;
1073   PyObject *py_r;
1074   char **r;
1075
1076   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
1077                          &py_g))
1078     return NULL;
1079   g = get_handle (py_g);
1080
1081   r = guestfs_list_devices (g);
1082   if (r == NULL) {
1083     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1084     return NULL;
1085   }
1086
1087   py_r = put_string_list (r);
1088   free_strings (r);
1089   return py_r;
1090 }
1091
1092 static PyObject *
1093 py_guestfs_list_partitions (PyObject *self, PyObject *args)
1094 {
1095   PyObject *py_g;
1096   guestfs_h *g;
1097   PyObject *py_r;
1098   char **r;
1099
1100   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
1101                          &py_g))
1102     return NULL;
1103   g = get_handle (py_g);
1104
1105   r = guestfs_list_partitions (g);
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_pvs (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_pvs",
1125                          &py_g))
1126     return NULL;
1127   g = get_handle (py_g);
1128
1129   r = guestfs_pvs (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_vgs (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_vgs",
1149                          &py_g))
1150     return NULL;
1151   g = get_handle (py_g);
1152
1153   r = guestfs_vgs (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_lvs (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_lvs",
1173                          &py_g))
1174     return NULL;
1175   g = get_handle (py_g);
1176
1177   r = guestfs_lvs (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_pvs_full (PyObject *self, PyObject *args)
1190 {
1191   PyObject *py_g;
1192   guestfs_h *g;
1193   PyObject *py_r;
1194   struct guestfs_lvm_pv_list *r;
1195
1196   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
1197                          &py_g))
1198     return NULL;
1199   g = get_handle (py_g);
1200
1201   r = guestfs_pvs_full (g);
1202   if (r == NULL) {
1203     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1204     return NULL;
1205   }
1206
1207   py_r = put_lvm_pv_list (r);
1208   guestfs_free_lvm_pv_list (r);
1209   return py_r;
1210 }
1211
1212 static PyObject *
1213 py_guestfs_vgs_full (PyObject *self, PyObject *args)
1214 {
1215   PyObject *py_g;
1216   guestfs_h *g;
1217   PyObject *py_r;
1218   struct guestfs_lvm_vg_list *r;
1219
1220   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
1221                          &py_g))
1222     return NULL;
1223   g = get_handle (py_g);
1224
1225   r = guestfs_vgs_full (g);
1226   if (r == NULL) {
1227     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1228     return NULL;
1229   }
1230
1231   py_r = put_lvm_vg_list (r);
1232   guestfs_free_lvm_vg_list (r);
1233   return py_r;
1234 }
1235
1236 static PyObject *
1237 py_guestfs_lvs_full (PyObject *self, PyObject *args)
1238 {
1239   PyObject *py_g;
1240   guestfs_h *g;
1241   PyObject *py_r;
1242   struct guestfs_lvm_lv_list *r;
1243
1244   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
1245                          &py_g))
1246     return NULL;
1247   g = get_handle (py_g);
1248
1249   r = guestfs_lvs_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_lv_list (r);
1256   guestfs_free_lvm_lv_list (r);
1257   return py_r;
1258 }
1259
1260 static PyObject *
1261 py_guestfs_read_lines (PyObject *self, PyObject *args)
1262 {
1263   PyObject *py_g;
1264   guestfs_h *g;
1265   PyObject *py_r;
1266   char **r;
1267   const char *path;
1268
1269   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
1270                          &py_g, &path))
1271     return NULL;
1272   g = get_handle (py_g);
1273
1274   r = guestfs_read_lines (g, path);
1275   if (r == NULL) {
1276     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1277     return NULL;
1278   }
1279
1280   py_r = put_string_list (r);
1281   free_strings (r);
1282   return py_r;
1283 }
1284
1285 static PyObject *
1286 py_guestfs_aug_init (PyObject *self, PyObject *args)
1287 {
1288   PyObject *py_g;
1289   guestfs_h *g;
1290   PyObject *py_r;
1291   int r;
1292   const char *root;
1293   int flags;
1294
1295   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
1296                          &py_g, &root, &flags))
1297     return NULL;
1298   g = get_handle (py_g);
1299
1300   r = guestfs_aug_init (g, root, flags);
1301   if (r == -1) {
1302     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1303     return NULL;
1304   }
1305
1306   Py_INCREF (Py_None);
1307   py_r = Py_None;
1308   return py_r;
1309 }
1310
1311 static PyObject *
1312 py_guestfs_aug_close (PyObject *self, PyObject *args)
1313 {
1314   PyObject *py_g;
1315   guestfs_h *g;
1316   PyObject *py_r;
1317   int r;
1318
1319   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
1320                          &py_g))
1321     return NULL;
1322   g = get_handle (py_g);
1323
1324   r = guestfs_aug_close (g);
1325   if (r == -1) {
1326     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1327     return NULL;
1328   }
1329
1330   Py_INCREF (Py_None);
1331   py_r = Py_None;
1332   return py_r;
1333 }
1334
1335 static PyObject *
1336 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
1337 {
1338   PyObject *py_g;
1339   guestfs_h *g;
1340   PyObject *py_r;
1341   int r;
1342   const char *name;
1343   const char *expr;
1344
1345   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
1346                          &py_g, &name, &expr))
1347     return NULL;
1348   g = get_handle (py_g);
1349
1350   r = guestfs_aug_defvar (g, name, expr);
1351   if (r == -1) {
1352     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1353     return NULL;
1354   }
1355
1356   py_r = PyInt_FromLong ((long) r);
1357   return py_r;
1358 }
1359
1360 static PyObject *
1361 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
1362 {
1363   PyObject *py_g;
1364   guestfs_h *g;
1365   PyObject *py_r;
1366   struct guestfs_int_bool *r;
1367   const char *name;
1368   const char *expr;
1369   const char *val;
1370
1371   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
1372                          &py_g, &name, &expr, &val))
1373     return NULL;
1374   g = get_handle (py_g);
1375
1376   r = guestfs_aug_defnode (g, name, expr, val);
1377   if (r == NULL) {
1378     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1379     return NULL;
1380   }
1381
1382   py_r = PyTuple_New (2);
1383   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
1384   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
1385   guestfs_free_int_bool (r);
1386   return py_r;
1387 }
1388
1389 static PyObject *
1390 py_guestfs_aug_get (PyObject *self, PyObject *args)
1391 {
1392   PyObject *py_g;
1393   guestfs_h *g;
1394   PyObject *py_r;
1395   char *r;
1396   const char *path;
1397
1398   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
1399                          &py_g, &path))
1400     return NULL;
1401   g = get_handle (py_g);
1402
1403   r = guestfs_aug_get (g, path);
1404   if (r == NULL) {
1405     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1406     return NULL;
1407   }
1408
1409   py_r = PyString_FromString (r);
1410   free (r);
1411   return py_r;
1412 }
1413
1414 static PyObject *
1415 py_guestfs_aug_set (PyObject *self, PyObject *args)
1416 {
1417   PyObject *py_g;
1418   guestfs_h *g;
1419   PyObject *py_r;
1420   int r;
1421   const char *path;
1422   const char *val;
1423
1424   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
1425                          &py_g, &path, &val))
1426     return NULL;
1427   g = get_handle (py_g);
1428
1429   r = guestfs_aug_set (g, path, val);
1430   if (r == -1) {
1431     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1432     return NULL;
1433   }
1434
1435   Py_INCREF (Py_None);
1436   py_r = Py_None;
1437   return py_r;
1438 }
1439
1440 static PyObject *
1441 py_guestfs_aug_insert (PyObject *self, PyObject *args)
1442 {
1443   PyObject *py_g;
1444   guestfs_h *g;
1445   PyObject *py_r;
1446   int r;
1447   const char *path;
1448   const char *label;
1449   int before;
1450
1451   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
1452                          &py_g, &path, &label, &before))
1453     return NULL;
1454   g = get_handle (py_g);
1455
1456   r = guestfs_aug_insert (g, path, label, before);
1457   if (r == -1) {
1458     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1459     return NULL;
1460   }
1461
1462   Py_INCREF (Py_None);
1463   py_r = Py_None;
1464   return py_r;
1465 }
1466
1467 static PyObject *
1468 py_guestfs_aug_rm (PyObject *self, PyObject *args)
1469 {
1470   PyObject *py_g;
1471   guestfs_h *g;
1472   PyObject *py_r;
1473   int r;
1474   const char *path;
1475
1476   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
1477                          &py_g, &path))
1478     return NULL;
1479   g = get_handle (py_g);
1480
1481   r = guestfs_aug_rm (g, path);
1482   if (r == -1) {
1483     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1484     return NULL;
1485   }
1486
1487   py_r = PyInt_FromLong ((long) r);
1488   return py_r;
1489 }
1490
1491 static PyObject *
1492 py_guestfs_aug_mv (PyObject *self, PyObject *args)
1493 {
1494   PyObject *py_g;
1495   guestfs_h *g;
1496   PyObject *py_r;
1497   int r;
1498   const char *src;
1499   const char *dest;
1500
1501   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
1502                          &py_g, &src, &dest))
1503     return NULL;
1504   g = get_handle (py_g);
1505
1506   r = guestfs_aug_mv (g, src, dest);
1507   if (r == -1) {
1508     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1509     return NULL;
1510   }
1511
1512   Py_INCREF (Py_None);
1513   py_r = Py_None;
1514   return py_r;
1515 }
1516
1517 static PyObject *
1518 py_guestfs_aug_match (PyObject *self, PyObject *args)
1519 {
1520   PyObject *py_g;
1521   guestfs_h *g;
1522   PyObject *py_r;
1523   char **r;
1524   const char *path;
1525
1526   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
1527                          &py_g, &path))
1528     return NULL;
1529   g = get_handle (py_g);
1530
1531   r = guestfs_aug_match (g, path);
1532   if (r == NULL) {
1533     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1534     return NULL;
1535   }
1536
1537   py_r = put_string_list (r);
1538   free_strings (r);
1539   return py_r;
1540 }
1541
1542 static PyObject *
1543 py_guestfs_aug_save (PyObject *self, PyObject *args)
1544 {
1545   PyObject *py_g;
1546   guestfs_h *g;
1547   PyObject *py_r;
1548   int r;
1549
1550   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
1551                          &py_g))
1552     return NULL;
1553   g = get_handle (py_g);
1554
1555   r = guestfs_aug_save (g);
1556   if (r == -1) {
1557     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1558     return NULL;
1559   }
1560
1561   Py_INCREF (Py_None);
1562   py_r = Py_None;
1563   return py_r;
1564 }
1565
1566 static PyObject *
1567 py_guestfs_aug_load (PyObject *self, PyObject *args)
1568 {
1569   PyObject *py_g;
1570   guestfs_h *g;
1571   PyObject *py_r;
1572   int r;
1573
1574   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
1575                          &py_g))
1576     return NULL;
1577   g = get_handle (py_g);
1578
1579   r = guestfs_aug_load (g);
1580   if (r == -1) {
1581     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1582     return NULL;
1583   }
1584
1585   Py_INCREF (Py_None);
1586   py_r = Py_None;
1587   return py_r;
1588 }
1589
1590 static PyObject *
1591 py_guestfs_aug_ls (PyObject *self, PyObject *args)
1592 {
1593   PyObject *py_g;
1594   guestfs_h *g;
1595   PyObject *py_r;
1596   char **r;
1597   const char *path;
1598
1599   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
1600                          &py_g, &path))
1601     return NULL;
1602   g = get_handle (py_g);
1603
1604   r = guestfs_aug_ls (g, path);
1605   if (r == NULL) {
1606     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1607     return NULL;
1608   }
1609
1610   py_r = put_string_list (r);
1611   free_strings (r);
1612   return py_r;
1613 }
1614
1615 static PyObject *
1616 py_guestfs_rm (PyObject *self, PyObject *args)
1617 {
1618   PyObject *py_g;
1619   guestfs_h *g;
1620   PyObject *py_r;
1621   int r;
1622   const char *path;
1623
1624   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
1625                          &py_g, &path))
1626     return NULL;
1627   g = get_handle (py_g);
1628
1629   r = guestfs_rm (g, path);
1630   if (r == -1) {
1631     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1632     return NULL;
1633   }
1634
1635   Py_INCREF (Py_None);
1636   py_r = Py_None;
1637   return py_r;
1638 }
1639
1640 static PyObject *
1641 py_guestfs_rmdir (PyObject *self, PyObject *args)
1642 {
1643   PyObject *py_g;
1644   guestfs_h *g;
1645   PyObject *py_r;
1646   int r;
1647   const char *path;
1648
1649   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
1650                          &py_g, &path))
1651     return NULL;
1652   g = get_handle (py_g);
1653
1654   r = guestfs_rmdir (g, path);
1655   if (r == -1) {
1656     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1657     return NULL;
1658   }
1659
1660   Py_INCREF (Py_None);
1661   py_r = Py_None;
1662   return py_r;
1663 }
1664
1665 static PyObject *
1666 py_guestfs_rm_rf (PyObject *self, PyObject *args)
1667 {
1668   PyObject *py_g;
1669   guestfs_h *g;
1670   PyObject *py_r;
1671   int r;
1672   const char *path;
1673
1674   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
1675                          &py_g, &path))
1676     return NULL;
1677   g = get_handle (py_g);
1678
1679   r = guestfs_rm_rf (g, path);
1680   if (r == -1) {
1681     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1682     return NULL;
1683   }
1684
1685   Py_INCREF (Py_None);
1686   py_r = Py_None;
1687   return py_r;
1688 }
1689
1690 static PyObject *
1691 py_guestfs_mkdir (PyObject *self, PyObject *args)
1692 {
1693   PyObject *py_g;
1694   guestfs_h *g;
1695   PyObject *py_r;
1696   int r;
1697   const char *path;
1698
1699   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
1700                          &py_g, &path))
1701     return NULL;
1702   g = get_handle (py_g);
1703
1704   r = guestfs_mkdir (g, path);
1705   if (r == -1) {
1706     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1707     return NULL;
1708   }
1709
1710   Py_INCREF (Py_None);
1711   py_r = Py_None;
1712   return py_r;
1713 }
1714
1715 static PyObject *
1716 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
1717 {
1718   PyObject *py_g;
1719   guestfs_h *g;
1720   PyObject *py_r;
1721   int r;
1722   const char *path;
1723
1724   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
1725                          &py_g, &path))
1726     return NULL;
1727   g = get_handle (py_g);
1728
1729   r = guestfs_mkdir_p (g, path);
1730   if (r == -1) {
1731     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1732     return NULL;
1733   }
1734
1735   Py_INCREF (Py_None);
1736   py_r = Py_None;
1737   return py_r;
1738 }
1739
1740 static PyObject *
1741 py_guestfs_chmod (PyObject *self, PyObject *args)
1742 {
1743   PyObject *py_g;
1744   guestfs_h *g;
1745   PyObject *py_r;
1746   int r;
1747   int mode;
1748   const char *path;
1749
1750   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
1751                          &py_g, &mode, &path))
1752     return NULL;
1753   g = get_handle (py_g);
1754
1755   r = guestfs_chmod (g, mode, path);
1756   if (r == -1) {
1757     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1758     return NULL;
1759   }
1760
1761   Py_INCREF (Py_None);
1762   py_r = Py_None;
1763   return py_r;
1764 }
1765
1766 static PyObject *
1767 py_guestfs_chown (PyObject *self, PyObject *args)
1768 {
1769   PyObject *py_g;
1770   guestfs_h *g;
1771   PyObject *py_r;
1772   int r;
1773   int owner;
1774   int group;
1775   const char *path;
1776
1777   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
1778                          &py_g, &owner, &group, &path))
1779     return NULL;
1780   g = get_handle (py_g);
1781
1782   r = guestfs_chown (g, owner, group, path);
1783   if (r == -1) {
1784     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1785     return NULL;
1786   }
1787
1788   Py_INCREF (Py_None);
1789   py_r = Py_None;
1790   return py_r;
1791 }
1792
1793 static PyObject *
1794 py_guestfs_exists (PyObject *self, PyObject *args)
1795 {
1796   PyObject *py_g;
1797   guestfs_h *g;
1798   PyObject *py_r;
1799   int r;
1800   const char *path;
1801
1802   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
1803                          &py_g, &path))
1804     return NULL;
1805   g = get_handle (py_g);
1806
1807   r = guestfs_exists (g, path);
1808   if (r == -1) {
1809     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1810     return NULL;
1811   }
1812
1813   py_r = PyInt_FromLong ((long) r);
1814   return py_r;
1815 }
1816
1817 static PyObject *
1818 py_guestfs_is_file (PyObject *self, PyObject *args)
1819 {
1820   PyObject *py_g;
1821   guestfs_h *g;
1822   PyObject *py_r;
1823   int r;
1824   const char *path;
1825
1826   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
1827                          &py_g, &path))
1828     return NULL;
1829   g = get_handle (py_g);
1830
1831   r = guestfs_is_file (g, path);
1832   if (r == -1) {
1833     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1834     return NULL;
1835   }
1836
1837   py_r = PyInt_FromLong ((long) r);
1838   return py_r;
1839 }
1840
1841 static PyObject *
1842 py_guestfs_is_dir (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_is_dir",
1851                          &py_g, &path))
1852     return NULL;
1853   g = get_handle (py_g);
1854
1855   r = guestfs_is_dir (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_pvcreate (PyObject *self, PyObject *args)
1867 {
1868   PyObject *py_g;
1869   guestfs_h *g;
1870   PyObject *py_r;
1871   int r;
1872   const char *device;
1873
1874   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
1875                          &py_g, &device))
1876     return NULL;
1877   g = get_handle (py_g);
1878
1879   r = guestfs_pvcreate (g, device);
1880   if (r == -1) {
1881     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1882     return NULL;
1883   }
1884
1885   Py_INCREF (Py_None);
1886   py_r = Py_None;
1887   return py_r;
1888 }
1889
1890 static PyObject *
1891 py_guestfs_vgcreate (PyObject *self, PyObject *args)
1892 {
1893   PyObject *py_g;
1894   guestfs_h *g;
1895   PyObject *py_r;
1896   int r;
1897   const char *volgroup;
1898   PyObject *py_physvols;
1899   const char **physvols;
1900
1901   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
1902                          &py_g, &volgroup, &py_physvols))
1903     return NULL;
1904   g = get_handle (py_g);
1905   physvols = get_string_list (py_physvols);
1906   if (!physvols) return NULL;
1907
1908   r = guestfs_vgcreate (g, volgroup, physvols);
1909   free (physvols);
1910   if (r == -1) {
1911     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1912     return NULL;
1913   }
1914
1915   Py_INCREF (Py_None);
1916   py_r = Py_None;
1917   return py_r;
1918 }
1919
1920 static PyObject *
1921 py_guestfs_lvcreate (PyObject *self, PyObject *args)
1922 {
1923   PyObject *py_g;
1924   guestfs_h *g;
1925   PyObject *py_r;
1926   int r;
1927   const char *logvol;
1928   const char *volgroup;
1929   int mbytes;
1930
1931   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
1932                          &py_g, &logvol, &volgroup, &mbytes))
1933     return NULL;
1934   g = get_handle (py_g);
1935
1936   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1937   if (r == -1) {
1938     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1939     return NULL;
1940   }
1941
1942   Py_INCREF (Py_None);
1943   py_r = Py_None;
1944   return py_r;
1945 }
1946
1947 static PyObject *
1948 py_guestfs_mkfs (PyObject *self, PyObject *args)
1949 {
1950   PyObject *py_g;
1951   guestfs_h *g;
1952   PyObject *py_r;
1953   int r;
1954   const char *fstype;
1955   const char *device;
1956
1957   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
1958                          &py_g, &fstype, &device))
1959     return NULL;
1960   g = get_handle (py_g);
1961
1962   r = guestfs_mkfs (g, fstype, device);
1963   if (r == -1) {
1964     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1965     return NULL;
1966   }
1967
1968   Py_INCREF (Py_None);
1969   py_r = Py_None;
1970   return py_r;
1971 }
1972
1973 static PyObject *
1974 py_guestfs_sfdisk (PyObject *self, PyObject *args)
1975 {
1976   PyObject *py_g;
1977   guestfs_h *g;
1978   PyObject *py_r;
1979   int r;
1980   const char *device;
1981   int cyls;
1982   int heads;
1983   int sectors;
1984   PyObject *py_lines;
1985   const char **lines;
1986
1987   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
1988                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
1989     return NULL;
1990   g = get_handle (py_g);
1991   lines = get_string_list (py_lines);
1992   if (!lines) return NULL;
1993
1994   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1995   free (lines);
1996   if (r == -1) {
1997     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1998     return NULL;
1999   }
2000
2001   Py_INCREF (Py_None);
2002   py_r = Py_None;
2003   return py_r;
2004 }
2005
2006 static PyObject *
2007 py_guestfs_write_file (PyObject *self, PyObject *args)
2008 {
2009   PyObject *py_g;
2010   guestfs_h *g;
2011   PyObject *py_r;
2012   int r;
2013   const char *path;
2014   const char *content;
2015   int size;
2016
2017   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
2018                          &py_g, &path, &content, &size))
2019     return NULL;
2020   g = get_handle (py_g);
2021
2022   r = guestfs_write_file (g, path, content, size);
2023   if (r == -1) {
2024     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2025     return NULL;
2026   }
2027
2028   Py_INCREF (Py_None);
2029   py_r = Py_None;
2030   return py_r;
2031 }
2032
2033 static PyObject *
2034 py_guestfs_umount (PyObject *self, PyObject *args)
2035 {
2036   PyObject *py_g;
2037   guestfs_h *g;
2038   PyObject *py_r;
2039   int r;
2040   const char *pathordevice;
2041
2042   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
2043                          &py_g, &pathordevice))
2044     return NULL;
2045   g = get_handle (py_g);
2046
2047   r = guestfs_umount (g, pathordevice);
2048   if (r == -1) {
2049     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2050     return NULL;
2051   }
2052
2053   Py_INCREF (Py_None);
2054   py_r = Py_None;
2055   return py_r;
2056 }
2057
2058 static PyObject *
2059 py_guestfs_mounts (PyObject *self, PyObject *args)
2060 {
2061   PyObject *py_g;
2062   guestfs_h *g;
2063   PyObject *py_r;
2064   char **r;
2065
2066   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
2067                          &py_g))
2068     return NULL;
2069   g = get_handle (py_g);
2070
2071   r = guestfs_mounts (g);
2072   if (r == NULL) {
2073     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2074     return NULL;
2075   }
2076
2077   py_r = put_string_list (r);
2078   free_strings (r);
2079   return py_r;
2080 }
2081
2082 static PyObject *
2083 py_guestfs_umount_all (PyObject *self, PyObject *args)
2084 {
2085   PyObject *py_g;
2086   guestfs_h *g;
2087   PyObject *py_r;
2088   int r;
2089
2090   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
2091                          &py_g))
2092     return NULL;
2093   g = get_handle (py_g);
2094
2095   r = guestfs_umount_all (g);
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_lvm_remove_all (PyObject *self, PyObject *args)
2108 {
2109   PyObject *py_g;
2110   guestfs_h *g;
2111   PyObject *py_r;
2112   int r;
2113
2114   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
2115                          &py_g))
2116     return NULL;
2117   g = get_handle (py_g);
2118
2119   r = guestfs_lvm_remove_all (g);
2120   if (r == -1) {
2121     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2122     return NULL;
2123   }
2124
2125   Py_INCREF (Py_None);
2126   py_r = Py_None;
2127   return py_r;
2128 }
2129
2130 static PyObject *
2131 py_guestfs_file (PyObject *self, PyObject *args)
2132 {
2133   PyObject *py_g;
2134   guestfs_h *g;
2135   PyObject *py_r;
2136   char *r;
2137   const char *path;
2138
2139   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
2140                          &py_g, &path))
2141     return NULL;
2142   g = get_handle (py_g);
2143
2144   r = guestfs_file (g, path);
2145   if (r == NULL) {
2146     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2147     return NULL;
2148   }
2149
2150   py_r = PyString_FromString (r);
2151   free (r);
2152   return py_r;
2153 }
2154
2155 static PyObject *
2156 py_guestfs_command (PyObject *self, PyObject *args)
2157 {
2158   PyObject *py_g;
2159   guestfs_h *g;
2160   PyObject *py_r;
2161   char *r;
2162   PyObject *py_arguments;
2163   const char **arguments;
2164
2165   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
2166                          &py_g, &py_arguments))
2167     return NULL;
2168   g = get_handle (py_g);
2169   arguments = get_string_list (py_arguments);
2170   if (!arguments) return NULL;
2171
2172   r = guestfs_command (g, arguments);
2173   free (arguments);
2174   if (r == NULL) {
2175     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2176     return NULL;
2177   }
2178
2179   py_r = PyString_FromString (r);
2180   free (r);
2181   return py_r;
2182 }
2183
2184 static PyObject *
2185 py_guestfs_command_lines (PyObject *self, PyObject *args)
2186 {
2187   PyObject *py_g;
2188   guestfs_h *g;
2189   PyObject *py_r;
2190   char **r;
2191   PyObject *py_arguments;
2192   const char **arguments;
2193
2194   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
2195                          &py_g, &py_arguments))
2196     return NULL;
2197   g = get_handle (py_g);
2198   arguments = get_string_list (py_arguments);
2199   if (!arguments) return NULL;
2200
2201   r = guestfs_command_lines (g, arguments);
2202   free (arguments);
2203   if (r == NULL) {
2204     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2205     return NULL;
2206   }
2207
2208   py_r = put_string_list (r);
2209   free_strings (r);
2210   return py_r;
2211 }
2212
2213 static PyObject *
2214 py_guestfs_stat (PyObject *self, PyObject *args)
2215 {
2216   PyObject *py_g;
2217   guestfs_h *g;
2218   PyObject *py_r;
2219   struct guestfs_stat *r;
2220   const char *path;
2221
2222   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
2223                          &py_g, &path))
2224     return NULL;
2225   g = get_handle (py_g);
2226
2227   r = guestfs_stat (g, path);
2228   if (r == NULL) {
2229     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2230     return NULL;
2231   }
2232
2233   py_r = put_stat (r);
2234   free (r);
2235   return py_r;
2236 }
2237
2238 static PyObject *
2239 py_guestfs_lstat (PyObject *self, PyObject *args)
2240 {
2241   PyObject *py_g;
2242   guestfs_h *g;
2243   PyObject *py_r;
2244   struct guestfs_stat *r;
2245   const char *path;
2246
2247   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
2248                          &py_g, &path))
2249     return NULL;
2250   g = get_handle (py_g);
2251
2252   r = guestfs_lstat (g, path);
2253   if (r == NULL) {
2254     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2255     return NULL;
2256   }
2257
2258   py_r = put_stat (r);
2259   free (r);
2260   return py_r;
2261 }
2262
2263 static PyObject *
2264 py_guestfs_statvfs (PyObject *self, PyObject *args)
2265 {
2266   PyObject *py_g;
2267   guestfs_h *g;
2268   PyObject *py_r;
2269   struct guestfs_statvfs *r;
2270   const char *path;
2271
2272   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
2273                          &py_g, &path))
2274     return NULL;
2275   g = get_handle (py_g);
2276
2277   r = guestfs_statvfs (g, path);
2278   if (r == NULL) {
2279     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2280     return NULL;
2281   }
2282
2283   py_r = put_statvfs (r);
2284   free (r);
2285   return py_r;
2286 }
2287
2288 static PyObject *
2289 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
2290 {
2291   PyObject *py_g;
2292   guestfs_h *g;
2293   PyObject *py_r;
2294   char **r;
2295   const char *device;
2296
2297   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
2298                          &py_g, &device))
2299     return NULL;
2300   g = get_handle (py_g);
2301
2302   r = guestfs_tune2fs_l (g, device);
2303   if (r == NULL) {
2304     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2305     return NULL;
2306   }
2307
2308   py_r = put_table (r);
2309   free_strings (r);
2310   return py_r;
2311 }
2312
2313 static PyObject *
2314 py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
2315 {
2316   PyObject *py_g;
2317   guestfs_h *g;
2318   PyObject *py_r;
2319   int r;
2320   const char *device;
2321
2322   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
2323                          &py_g, &device))
2324     return NULL;
2325   g = get_handle (py_g);
2326
2327   r = guestfs_blockdev_setro (g, device);
2328   if (r == -1) {
2329     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2330     return NULL;
2331   }
2332
2333   Py_INCREF (Py_None);
2334   py_r = Py_None;
2335   return py_r;
2336 }
2337
2338 static PyObject *
2339 py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
2340 {
2341   PyObject *py_g;
2342   guestfs_h *g;
2343   PyObject *py_r;
2344   int r;
2345   const char *device;
2346
2347   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
2348                          &py_g, &device))
2349     return NULL;
2350   g = get_handle (py_g);
2351
2352   r = guestfs_blockdev_setrw (g, device);
2353   if (r == -1) {
2354     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2355     return NULL;
2356   }
2357
2358   Py_INCREF (Py_None);
2359   py_r = Py_None;
2360   return py_r;
2361 }
2362
2363 static PyObject *
2364 py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
2365 {
2366   PyObject *py_g;
2367   guestfs_h *g;
2368   PyObject *py_r;
2369   int r;
2370   const char *device;
2371
2372   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
2373                          &py_g, &device))
2374     return NULL;
2375   g = get_handle (py_g);
2376
2377   r = guestfs_blockdev_getro (g, device);
2378   if (r == -1) {
2379     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2380     return NULL;
2381   }
2382
2383   py_r = PyInt_FromLong ((long) r);
2384   return py_r;
2385 }
2386
2387 static PyObject *
2388 py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
2389 {
2390   PyObject *py_g;
2391   guestfs_h *g;
2392   PyObject *py_r;
2393   int r;
2394   const char *device;
2395
2396   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
2397                          &py_g, &device))
2398     return NULL;
2399   g = get_handle (py_g);
2400
2401   r = guestfs_blockdev_getss (g, device);
2402   if (r == -1) {
2403     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2404     return NULL;
2405   }
2406
2407   py_r = PyInt_FromLong ((long) r);
2408   return py_r;
2409 }
2410
2411 static PyObject *
2412 py_guestfs_blockdev_getbsz (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_getbsz",
2421                          &py_g, &device))
2422     return NULL;
2423   g = get_handle (py_g);
2424
2425   r = guestfs_blockdev_getbsz (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_setbsz (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   int blocksize;
2444
2445   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
2446                          &py_g, &device, &blocksize))
2447     return NULL;
2448   g = get_handle (py_g);
2449
2450   r = guestfs_blockdev_setbsz (g, device, blocksize);
2451   if (r == -1) {
2452     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2453     return NULL;
2454   }
2455
2456   Py_INCREF (Py_None);
2457   py_r = Py_None;
2458   return py_r;
2459 }
2460
2461 static PyObject *
2462 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
2463 {
2464   PyObject *py_g;
2465   guestfs_h *g;
2466   PyObject *py_r;
2467   int64_t r;
2468   const char *device;
2469
2470   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
2471                          &py_g, &device))
2472     return NULL;
2473   g = get_handle (py_g);
2474
2475   r = guestfs_blockdev_getsz (g, device);
2476   if (r == -1) {
2477     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2478     return NULL;
2479   }
2480
2481   py_r = PyLong_FromLongLong (r);
2482   return py_r;
2483 }
2484
2485 static PyObject *
2486 py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
2487 {
2488   PyObject *py_g;
2489   guestfs_h *g;
2490   PyObject *py_r;
2491   int64_t r;
2492   const char *device;
2493
2494   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
2495                          &py_g, &device))
2496     return NULL;
2497   g = get_handle (py_g);
2498
2499   r = guestfs_blockdev_getsize64 (g, device);
2500   if (r == -1) {
2501     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2502     return NULL;
2503   }
2504
2505   py_r = PyLong_FromLongLong (r);
2506   return py_r;
2507 }
2508
2509 static PyObject *
2510 py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
2511 {
2512   PyObject *py_g;
2513   guestfs_h *g;
2514   PyObject *py_r;
2515   int r;
2516   const char *device;
2517
2518   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
2519                          &py_g, &device))
2520     return NULL;
2521   g = get_handle (py_g);
2522
2523   r = guestfs_blockdev_flushbufs (g, device);
2524   if (r == -1) {
2525     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2526     return NULL;
2527   }
2528
2529   Py_INCREF (Py_None);
2530   py_r = Py_None;
2531   return py_r;
2532 }
2533
2534 static PyObject *
2535 py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
2536 {
2537   PyObject *py_g;
2538   guestfs_h *g;
2539   PyObject *py_r;
2540   int r;
2541   const char *device;
2542
2543   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
2544                          &py_g, &device))
2545     return NULL;
2546   g = get_handle (py_g);
2547
2548   r = guestfs_blockdev_rereadpt (g, device);
2549   if (r == -1) {
2550     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2551     return NULL;
2552   }
2553
2554   Py_INCREF (Py_None);
2555   py_r = Py_None;
2556   return py_r;
2557 }
2558
2559 static PyObject *
2560 py_guestfs_upload (PyObject *self, PyObject *args)
2561 {
2562   PyObject *py_g;
2563   guestfs_h *g;
2564   PyObject *py_r;
2565   int r;
2566   const char *filename;
2567   const char *remotefilename;
2568
2569   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
2570                          &py_g, &filename, &remotefilename))
2571     return NULL;
2572   g = get_handle (py_g);
2573
2574   r = guestfs_upload (g, filename, remotefilename);
2575   if (r == -1) {
2576     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2577     return NULL;
2578   }
2579
2580   Py_INCREF (Py_None);
2581   py_r = Py_None;
2582   return py_r;
2583 }
2584
2585 static PyObject *
2586 py_guestfs_download (PyObject *self, PyObject *args)
2587 {
2588   PyObject *py_g;
2589   guestfs_h *g;
2590   PyObject *py_r;
2591   int r;
2592   const char *remotefilename;
2593   const char *filename;
2594
2595   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
2596                          &py_g, &remotefilename, &filename))
2597     return NULL;
2598   g = get_handle (py_g);
2599
2600   r = guestfs_download (g, remotefilename, filename);
2601   if (r == -1) {
2602     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2603     return NULL;
2604   }
2605
2606   Py_INCREF (Py_None);
2607   py_r = Py_None;
2608   return py_r;
2609 }
2610
2611 static PyObject *
2612 py_guestfs_checksum (PyObject *self, PyObject *args)
2613 {
2614   PyObject *py_g;
2615   guestfs_h *g;
2616   PyObject *py_r;
2617   char *r;
2618   const char *csumtype;
2619   const char *path;
2620
2621   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum",
2622                          &py_g, &csumtype, &path))
2623     return NULL;
2624   g = get_handle (py_g);
2625
2626   r = guestfs_checksum (g, csumtype, path);
2627   if (r == NULL) {
2628     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2629     return NULL;
2630   }
2631
2632   py_r = PyString_FromString (r);
2633   free (r);
2634   return py_r;
2635 }
2636
2637 static PyObject *
2638 py_guestfs_tar_in (PyObject *self, PyObject *args)
2639 {
2640   PyObject *py_g;
2641   guestfs_h *g;
2642   PyObject *py_r;
2643   int r;
2644   const char *tarfile;
2645   const char *directory;
2646
2647   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in",
2648                          &py_g, &tarfile, &directory))
2649     return NULL;
2650   g = get_handle (py_g);
2651
2652   r = guestfs_tar_in (g, tarfile, directory);
2653   if (r == -1) {
2654     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2655     return NULL;
2656   }
2657
2658   Py_INCREF (Py_None);
2659   py_r = Py_None;
2660   return py_r;
2661 }
2662
2663 static PyObject *
2664 py_guestfs_tar_out (PyObject *self, PyObject *args)
2665 {
2666   PyObject *py_g;
2667   guestfs_h *g;
2668   PyObject *py_r;
2669   int r;
2670   const char *directory;
2671   const char *tarfile;
2672
2673   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out",
2674                          &py_g, &directory, &tarfile))
2675     return NULL;
2676   g = get_handle (py_g);
2677
2678   r = guestfs_tar_out (g, directory, tarfile);
2679   if (r == -1) {
2680     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2681     return NULL;
2682   }
2683
2684   Py_INCREF (Py_None);
2685   py_r = Py_None;
2686   return py_r;
2687 }
2688
2689 static PyObject *
2690 py_guestfs_tgz_in (PyObject *self, PyObject *args)
2691 {
2692   PyObject *py_g;
2693   guestfs_h *g;
2694   PyObject *py_r;
2695   int r;
2696   const char *tarball;
2697   const char *directory;
2698
2699   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in",
2700                          &py_g, &tarball, &directory))
2701     return NULL;
2702   g = get_handle (py_g);
2703
2704   r = guestfs_tgz_in (g, tarball, directory);
2705   if (r == -1) {
2706     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2707     return NULL;
2708   }
2709
2710   Py_INCREF (Py_None);
2711   py_r = Py_None;
2712   return py_r;
2713 }
2714
2715 static PyObject *
2716 py_guestfs_tgz_out (PyObject *self, PyObject *args)
2717 {
2718   PyObject *py_g;
2719   guestfs_h *g;
2720   PyObject *py_r;
2721   int r;
2722   const char *directory;
2723   const char *tarball;
2724
2725   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out",
2726                          &py_g, &directory, &tarball))
2727     return NULL;
2728   g = get_handle (py_g);
2729
2730   r = guestfs_tgz_out (g, directory, tarball);
2731   if (r == -1) {
2732     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2733     return NULL;
2734   }
2735
2736   Py_INCREF (Py_None);
2737   py_r = Py_None;
2738   return py_r;
2739 }
2740
2741 static PyObject *
2742 py_guestfs_mount_ro (PyObject *self, PyObject *args)
2743 {
2744   PyObject *py_g;
2745   guestfs_h *g;
2746   PyObject *py_r;
2747   int r;
2748   const char *device;
2749   const char *mountpoint;
2750
2751   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro",
2752                          &py_g, &device, &mountpoint))
2753     return NULL;
2754   g = get_handle (py_g);
2755
2756   r = guestfs_mount_ro (g, device, mountpoint);
2757   if (r == -1) {
2758     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2759     return NULL;
2760   }
2761
2762   Py_INCREF (Py_None);
2763   py_r = Py_None;
2764   return py_r;
2765 }
2766
2767 static PyObject *
2768 py_guestfs_mount_options (PyObject *self, PyObject *args)
2769 {
2770   PyObject *py_g;
2771   guestfs_h *g;
2772   PyObject *py_r;
2773   int r;
2774   const char *options;
2775   const char *device;
2776   const char *mountpoint;
2777
2778   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options",
2779                          &py_g, &options, &device, &mountpoint))
2780     return NULL;
2781   g = get_handle (py_g);
2782
2783   r = guestfs_mount_options (g, options, device, mountpoint);
2784   if (r == -1) {
2785     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2786     return NULL;
2787   }
2788
2789   Py_INCREF (Py_None);
2790   py_r = Py_None;
2791   return py_r;
2792 }
2793
2794 static PyObject *
2795 py_guestfs_mount_vfs (PyObject *self, PyObject *args)
2796 {
2797   PyObject *py_g;
2798   guestfs_h *g;
2799   PyObject *py_r;
2800   int r;
2801   const char *options;
2802   const char *vfstype;
2803   const char *device;
2804   const char *mountpoint;
2805
2806   if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs",
2807                          &py_g, &options, &vfstype, &device, &mountpoint))
2808     return NULL;
2809   g = get_handle (py_g);
2810
2811   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2812   if (r == -1) {
2813     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2814     return NULL;
2815   }
2816
2817   Py_INCREF (Py_None);
2818   py_r = Py_None;
2819   return py_r;
2820 }
2821
2822 static PyObject *
2823 py_guestfs_debug (PyObject *self, PyObject *args)
2824 {
2825   PyObject *py_g;
2826   guestfs_h *g;
2827   PyObject *py_r;
2828   char *r;
2829   const char *subcmd;
2830   PyObject *py_extraargs;
2831   const char **extraargs;
2832
2833   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug",
2834                          &py_g, &subcmd, &py_extraargs))
2835     return NULL;
2836   g = get_handle (py_g);
2837   extraargs = get_string_list (py_extraargs);
2838   if (!extraargs) return NULL;
2839
2840   r = guestfs_debug (g, subcmd, extraargs);
2841   free (extraargs);
2842   if (r == NULL) {
2843     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2844     return NULL;
2845   }
2846
2847   py_r = PyString_FromString (r);
2848   free (r);
2849   return py_r;
2850 }
2851
2852 static PyObject *
2853 py_guestfs_lvremove (PyObject *self, PyObject *args)
2854 {
2855   PyObject *py_g;
2856   guestfs_h *g;
2857   PyObject *py_r;
2858   int r;
2859   const char *device;
2860
2861   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove",
2862                          &py_g, &device))
2863     return NULL;
2864   g = get_handle (py_g);
2865
2866   r = guestfs_lvremove (g, device);
2867   if (r == -1) {
2868     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2869     return NULL;
2870   }
2871
2872   Py_INCREF (Py_None);
2873   py_r = Py_None;
2874   return py_r;
2875 }
2876
2877 static PyObject *
2878 py_guestfs_vgremove (PyObject *self, PyObject *args)
2879 {
2880   PyObject *py_g;
2881   guestfs_h *g;
2882   PyObject *py_r;
2883   int r;
2884   const char *vgname;
2885
2886   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove",
2887                          &py_g, &vgname))
2888     return NULL;
2889   g = get_handle (py_g);
2890
2891   r = guestfs_vgremove (g, vgname);
2892   if (r == -1) {
2893     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2894     return NULL;
2895   }
2896
2897   Py_INCREF (Py_None);
2898   py_r = Py_None;
2899   return py_r;
2900 }
2901
2902 static PyObject *
2903 py_guestfs_pvremove (PyObject *self, PyObject *args)
2904 {
2905   PyObject *py_g;
2906   guestfs_h *g;
2907   PyObject *py_r;
2908   int r;
2909   const char *device;
2910
2911   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove",
2912                          &py_g, &device))
2913     return NULL;
2914   g = get_handle (py_g);
2915
2916   r = guestfs_pvremove (g, device);
2917   if (r == -1) {
2918     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2919     return NULL;
2920   }
2921
2922   Py_INCREF (Py_None);
2923   py_r = Py_None;
2924   return py_r;
2925 }
2926
2927 static PyObject *
2928 py_guestfs_set_e2label (PyObject *self, PyObject *args)
2929 {
2930   PyObject *py_g;
2931   guestfs_h *g;
2932   PyObject *py_r;
2933   int r;
2934   const char *device;
2935   const char *label;
2936
2937   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label",
2938                          &py_g, &device, &label))
2939     return NULL;
2940   g = get_handle (py_g);
2941
2942   r = guestfs_set_e2label (g, device, label);
2943   if (r == -1) {
2944     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2945     return NULL;
2946   }
2947
2948   Py_INCREF (Py_None);
2949   py_r = Py_None;
2950   return py_r;
2951 }
2952
2953 static PyObject *
2954 py_guestfs_get_e2label (PyObject *self, PyObject *args)
2955 {
2956   PyObject *py_g;
2957   guestfs_h *g;
2958   PyObject *py_r;
2959   char *r;
2960   const char *device;
2961
2962   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label",
2963                          &py_g, &device))
2964     return NULL;
2965   g = get_handle (py_g);
2966
2967   r = guestfs_get_e2label (g, device);
2968   if (r == NULL) {
2969     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2970     return NULL;
2971   }
2972
2973   py_r = PyString_FromString (r);
2974   free (r);
2975   return py_r;
2976 }
2977
2978 static PyObject *
2979 py_guestfs_set_e2uuid (PyObject *self, PyObject *args)
2980 {
2981   PyObject *py_g;
2982   guestfs_h *g;
2983   PyObject *py_r;
2984   int r;
2985   const char *device;
2986   const char *uuid;
2987
2988   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid",
2989                          &py_g, &device, &uuid))
2990     return NULL;
2991   g = get_handle (py_g);
2992
2993   r = guestfs_set_e2uuid (g, device, uuid);
2994   if (r == -1) {
2995     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2996     return NULL;
2997   }
2998
2999   Py_INCREF (Py_None);
3000   py_r = Py_None;
3001   return py_r;
3002 }
3003
3004 static PyObject *
3005 py_guestfs_get_e2uuid (PyObject *self, PyObject *args)
3006 {
3007   PyObject *py_g;
3008   guestfs_h *g;
3009   PyObject *py_r;
3010   char *r;
3011   const char *device;
3012
3013   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid",
3014                          &py_g, &device))
3015     return NULL;
3016   g = get_handle (py_g);
3017
3018   r = guestfs_get_e2uuid (g, device);
3019   if (r == NULL) {
3020     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3021     return NULL;
3022   }
3023
3024   py_r = PyString_FromString (r);
3025   free (r);
3026   return py_r;
3027 }
3028
3029 static PyObject *
3030 py_guestfs_fsck (PyObject *self, PyObject *args)
3031 {
3032   PyObject *py_g;
3033   guestfs_h *g;
3034   PyObject *py_r;
3035   int r;
3036   const char *fstype;
3037   const char *device;
3038
3039   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck",
3040                          &py_g, &fstype, &device))
3041     return NULL;
3042   g = get_handle (py_g);
3043
3044   r = guestfs_fsck (g, fstype, device);
3045   if (r == -1) {
3046     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3047     return NULL;
3048   }
3049
3050   py_r = PyInt_FromLong ((long) r);
3051   return py_r;
3052 }
3053
3054 static PyObject *
3055 py_guestfs_zero (PyObject *self, PyObject *args)
3056 {
3057   PyObject *py_g;
3058   guestfs_h *g;
3059   PyObject *py_r;
3060   int r;
3061   const char *device;
3062
3063   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero",
3064                          &py_g, &device))
3065     return NULL;
3066   g = get_handle (py_g);
3067
3068   r = guestfs_zero (g, device);
3069   if (r == -1) {
3070     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3071     return NULL;
3072   }
3073
3074   Py_INCREF (Py_None);
3075   py_r = Py_None;
3076   return py_r;
3077 }
3078
3079 static PyObject *
3080 py_guestfs_grub_install (PyObject *self, PyObject *args)
3081 {
3082   PyObject *py_g;
3083   guestfs_h *g;
3084   PyObject *py_r;
3085   int r;
3086   const char *root;
3087   const char *device;
3088
3089   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install",
3090                          &py_g, &root, &device))
3091     return NULL;
3092   g = get_handle (py_g);
3093
3094   r = guestfs_grub_install (g, root, device);
3095   if (r == -1) {
3096     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3097     return NULL;
3098   }
3099
3100   Py_INCREF (Py_None);
3101   py_r = Py_None;
3102   return py_r;
3103 }
3104
3105 static PyObject *
3106 py_guestfs_cp (PyObject *self, PyObject *args)
3107 {
3108   PyObject *py_g;
3109   guestfs_h *g;
3110   PyObject *py_r;
3111   int r;
3112   const char *src;
3113   const char *dest;
3114
3115   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp",
3116                          &py_g, &src, &dest))
3117     return NULL;
3118   g = get_handle (py_g);
3119
3120   r = guestfs_cp (g, src, dest);
3121   if (r == -1) {
3122     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3123     return NULL;
3124   }
3125
3126   Py_INCREF (Py_None);
3127   py_r = Py_None;
3128   return py_r;
3129 }
3130
3131 static PyObject *
3132 py_guestfs_cp_a (PyObject *self, PyObject *args)
3133 {
3134   PyObject *py_g;
3135   guestfs_h *g;
3136   PyObject *py_r;
3137   int r;
3138   const char *src;
3139   const char *dest;
3140
3141   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a",
3142                          &py_g, &src, &dest))
3143     return NULL;
3144   g = get_handle (py_g);
3145
3146   r = guestfs_cp_a (g, src, dest);
3147   if (r == -1) {
3148     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3149     return NULL;
3150   }
3151
3152   Py_INCREF (Py_None);
3153   py_r = Py_None;
3154   return py_r;
3155 }
3156
3157 static PyObject *
3158 py_guestfs_mv (PyObject *self, PyObject *args)
3159 {
3160   PyObject *py_g;
3161   guestfs_h *g;
3162   PyObject *py_r;
3163   int r;
3164   const char *src;
3165   const char *dest;
3166
3167   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv",
3168                          &py_g, &src, &dest))
3169     return NULL;
3170   g = get_handle (py_g);
3171
3172   r = guestfs_mv (g, src, dest);
3173   if (r == -1) {
3174     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3175     return NULL;
3176   }
3177
3178   Py_INCREF (Py_None);
3179   py_r = Py_None;
3180   return py_r;
3181 }
3182
3183 static PyObject *
3184 py_guestfs_drop_caches (PyObject *self, PyObject *args)
3185 {
3186   PyObject *py_g;
3187   guestfs_h *g;
3188   PyObject *py_r;
3189   int r;
3190   int whattodrop;
3191
3192   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches",
3193                          &py_g, &whattodrop))
3194     return NULL;
3195   g = get_handle (py_g);
3196
3197   r = guestfs_drop_caches (g, whattodrop);
3198   if (r == -1) {
3199     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3200     return NULL;
3201   }
3202
3203   Py_INCREF (Py_None);
3204   py_r = Py_None;
3205   return py_r;
3206 }
3207
3208 static PyObject *
3209 py_guestfs_dmesg (PyObject *self, PyObject *args)
3210 {
3211   PyObject *py_g;
3212   guestfs_h *g;
3213   PyObject *py_r;
3214   char *r;
3215
3216   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_dmesg",
3217                          &py_g))
3218     return NULL;
3219   g = get_handle (py_g);
3220
3221   r = guestfs_dmesg (g);
3222   if (r == NULL) {
3223     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3224     return NULL;
3225   }
3226
3227   py_r = PyString_FromString (r);
3228   free (r);
3229   return py_r;
3230 }
3231
3232 static PyObject *
3233 py_guestfs_ping_daemon (PyObject *self, PyObject *args)
3234 {
3235   PyObject *py_g;
3236   guestfs_h *g;
3237   PyObject *py_r;
3238   int r;
3239
3240   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_ping_daemon",
3241                          &py_g))
3242     return NULL;
3243   g = get_handle (py_g);
3244
3245   r = guestfs_ping_daemon (g);
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_equal (PyObject *self, PyObject *args)
3258 {
3259   PyObject *py_g;
3260   guestfs_h *g;
3261   PyObject *py_r;
3262   int r;
3263   const char *file1;
3264   const char *file2;
3265
3266   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_equal",
3267                          &py_g, &file1, &file2))
3268     return NULL;
3269   g = get_handle (py_g);
3270
3271   r = guestfs_equal (g, file1, file2);
3272   if (r == -1) {
3273     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3274     return NULL;
3275   }
3276
3277   py_r = PyInt_FromLong ((long) r);
3278   return py_r;
3279 }
3280
3281 static PyObject *
3282 py_guestfs_strings (PyObject *self, PyObject *args)
3283 {
3284   PyObject *py_g;
3285   guestfs_h *g;
3286   PyObject *py_r;
3287   char **r;
3288   const char *path;
3289
3290   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_strings",
3291                          &py_g, &path))
3292     return NULL;
3293   g = get_handle (py_g);
3294
3295   r = guestfs_strings (g, path);
3296   if (r == NULL) {
3297     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3298     return NULL;
3299   }
3300
3301   py_r = put_string_list (r);
3302   free_strings (r);
3303   return py_r;
3304 }
3305
3306 static PyObject *
3307 py_guestfs_strings_e (PyObject *self, PyObject *args)
3308 {
3309   PyObject *py_g;
3310   guestfs_h *g;
3311   PyObject *py_r;
3312   char **r;
3313   const char *encoding;
3314   const char *path;
3315
3316   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_strings_e",
3317                          &py_g, &encoding, &path))
3318     return NULL;
3319   g = get_handle (py_g);
3320
3321   r = guestfs_strings_e (g, encoding, path);
3322   if (r == NULL) {
3323     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3324     return NULL;
3325   }
3326
3327   py_r = put_string_list (r);
3328   free_strings (r);
3329   return py_r;
3330 }
3331
3332 static PyObject *
3333 py_guestfs_hexdump (PyObject *self, PyObject *args)
3334 {
3335   PyObject *py_g;
3336   guestfs_h *g;
3337   PyObject *py_r;
3338   char *r;
3339   const char *path;
3340
3341   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_hexdump",
3342                          &py_g, &path))
3343     return NULL;
3344   g = get_handle (py_g);
3345
3346   r = guestfs_hexdump (g, path);
3347   if (r == NULL) {
3348     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3349     return NULL;
3350   }
3351
3352   py_r = PyString_FromString (r);
3353   free (r);
3354   return py_r;
3355 }
3356
3357 static PyMethodDef methods[] = {
3358   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
3359   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
3360   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
3361   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
3362   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
3363   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
3364   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
3365   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
3366   { (char *) "set_qemu", py_guestfs_set_qemu, METH_VARARGS, NULL },
3367   { (char *) "get_qemu", py_guestfs_get_qemu, METH_VARARGS, NULL },
3368   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
3369   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
3370   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
3371   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
3372   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
3373   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
3374   { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
3375   { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
3376   { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
3377   { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
3378   { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
3379   { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL },
3380   { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL },
3381   { (char *) "end_busy", py_guestfs_end_busy, METH_VARARGS, NULL },
3382   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
3383   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
3384   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
3385   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
3386   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
3387   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
3388   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
3389   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
3390   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
3391   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
3392   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
3393   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
3394   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
3395   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
3396   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
3397   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
3398   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
3399   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
3400   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
3401   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
3402   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
3403   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
3404   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
3405   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
3406   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
3407   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
3408   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
3409   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
3410   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
3411   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
3412   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
3413   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
3414   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
3415   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
3416   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
3417   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
3418   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
3419   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
3420   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
3421   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
3422   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
3423   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
3424   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
3425   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
3426   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
3427   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
3428   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
3429   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
3430   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
3431   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
3432   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
3433   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
3434   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
3435   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
3436   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
3437   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
3438   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
3439   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
3440   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
3441   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
3442   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
3443   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
3444   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
3445   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
3446   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
3447   { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
3448   { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
3449   { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL },
3450   { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL },
3451   { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL },
3452   { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL },
3453   { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL },
3454   { (char *) "mount_ro", py_guestfs_mount_ro, METH_VARARGS, NULL },
3455   { (char *) "mount_options", py_guestfs_mount_options, METH_VARARGS, NULL },
3456   { (char *) "mount_vfs", py_guestfs_mount_vfs, METH_VARARGS, NULL },
3457   { (char *) "debug", py_guestfs_debug, METH_VARARGS, NULL },
3458   { (char *) "lvremove", py_guestfs_lvremove, METH_VARARGS, NULL },
3459   { (char *) "vgremove", py_guestfs_vgremove, METH_VARARGS, NULL },
3460   { (char *) "pvremove", py_guestfs_pvremove, METH_VARARGS, NULL },
3461   { (char *) "set_e2label", py_guestfs_set_e2label, METH_VARARGS, NULL },
3462   { (char *) "get_e2label", py_guestfs_get_e2label, METH_VARARGS, NULL },
3463   { (char *) "set_e2uuid", py_guestfs_set_e2uuid, METH_VARARGS, NULL },
3464   { (char *) "get_e2uuid", py_guestfs_get_e2uuid, METH_VARARGS, NULL },
3465   { (char *) "fsck", py_guestfs_fsck, METH_VARARGS, NULL },
3466   { (char *) "zero", py_guestfs_zero, METH_VARARGS, NULL },
3467   { (char *) "grub_install", py_guestfs_grub_install, METH_VARARGS, NULL },
3468   { (char *) "cp", py_guestfs_cp, METH_VARARGS, NULL },
3469   { (char *) "cp_a", py_guestfs_cp_a, METH_VARARGS, NULL },
3470   { (char *) "mv", py_guestfs_mv, METH_VARARGS, NULL },
3471   { (char *) "drop_caches", py_guestfs_drop_caches, METH_VARARGS, NULL },
3472   { (char *) "dmesg", py_guestfs_dmesg, METH_VARARGS, NULL },
3473   { (char *) "ping_daemon", py_guestfs_ping_daemon, METH_VARARGS, NULL },
3474   { (char *) "equal", py_guestfs_equal, METH_VARARGS, NULL },
3475   { (char *) "strings", py_guestfs_strings, METH_VARARGS, NULL },
3476   { (char *) "strings_e", py_guestfs_strings_e, METH_VARARGS, NULL },
3477   { (char *) "hexdump", py_guestfs_hexdump, METH_VARARGS, NULL },
3478   { NULL, NULL, 0, NULL }
3479 };
3480
3481 void
3482 initlibguestfsmod (void)
3483 {
3484   static int initialized = 0;
3485
3486   if (initialized) return;
3487   Py_InitModule ((char *) "libguestfsmod", methods);
3488   initialized = 1;
3489 }