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_mount (PyObject *self, PyObject *args)
 896 {
 897   PyObject *py_g;
 898   guestfs_h *g;
 899   PyObject *py_r;
 900   int r;
 901   const char *device;
 902   const char *mountpoint;
 903
 904   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
 905                          &py_g, &device, &mountpoint))
 906     return NULL;
 907   g = get_handle (py_g);
 908
 909   r = guestfs_mount (g, device, mountpoint);
 910   if (r == -1) {
 911     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 912     return NULL;
 913   }
 914
 915   Py_INCREF (Py_None);
 916   py_r = Py_None;
 917   return py_r;
 918 }
 919
 920 static PyObject *
 921 py_guestfs_sync (PyObject *self, PyObject *args)
 922 {
 923   PyObject *py_g;
 924   guestfs_h *g;
 925   PyObject *py_r;
 926   int r;
 927
 928   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
 929                          &py_g))
 930     return NULL;
 931   g = get_handle (py_g);
 932
 933   r = guestfs_sync (g);
 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_touch (PyObject *self, PyObject *args)
 946 {
 947   PyObject *py_g;
 948   guestfs_h *g;
 949   PyObject *py_r;
 950   int r;
 951   const char *path;
 952
 953   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
 954                          &py_g, &path))
 955     return NULL;
 956   g = get_handle (py_g);
 957
 958   r = guestfs_touch (g, path);
 959   if (r == -1) {
 960     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 961     return NULL;
 962   }
 963
 964   Py_INCREF (Py_None);
 965   py_r = Py_None;
 966   return py_r;
 967 }
 968
 969 static PyObject *
 970 py_guestfs_cat (PyObject *self, PyObject *args)
 971 {
 972   PyObject *py_g;
 973   guestfs_h *g;
 974   PyObject *py_r;
 975   char *r;
 976   const char *path;
 977
 978   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
 979                          &py_g, &path))
 980     return NULL;
 981   g = get_handle (py_g);
 982
 983   r = guestfs_cat (g, path);
 984   if (r == NULL) {
 985     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 986     return NULL;
 987   }
 988
 989   py_r = PyString_FromString (r);
 990   free (r);
 991   return py_r;
 992 }
 993
 994 static PyObject *
 995 py_guestfs_ll (PyObject *self, PyObject *args)
 996 {
 997   PyObject *py_g;
 998   guestfs_h *g;
 999   PyObject *py_r;
1000   char *r;
1001   const char *directory;
1002
1003   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
1004                          &py_g, &directory))
1005     return NULL;
1006   g = get_handle (py_g);
1007
1008   r = guestfs_ll (g, directory);
1009   if (r == NULL) {
1010     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1011     return NULL;
1012   }
1013
1014   py_r = PyString_FromString (r);
1015   free (r);
1016   return py_r;
1017 }
1018
1019 static PyObject *
1020 py_guestfs_ls (PyObject *self, PyObject *args)
1021 {
1022   PyObject *py_g;
1023   guestfs_h *g;
1024   PyObject *py_r;
1025   char **r;
1026   const char *directory;
1027
1028   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
1029                          &py_g, &directory))
1030     return NULL;
1031   g = get_handle (py_g);
1032
1033   r = guestfs_ls (g, directory);
1034   if (r == NULL) {
1035     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1036     return NULL;
1037   }
1038
1039   py_r = put_string_list (r);
1040   free_strings (r);
1041   return py_r;
1042 }
1043
1044 static PyObject *
1045 py_guestfs_list_devices (PyObject *self, PyObject *args)
1046 {
1047   PyObject *py_g;
1048   guestfs_h *g;
1049   PyObject *py_r;
1050   char **r;
1051
1052   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
1053                          &py_g))
1054     return NULL;
1055   g = get_handle (py_g);
1056
1057   r = guestfs_list_devices (g);
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_partitions (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_partitions",
1077                          &py_g))
1078     return NULL;
1079   g = get_handle (py_g);
1080
1081   r = guestfs_list_partitions (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_pvs (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_pvs",
1101                          &py_g))
1102     return NULL;
1103   g = get_handle (py_g);
1104
1105   r = guestfs_pvs (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_vgs (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_vgs",
1125                          &py_g))
1126     return NULL;
1127   g = get_handle (py_g);
1128
1129   r = guestfs_vgs (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_lvs (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_lvs",
1149                          &py_g))
1150     return NULL;
1151   g = get_handle (py_g);
1152
1153   r = guestfs_lvs (g);
1154   if (r == NULL) {
1155     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1156     return NULL;
1157   }
1158
1159   py_r = put_string_list (r);
1160   free_strings (r);
1161   return py_r;
1162 }
1163
1164 static PyObject *
1165 py_guestfs_pvs_full (PyObject *self, PyObject *args)
1166 {
1167   PyObject *py_g;
1168   guestfs_h *g;
1169   PyObject *py_r;
1170   struct guestfs_lvm_pv_list *r;
1171
1172   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
1173                          &py_g))
1174     return NULL;
1175   g = get_handle (py_g);
1176
1177   r = guestfs_pvs_full (g);
1178   if (r == NULL) {
1179     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1180     return NULL;
1181   }
1182
1183   py_r = put_lvm_pv_list (r);
1184   guestfs_free_lvm_pv_list (r);
1185   return py_r;
1186 }
1187
1188 static PyObject *
1189 py_guestfs_vgs_full (PyObject *self, PyObject *args)
1190 {
1191   PyObject *py_g;
1192   guestfs_h *g;
1193   PyObject *py_r;
1194   struct guestfs_lvm_vg_list *r;
1195
1196   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
1197                          &py_g))
1198     return NULL;
1199   g = get_handle (py_g);
1200
1201   r = guestfs_vgs_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_vg_list (r);
1208   guestfs_free_lvm_vg_list (r);
1209   return py_r;
1210 }
1211
1212 static PyObject *
1213 py_guestfs_lvs_full (PyObject *self, PyObject *args)
1214 {
1215   PyObject *py_g;
1216   guestfs_h *g;
1217   PyObject *py_r;
1218   struct guestfs_lvm_lv_list *r;
1219
1220   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
1221                          &py_g))
1222     return NULL;
1223   g = get_handle (py_g);
1224
1225   r = guestfs_lvs_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_lv_list (r);
1232   guestfs_free_lvm_lv_list (r);
1233   return py_r;
1234 }
1235
1236 static PyObject *
1237 py_guestfs_read_lines (PyObject *self, PyObject *args)
1238 {
1239   PyObject *py_g;
1240   guestfs_h *g;
1241   PyObject *py_r;
1242   char **r;
1243   const char *path;
1244
1245   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
1246                          &py_g, &path))
1247     return NULL;
1248   g = get_handle (py_g);
1249
1250   r = guestfs_read_lines (g, path);
1251   if (r == NULL) {
1252     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1253     return NULL;
1254   }
1255
1256   py_r = put_string_list (r);
1257   free_strings (r);
1258   return py_r;
1259 }
1260
1261 static PyObject *
1262 py_guestfs_aug_init (PyObject *self, PyObject *args)
1263 {
1264   PyObject *py_g;
1265   guestfs_h *g;
1266   PyObject *py_r;
1267   int r;
1268   const char *root;
1269   int flags;
1270
1271   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
1272                          &py_g, &root, &flags))
1273     return NULL;
1274   g = get_handle (py_g);
1275
1276   r = guestfs_aug_init (g, root, flags);
1277   if (r == -1) {
1278     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1279     return NULL;
1280   }
1281
1282   Py_INCREF (Py_None);
1283   py_r = Py_None;
1284   return py_r;
1285 }
1286
1287 static PyObject *
1288 py_guestfs_aug_close (PyObject *self, PyObject *args)
1289 {
1290   PyObject *py_g;
1291   guestfs_h *g;
1292   PyObject *py_r;
1293   int r;
1294
1295   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
1296                          &py_g))
1297     return NULL;
1298   g = get_handle (py_g);
1299
1300   r = guestfs_aug_close (g);
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_defvar (PyObject *self, PyObject *args)
1313 {
1314   PyObject *py_g;
1315   guestfs_h *g;
1316   PyObject *py_r;
1317   int r;
1318   const char *name;
1319   const char *expr;
1320
1321   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
1322                          &py_g, &name, &expr))
1323     return NULL;
1324   g = get_handle (py_g);
1325
1326   r = guestfs_aug_defvar (g, name, expr);
1327   if (r == -1) {
1328     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1329     return NULL;
1330   }
1331
1332   py_r = PyInt_FromLong ((long) r);
1333   return py_r;
1334 }
1335
1336 static PyObject *
1337 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
1338 {
1339   PyObject *py_g;
1340   guestfs_h *g;
1341   PyObject *py_r;
1342   struct guestfs_int_bool *r;
1343   const char *name;
1344   const char *expr;
1345   const char *val;
1346
1347   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
1348                          &py_g, &name, &expr, &val))
1349     return NULL;
1350   g = get_handle (py_g);
1351
1352   r = guestfs_aug_defnode (g, name, expr, val);
1353   if (r == NULL) {
1354     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1355     return NULL;
1356   }
1357
1358   py_r = PyTuple_New (2);
1359   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
1360   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
1361   guestfs_free_int_bool (r);
1362   return py_r;
1363 }
1364
1365 static PyObject *
1366 py_guestfs_aug_get (PyObject *self, PyObject *args)
1367 {
1368   PyObject *py_g;
1369   guestfs_h *g;
1370   PyObject *py_r;
1371   char *r;
1372   const char *path;
1373
1374   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
1375                          &py_g, &path))
1376     return NULL;
1377   g = get_handle (py_g);
1378
1379   r = guestfs_aug_get (g, path);
1380   if (r == NULL) {
1381     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1382     return NULL;
1383   }
1384
1385   py_r = PyString_FromString (r);
1386   free (r);
1387   return py_r;
1388 }
1389
1390 static PyObject *
1391 py_guestfs_aug_set (PyObject *self, PyObject *args)
1392 {
1393   PyObject *py_g;
1394   guestfs_h *g;
1395   PyObject *py_r;
1396   int r;
1397   const char *path;
1398   const char *val;
1399
1400   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
1401                          &py_g, &path, &val))
1402     return NULL;
1403   g = get_handle (py_g);
1404
1405   r = guestfs_aug_set (g, path, val);
1406   if (r == -1) {
1407     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1408     return NULL;
1409   }
1410
1411   Py_INCREF (Py_None);
1412   py_r = Py_None;
1413   return py_r;
1414 }
1415
1416 static PyObject *
1417 py_guestfs_aug_insert (PyObject *self, PyObject *args)
1418 {
1419   PyObject *py_g;
1420   guestfs_h *g;
1421   PyObject *py_r;
1422   int r;
1423   const char *path;
1424   const char *label;
1425   int before;
1426
1427   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
1428                          &py_g, &path, &label, &before))
1429     return NULL;
1430   g = get_handle (py_g);
1431
1432   r = guestfs_aug_insert (g, path, label, before);
1433   if (r == -1) {
1434     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1435     return NULL;
1436   }
1437
1438   Py_INCREF (Py_None);
1439   py_r = Py_None;
1440   return py_r;
1441 }
1442
1443 static PyObject *
1444 py_guestfs_aug_rm (PyObject *self, PyObject *args)
1445 {
1446   PyObject *py_g;
1447   guestfs_h *g;
1448   PyObject *py_r;
1449   int r;
1450   const char *path;
1451
1452   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
1453                          &py_g, &path))
1454     return NULL;
1455   g = get_handle (py_g);
1456
1457   r = guestfs_aug_rm (g, path);
1458   if (r == -1) {
1459     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1460     return NULL;
1461   }
1462
1463   py_r = PyInt_FromLong ((long) r);
1464   return py_r;
1465 }
1466
1467 static PyObject *
1468 py_guestfs_aug_mv (PyObject *self, PyObject *args)
1469 {
1470   PyObject *py_g;
1471   guestfs_h *g;
1472   PyObject *py_r;
1473   int r;
1474   const char *src;
1475   const char *dest;
1476
1477   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
1478                          &py_g, &src, &dest))
1479     return NULL;
1480   g = get_handle (py_g);
1481
1482   r = guestfs_aug_mv (g, src, dest);
1483   if (r == -1) {
1484     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1485     return NULL;
1486   }
1487
1488   Py_INCREF (Py_None);
1489   py_r = Py_None;
1490   return py_r;
1491 }
1492
1493 static PyObject *
1494 py_guestfs_aug_match (PyObject *self, PyObject *args)
1495 {
1496   PyObject *py_g;
1497   guestfs_h *g;
1498   PyObject *py_r;
1499   char **r;
1500   const char *path;
1501
1502   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
1503                          &py_g, &path))
1504     return NULL;
1505   g = get_handle (py_g);
1506
1507   r = guestfs_aug_match (g, path);
1508   if (r == NULL) {
1509     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1510     return NULL;
1511   }
1512
1513   py_r = put_string_list (r);
1514   free_strings (r);
1515   return py_r;
1516 }
1517
1518 static PyObject *
1519 py_guestfs_aug_save (PyObject *self, PyObject *args)
1520 {
1521   PyObject *py_g;
1522   guestfs_h *g;
1523   PyObject *py_r;
1524   int r;
1525
1526   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
1527                          &py_g))
1528     return NULL;
1529   g = get_handle (py_g);
1530
1531   r = guestfs_aug_save (g);
1532   if (r == -1) {
1533     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1534     return NULL;
1535   }
1536
1537   Py_INCREF (Py_None);
1538   py_r = Py_None;
1539   return py_r;
1540 }
1541
1542 static PyObject *
1543 py_guestfs_aug_load (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_load",
1551                          &py_g))
1552     return NULL;
1553   g = get_handle (py_g);
1554
1555   r = guestfs_aug_load (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_ls (PyObject *self, PyObject *args)
1568 {
1569   PyObject *py_g;
1570   guestfs_h *g;
1571   PyObject *py_r;
1572   char **r;
1573   const char *path;
1574
1575   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
1576                          &py_g, &path))
1577     return NULL;
1578   g = get_handle (py_g);
1579
1580   r = guestfs_aug_ls (g, path);
1581   if (r == NULL) {
1582     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1583     return NULL;
1584   }
1585
1586   py_r = put_string_list (r);
1587   free_strings (r);
1588   return py_r;
1589 }
1590
1591 static PyObject *
1592 py_guestfs_rm (PyObject *self, PyObject *args)
1593 {
1594   PyObject *py_g;
1595   guestfs_h *g;
1596   PyObject *py_r;
1597   int r;
1598   const char *path;
1599
1600   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
1601                          &py_g, &path))
1602     return NULL;
1603   g = get_handle (py_g);
1604
1605   r = guestfs_rm (g, path);
1606   if (r == -1) {
1607     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1608     return NULL;
1609   }
1610
1611   Py_INCREF (Py_None);
1612   py_r = Py_None;
1613   return py_r;
1614 }
1615
1616 static PyObject *
1617 py_guestfs_rmdir (PyObject *self, PyObject *args)
1618 {
1619   PyObject *py_g;
1620   guestfs_h *g;
1621   PyObject *py_r;
1622   int r;
1623   const char *path;
1624
1625   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
1626                          &py_g, &path))
1627     return NULL;
1628   g = get_handle (py_g);
1629
1630   r = guestfs_rmdir (g, path);
1631   if (r == -1) {
1632     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1633     return NULL;
1634   }
1635
1636   Py_INCREF (Py_None);
1637   py_r = Py_None;
1638   return py_r;
1639 }
1640
1641 static PyObject *
1642 py_guestfs_rm_rf (PyObject *self, PyObject *args)
1643 {
1644   PyObject *py_g;
1645   guestfs_h *g;
1646   PyObject *py_r;
1647   int r;
1648   const char *path;
1649
1650   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
1651                          &py_g, &path))
1652     return NULL;
1653   g = get_handle (py_g);
1654
1655   r = guestfs_rm_rf (g, path);
1656   if (r == -1) {
1657     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1658     return NULL;
1659   }
1660
1661   Py_INCREF (Py_None);
1662   py_r = Py_None;
1663   return py_r;
1664 }
1665
1666 static PyObject *
1667 py_guestfs_mkdir (PyObject *self, PyObject *args)
1668 {
1669   PyObject *py_g;
1670   guestfs_h *g;
1671   PyObject *py_r;
1672   int r;
1673   const char *path;
1674
1675   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
1676                          &py_g, &path))
1677     return NULL;
1678   g = get_handle (py_g);
1679
1680   r = guestfs_mkdir (g, path);
1681   if (r == -1) {
1682     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1683     return NULL;
1684   }
1685
1686   Py_INCREF (Py_None);
1687   py_r = Py_None;
1688   return py_r;
1689 }
1690
1691 static PyObject *
1692 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
1693 {
1694   PyObject *py_g;
1695   guestfs_h *g;
1696   PyObject *py_r;
1697   int r;
1698   const char *path;
1699
1700   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
1701                          &py_g, &path))
1702     return NULL;
1703   g = get_handle (py_g);
1704
1705   r = guestfs_mkdir_p (g, path);
1706   if (r == -1) {
1707     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1708     return NULL;
1709   }
1710
1711   Py_INCREF (Py_None);
1712   py_r = Py_None;
1713   return py_r;
1714 }
1715
1716 static PyObject *
1717 py_guestfs_chmod (PyObject *self, PyObject *args)
1718 {
1719   PyObject *py_g;
1720   guestfs_h *g;
1721   PyObject *py_r;
1722   int r;
1723   int mode;
1724   const char *path;
1725
1726   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
1727                          &py_g, &mode, &path))
1728     return NULL;
1729   g = get_handle (py_g);
1730
1731   r = guestfs_chmod (g, mode, path);
1732   if (r == -1) {
1733     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1734     return NULL;
1735   }
1736
1737   Py_INCREF (Py_None);
1738   py_r = Py_None;
1739   return py_r;
1740 }
1741
1742 static PyObject *
1743 py_guestfs_chown (PyObject *self, PyObject *args)
1744 {
1745   PyObject *py_g;
1746   guestfs_h *g;
1747   PyObject *py_r;
1748   int r;
1749   int owner;
1750   int group;
1751   const char *path;
1752
1753   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
1754                          &py_g, &owner, &group, &path))
1755     return NULL;
1756   g = get_handle (py_g);
1757
1758   r = guestfs_chown (g, owner, group, path);
1759   if (r == -1) {
1760     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1761     return NULL;
1762   }
1763
1764   Py_INCREF (Py_None);
1765   py_r = Py_None;
1766   return py_r;
1767 }
1768
1769 static PyObject *
1770 py_guestfs_exists (PyObject *self, PyObject *args)
1771 {
1772   PyObject *py_g;
1773   guestfs_h *g;
1774   PyObject *py_r;
1775   int r;
1776   const char *path;
1777
1778   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
1779                          &py_g, &path))
1780     return NULL;
1781   g = get_handle (py_g);
1782
1783   r = guestfs_exists (g, path);
1784   if (r == -1) {
1785     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1786     return NULL;
1787   }
1788
1789   py_r = PyInt_FromLong ((long) r);
1790   return py_r;
1791 }
1792
1793 static PyObject *
1794 py_guestfs_is_file (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_is_file",
1803                          &py_g, &path))
1804     return NULL;
1805   g = get_handle (py_g);
1806
1807   r = guestfs_is_file (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_dir (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_dir",
1827                          &py_g, &path))
1828     return NULL;
1829   g = get_handle (py_g);
1830
1831   r = guestfs_is_dir (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_pvcreate (PyObject *self, PyObject *args)
1843 {
1844   PyObject *py_g;
1845   guestfs_h *g;
1846   PyObject *py_r;
1847   int r;
1848   const char *device;
1849
1850   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
1851                          &py_g, &device))
1852     return NULL;
1853   g = get_handle (py_g);
1854
1855   r = guestfs_pvcreate (g, device);
1856   if (r == -1) {
1857     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1858     return NULL;
1859   }
1860
1861   Py_INCREF (Py_None);
1862   py_r = Py_None;
1863   return py_r;
1864 }
1865
1866 static PyObject *
1867 py_guestfs_vgcreate (PyObject *self, PyObject *args)
1868 {
1869   PyObject *py_g;
1870   guestfs_h *g;
1871   PyObject *py_r;
1872   int r;
1873   const char *volgroup;
1874   PyObject *py_physvols;
1875   const char **physvols;
1876
1877   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
1878                          &py_g, &volgroup, &py_physvols))
1879     return NULL;
1880   g = get_handle (py_g);
1881   physvols = get_string_list (py_physvols);
1882   if (!physvols) return NULL;
1883
1884   r = guestfs_vgcreate (g, volgroup, physvols);
1885   free (physvols);
1886   if (r == -1) {
1887     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1888     return NULL;
1889   }
1890
1891   Py_INCREF (Py_None);
1892   py_r = Py_None;
1893   return py_r;
1894 }
1895
1896 static PyObject *
1897 py_guestfs_lvcreate (PyObject *self, PyObject *args)
1898 {
1899   PyObject *py_g;
1900   guestfs_h *g;
1901   PyObject *py_r;
1902   int r;
1903   const char *logvol;
1904   const char *volgroup;
1905   int mbytes;
1906
1907   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
1908                          &py_g, &logvol, &volgroup, &mbytes))
1909     return NULL;
1910   g = get_handle (py_g);
1911
1912   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1913   if (r == -1) {
1914     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1915     return NULL;
1916   }
1917
1918   Py_INCREF (Py_None);
1919   py_r = Py_None;
1920   return py_r;
1921 }
1922
1923 static PyObject *
1924 py_guestfs_mkfs (PyObject *self, PyObject *args)
1925 {
1926   PyObject *py_g;
1927   guestfs_h *g;
1928   PyObject *py_r;
1929   int r;
1930   const char *fstype;
1931   const char *device;
1932
1933   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
1934                          &py_g, &fstype, &device))
1935     return NULL;
1936   g = get_handle (py_g);
1937
1938   r = guestfs_mkfs (g, fstype, device);
1939   if (r == -1) {
1940     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1941     return NULL;
1942   }
1943
1944   Py_INCREF (Py_None);
1945   py_r = Py_None;
1946   return py_r;
1947 }
1948
1949 static PyObject *
1950 py_guestfs_sfdisk (PyObject *self, PyObject *args)
1951 {
1952   PyObject *py_g;
1953   guestfs_h *g;
1954   PyObject *py_r;
1955   int r;
1956   const char *device;
1957   int cyls;
1958   int heads;
1959   int sectors;
1960   PyObject *py_lines;
1961   const char **lines;
1962
1963   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
1964                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
1965     return NULL;
1966   g = get_handle (py_g);
1967   lines = get_string_list (py_lines);
1968   if (!lines) return NULL;
1969
1970   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1971   free (lines);
1972   if (r == -1) {
1973     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1974     return NULL;
1975   }
1976
1977   Py_INCREF (Py_None);
1978   py_r = Py_None;
1979   return py_r;
1980 }
1981
1982 static PyObject *
1983 py_guestfs_write_file (PyObject *self, PyObject *args)
1984 {
1985   PyObject *py_g;
1986   guestfs_h *g;
1987   PyObject *py_r;
1988   int r;
1989   const char *path;
1990   const char *content;
1991   int size;
1992
1993   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
1994                          &py_g, &path, &content, &size))
1995     return NULL;
1996   g = get_handle (py_g);
1997
1998   r = guestfs_write_file (g, path, content, size);
1999   if (r == -1) {
2000     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2001     return NULL;
2002   }
2003
2004   Py_INCREF (Py_None);
2005   py_r = Py_None;
2006   return py_r;
2007 }
2008
2009 static PyObject *
2010 py_guestfs_umount (PyObject *self, PyObject *args)
2011 {
2012   PyObject *py_g;
2013   guestfs_h *g;
2014   PyObject *py_r;
2015   int r;
2016   const char *pathordevice;
2017
2018   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
2019                          &py_g, &pathordevice))
2020     return NULL;
2021   g = get_handle (py_g);
2022
2023   r = guestfs_umount (g, pathordevice);
2024   if (r == -1) {
2025     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2026     return NULL;
2027   }
2028
2029   Py_INCREF (Py_None);
2030   py_r = Py_None;
2031   return py_r;
2032 }
2033
2034 static PyObject *
2035 py_guestfs_mounts (PyObject *self, PyObject *args)
2036 {
2037   PyObject *py_g;
2038   guestfs_h *g;
2039   PyObject *py_r;
2040   char **r;
2041
2042   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
2043                          &py_g))
2044     return NULL;
2045   g = get_handle (py_g);
2046
2047   r = guestfs_mounts (g);
2048   if (r == NULL) {
2049     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2050     return NULL;
2051   }
2052
2053   py_r = put_string_list (r);
2054   free_strings (r);
2055   return py_r;
2056 }
2057
2058 static PyObject *
2059 py_guestfs_umount_all (PyObject *self, PyObject *args)
2060 {
2061   PyObject *py_g;
2062   guestfs_h *g;
2063   PyObject *py_r;
2064   int r;
2065
2066   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
2067                          &py_g))
2068     return NULL;
2069   g = get_handle (py_g);
2070
2071   r = guestfs_umount_all (g);
2072   if (r == -1) {
2073     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2074     return NULL;
2075   }
2076
2077   Py_INCREF (Py_None);
2078   py_r = Py_None;
2079   return py_r;
2080 }
2081
2082 static PyObject *
2083 py_guestfs_lvm_remove_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_lvm_remove_all",
2091                          &py_g))
2092     return NULL;
2093   g = get_handle (py_g);
2094
2095   r = guestfs_lvm_remove_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_file (PyObject *self, PyObject *args)
2108 {
2109   PyObject *py_g;
2110   guestfs_h *g;
2111   PyObject *py_r;
2112   char *r;
2113   const char *path;
2114
2115   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
2116                          &py_g, &path))
2117     return NULL;
2118   g = get_handle (py_g);
2119
2120   r = guestfs_file (g, path);
2121   if (r == NULL) {
2122     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2123     return NULL;
2124   }
2125
2126   py_r = PyString_FromString (r);
2127   free (r);
2128   return py_r;
2129 }
2130
2131 static PyObject *
2132 py_guestfs_command (PyObject *self, PyObject *args)
2133 {
2134   PyObject *py_g;
2135   guestfs_h *g;
2136   PyObject *py_r;
2137   char *r;
2138   PyObject *py_arguments;
2139   const char **arguments;
2140
2141   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
2142                          &py_g, &py_arguments))
2143     return NULL;
2144   g = get_handle (py_g);
2145   arguments = get_string_list (py_arguments);
2146   if (!arguments) return NULL;
2147
2148   r = guestfs_command (g, arguments);
2149   free (arguments);
2150   if (r == NULL) {
2151     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2152     return NULL;
2153   }
2154
2155   py_r = PyString_FromString (r);
2156   free (r);
2157   return py_r;
2158 }
2159
2160 static PyObject *
2161 py_guestfs_command_lines (PyObject *self, PyObject *args)
2162 {
2163   PyObject *py_g;
2164   guestfs_h *g;
2165   PyObject *py_r;
2166   char **r;
2167   PyObject *py_arguments;
2168   const char **arguments;
2169
2170   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
2171                          &py_g, &py_arguments))
2172     return NULL;
2173   g = get_handle (py_g);
2174   arguments = get_string_list (py_arguments);
2175   if (!arguments) return NULL;
2176
2177   r = guestfs_command_lines (g, arguments);
2178   free (arguments);
2179   if (r == NULL) {
2180     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2181     return NULL;
2182   }
2183
2184   py_r = put_string_list (r);
2185   free_strings (r);
2186   return py_r;
2187 }
2188
2189 static PyObject *
2190 py_guestfs_stat (PyObject *self, PyObject *args)
2191 {
2192   PyObject *py_g;
2193   guestfs_h *g;
2194   PyObject *py_r;
2195   struct guestfs_stat *r;
2196   const char *path;
2197
2198   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
2199                          &py_g, &path))
2200     return NULL;
2201   g = get_handle (py_g);
2202
2203   r = guestfs_stat (g, path);
2204   if (r == NULL) {
2205     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2206     return NULL;
2207   }
2208
2209   py_r = put_stat (r);
2210   free (r);
2211   return py_r;
2212 }
2213
2214 static PyObject *
2215 py_guestfs_lstat (PyObject *self, PyObject *args)
2216 {
2217   PyObject *py_g;
2218   guestfs_h *g;
2219   PyObject *py_r;
2220   struct guestfs_stat *r;
2221   const char *path;
2222
2223   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
2224                          &py_g, &path))
2225     return NULL;
2226   g = get_handle (py_g);
2227
2228   r = guestfs_lstat (g, path);
2229   if (r == NULL) {
2230     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2231     return NULL;
2232   }
2233
2234   py_r = put_stat (r);
2235   free (r);
2236   return py_r;
2237 }
2238
2239 static PyObject *
2240 py_guestfs_statvfs (PyObject *self, PyObject *args)
2241 {
2242   PyObject *py_g;
2243   guestfs_h *g;
2244   PyObject *py_r;
2245   struct guestfs_statvfs *r;
2246   const char *path;
2247
2248   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
2249                          &py_g, &path))
2250     return NULL;
2251   g = get_handle (py_g);
2252
2253   r = guestfs_statvfs (g, path);
2254   if (r == NULL) {
2255     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2256     return NULL;
2257   }
2258
2259   py_r = put_statvfs (r);
2260   free (r);
2261   return py_r;
2262 }
2263
2264 static PyObject *
2265 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
2266 {
2267   PyObject *py_g;
2268   guestfs_h *g;
2269   PyObject *py_r;
2270   char **r;
2271   const char *device;
2272
2273   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
2274                          &py_g, &device))
2275     return NULL;
2276   g = get_handle (py_g);
2277
2278   r = guestfs_tune2fs_l (g, device);
2279   if (r == NULL) {
2280     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2281     return NULL;
2282   }
2283
2284   py_r = put_table (r);
2285   free_strings (r);
2286   return py_r;
2287 }
2288
2289 static PyObject *
2290 py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
2291 {
2292   PyObject *py_g;
2293   guestfs_h *g;
2294   PyObject *py_r;
2295   int r;
2296   const char *device;
2297
2298   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
2299                          &py_g, &device))
2300     return NULL;
2301   g = get_handle (py_g);
2302
2303   r = guestfs_blockdev_setro (g, device);
2304   if (r == -1) {
2305     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2306     return NULL;
2307   }
2308
2309   Py_INCREF (Py_None);
2310   py_r = Py_None;
2311   return py_r;
2312 }
2313
2314 static PyObject *
2315 py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
2316 {
2317   PyObject *py_g;
2318   guestfs_h *g;
2319   PyObject *py_r;
2320   int r;
2321   const char *device;
2322
2323   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
2324                          &py_g, &device))
2325     return NULL;
2326   g = get_handle (py_g);
2327
2328   r = guestfs_blockdev_setrw (g, device);
2329   if (r == -1) {
2330     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2331     return NULL;
2332   }
2333
2334   Py_INCREF (Py_None);
2335   py_r = Py_None;
2336   return py_r;
2337 }
2338
2339 static PyObject *
2340 py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
2341 {
2342   PyObject *py_g;
2343   guestfs_h *g;
2344   PyObject *py_r;
2345   int r;
2346   const char *device;
2347
2348   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
2349                          &py_g, &device))
2350     return NULL;
2351   g = get_handle (py_g);
2352
2353   r = guestfs_blockdev_getro (g, device);
2354   if (r == -1) {
2355     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2356     return NULL;
2357   }
2358
2359   py_r = PyInt_FromLong ((long) r);
2360   return py_r;
2361 }
2362
2363 static PyObject *
2364 py_guestfs_blockdev_getss (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_getss",
2373                          &py_g, &device))
2374     return NULL;
2375   g = get_handle (py_g);
2376
2377   r = guestfs_blockdev_getss (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_getbsz (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_getbsz",
2397                          &py_g, &device))
2398     return NULL;
2399   g = get_handle (py_g);
2400
2401   r = guestfs_blockdev_getbsz (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_setbsz (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   int blocksize;
2420
2421   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
2422                          &py_g, &device, &blocksize))
2423     return NULL;
2424   g = get_handle (py_g);
2425
2426   r = guestfs_blockdev_setbsz (g, device, blocksize);
2427   if (r == -1) {
2428     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2429     return NULL;
2430   }
2431
2432   Py_INCREF (Py_None);
2433   py_r = Py_None;
2434   return py_r;
2435 }
2436
2437 static PyObject *
2438 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
2439 {
2440   PyObject *py_g;
2441   guestfs_h *g;
2442   PyObject *py_r;
2443   int64_t r;
2444   const char *device;
2445
2446   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
2447                          &py_g, &device))
2448     return NULL;
2449   g = get_handle (py_g);
2450
2451   r = guestfs_blockdev_getsz (g, device);
2452   if (r == -1) {
2453     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2454     return NULL;
2455   }
2456
2457   py_r = PyLong_FromLongLong (r);
2458   return py_r;
2459 }
2460
2461 static PyObject *
2462 py_guestfs_blockdev_getsize64 (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_getsize64",
2471                          &py_g, &device))
2472     return NULL;
2473   g = get_handle (py_g);
2474
2475   r = guestfs_blockdev_getsize64 (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_flushbufs (PyObject *self, PyObject *args)
2487 {
2488   PyObject *py_g;
2489   guestfs_h *g;
2490   PyObject *py_r;
2491   int r;
2492   const char *device;
2493
2494   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
2495                          &py_g, &device))
2496     return NULL;
2497   g = get_handle (py_g);
2498
2499   r = guestfs_blockdev_flushbufs (g, device);
2500   if (r == -1) {
2501     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2502     return NULL;
2503   }
2504
2505   Py_INCREF (Py_None);
2506   py_r = Py_None;
2507   return py_r;
2508 }
2509
2510 static PyObject *
2511 py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
2512 {
2513   PyObject *py_g;
2514   guestfs_h *g;
2515   PyObject *py_r;
2516   int r;
2517   const char *device;
2518
2519   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
2520                          &py_g, &device))
2521     return NULL;
2522   g = get_handle (py_g);
2523
2524   r = guestfs_blockdev_rereadpt (g, device);
2525   if (r == -1) {
2526     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2527     return NULL;
2528   }
2529
2530   Py_INCREF (Py_None);
2531   py_r = Py_None;
2532   return py_r;
2533 }
2534
2535 static PyObject *
2536 py_guestfs_upload (PyObject *self, PyObject *args)
2537 {
2538   PyObject *py_g;
2539   guestfs_h *g;
2540   PyObject *py_r;
2541   int r;
2542   const char *filename;
2543   const char *remotefilename;
2544
2545   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
2546                          &py_g, &filename, &remotefilename))
2547     return NULL;
2548   g = get_handle (py_g);
2549
2550   r = guestfs_upload (g, filename, remotefilename);
2551   if (r == -1) {
2552     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2553     return NULL;
2554   }
2555
2556   Py_INCREF (Py_None);
2557   py_r = Py_None;
2558   return py_r;
2559 }
2560
2561 static PyObject *
2562 py_guestfs_download (PyObject *self, PyObject *args)
2563 {
2564   PyObject *py_g;
2565   guestfs_h *g;
2566   PyObject *py_r;
2567   int r;
2568   const char *remotefilename;
2569   const char *filename;
2570
2571   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
2572                          &py_g, &remotefilename, &filename))
2573     return NULL;
2574   g = get_handle (py_g);
2575
2576   r = guestfs_download (g, remotefilename, filename);
2577   if (r == -1) {
2578     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2579     return NULL;
2580   }
2581
2582   Py_INCREF (Py_None);
2583   py_r = Py_None;
2584   return py_r;
2585 }
2586
2587 static PyObject *
2588 py_guestfs_checksum (PyObject *self, PyObject *args)
2589 {
2590   PyObject *py_g;
2591   guestfs_h *g;
2592   PyObject *py_r;
2593   char *r;
2594   const char *csumtype;
2595   const char *path;
2596
2597   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum",
2598                          &py_g, &csumtype, &path))
2599     return NULL;
2600   g = get_handle (py_g);
2601
2602   r = guestfs_checksum (g, csumtype, path);
2603   if (r == NULL) {
2604     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2605     return NULL;
2606   }
2607
2608   py_r = PyString_FromString (r);
2609   free (r);
2610   return py_r;
2611 }
2612
2613 static PyObject *
2614 py_guestfs_tar_in (PyObject *self, PyObject *args)
2615 {
2616   PyObject *py_g;
2617   guestfs_h *g;
2618   PyObject *py_r;
2619   int r;
2620   const char *tarfile;
2621   const char *directory;
2622
2623   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in",
2624                          &py_g, &tarfile, &directory))
2625     return NULL;
2626   g = get_handle (py_g);
2627
2628   r = guestfs_tar_in (g, tarfile, directory);
2629   if (r == -1) {
2630     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2631     return NULL;
2632   }
2633
2634   Py_INCREF (Py_None);
2635   py_r = Py_None;
2636   return py_r;
2637 }
2638
2639 static PyObject *
2640 py_guestfs_tar_out (PyObject *self, PyObject *args)
2641 {
2642   PyObject *py_g;
2643   guestfs_h *g;
2644   PyObject *py_r;
2645   int r;
2646   const char *directory;
2647   const char *tarfile;
2648
2649   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out",
2650                          &py_g, &directory, &tarfile))
2651     return NULL;
2652   g = get_handle (py_g);
2653
2654   r = guestfs_tar_out (g, directory, tarfile);
2655   if (r == -1) {
2656     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2657     return NULL;
2658   }
2659
2660   Py_INCREF (Py_None);
2661   py_r = Py_None;
2662   return py_r;
2663 }
2664
2665 static PyObject *
2666 py_guestfs_tgz_in (PyObject *self, PyObject *args)
2667 {
2668   PyObject *py_g;
2669   guestfs_h *g;
2670   PyObject *py_r;
2671   int r;
2672   const char *tarball;
2673   const char *directory;
2674
2675   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in",
2676                          &py_g, &tarball, &directory))
2677     return NULL;
2678   g = get_handle (py_g);
2679
2680   r = guestfs_tgz_in (g, tarball, directory);
2681   if (r == -1) {
2682     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2683     return NULL;
2684   }
2685
2686   Py_INCREF (Py_None);
2687   py_r = Py_None;
2688   return py_r;
2689 }
2690
2691 static PyObject *
2692 py_guestfs_tgz_out (PyObject *self, PyObject *args)
2693 {
2694   PyObject *py_g;
2695   guestfs_h *g;
2696   PyObject *py_r;
2697   int r;
2698   const char *directory;
2699   const char *tarball;
2700
2701   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out",
2702                          &py_g, &directory, &tarball))
2703     return NULL;
2704   g = get_handle (py_g);
2705
2706   r = guestfs_tgz_out (g, directory, tarball);
2707   if (r == -1) {
2708     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2709     return NULL;
2710   }
2711
2712   Py_INCREF (Py_None);
2713   py_r = Py_None;
2714   return py_r;
2715 }
2716
2717 static PyObject *
2718 py_guestfs_mount_ro (PyObject *self, PyObject *args)
2719 {
2720   PyObject *py_g;
2721   guestfs_h *g;
2722   PyObject *py_r;
2723   int r;
2724   const char *device;
2725   const char *mountpoint;
2726
2727   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro",
2728                          &py_g, &device, &mountpoint))
2729     return NULL;
2730   g = get_handle (py_g);
2731
2732   r = guestfs_mount_ro (g, device, mountpoint);
2733   if (r == -1) {
2734     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2735     return NULL;
2736   }
2737
2738   Py_INCREF (Py_None);
2739   py_r = Py_None;
2740   return py_r;
2741 }
2742
2743 static PyObject *
2744 py_guestfs_mount_options (PyObject *self, PyObject *args)
2745 {
2746   PyObject *py_g;
2747   guestfs_h *g;
2748   PyObject *py_r;
2749   int r;
2750   const char *options;
2751   const char *device;
2752   const char *mountpoint;
2753
2754   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options",
2755                          &py_g, &options, &device, &mountpoint))
2756     return NULL;
2757   g = get_handle (py_g);
2758
2759   r = guestfs_mount_options (g, options, device, mountpoint);
2760   if (r == -1) {
2761     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2762     return NULL;
2763   }
2764
2765   Py_INCREF (Py_None);
2766   py_r = Py_None;
2767   return py_r;
2768 }
2769
2770 static PyObject *
2771 py_guestfs_mount_vfs (PyObject *self, PyObject *args)
2772 {
2773   PyObject *py_g;
2774   guestfs_h *g;
2775   PyObject *py_r;
2776   int r;
2777   const char *options;
2778   const char *vfstype;
2779   const char *device;
2780   const char *mountpoint;
2781
2782   if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs",
2783                          &py_g, &options, &vfstype, &device, &mountpoint))
2784     return NULL;
2785   g = get_handle (py_g);
2786
2787   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2788   if (r == -1) {
2789     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2790     return NULL;
2791   }
2792
2793   Py_INCREF (Py_None);
2794   py_r = Py_None;
2795   return py_r;
2796 }
2797
2798 static PyObject *
2799 py_guestfs_debug (PyObject *self, PyObject *args)
2800 {
2801   PyObject *py_g;
2802   guestfs_h *g;
2803   PyObject *py_r;
2804   char *r;
2805   const char *subcmd;
2806   PyObject *py_extraargs;
2807   const char **extraargs;
2808
2809   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug",
2810                          &py_g, &subcmd, &py_extraargs))
2811     return NULL;
2812   g = get_handle (py_g);
2813   extraargs = get_string_list (py_extraargs);
2814   if (!extraargs) return NULL;
2815
2816   r = guestfs_debug (g, subcmd, extraargs);
2817   free (extraargs);
2818   if (r == NULL) {
2819     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2820     return NULL;
2821   }
2822
2823   py_r = PyString_FromString (r);
2824   free (r);
2825   return py_r;
2826 }
2827
2828 static PyObject *
2829 py_guestfs_lvremove (PyObject *self, PyObject *args)
2830 {
2831   PyObject *py_g;
2832   guestfs_h *g;
2833   PyObject *py_r;
2834   int r;
2835   const char *device;
2836
2837   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove",
2838                          &py_g, &device))
2839     return NULL;
2840   g = get_handle (py_g);
2841
2842   r = guestfs_lvremove (g, device);
2843   if (r == -1) {
2844     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2845     return NULL;
2846   }
2847
2848   Py_INCREF (Py_None);
2849   py_r = Py_None;
2850   return py_r;
2851 }
2852
2853 static PyObject *
2854 py_guestfs_vgremove (PyObject *self, PyObject *args)
2855 {
2856   PyObject *py_g;
2857   guestfs_h *g;
2858   PyObject *py_r;
2859   int r;
2860   const char *vgname;
2861
2862   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove",
2863                          &py_g, &vgname))
2864     return NULL;
2865   g = get_handle (py_g);
2866
2867   r = guestfs_vgremove (g, vgname);
2868   if (r == -1) {
2869     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2870     return NULL;
2871   }
2872
2873   Py_INCREF (Py_None);
2874   py_r = Py_None;
2875   return py_r;
2876 }
2877
2878 static PyObject *
2879 py_guestfs_pvremove (PyObject *self, PyObject *args)
2880 {
2881   PyObject *py_g;
2882   guestfs_h *g;
2883   PyObject *py_r;
2884   int r;
2885   const char *device;
2886
2887   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove",
2888                          &py_g, &device))
2889     return NULL;
2890   g = get_handle (py_g);
2891
2892   r = guestfs_pvremove (g, device);
2893   if (r == -1) {
2894     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2895     return NULL;
2896   }
2897
2898   Py_INCREF (Py_None);
2899   py_r = Py_None;
2900   return py_r;
2901 }
2902
2903 static PyObject *
2904 py_guestfs_set_e2label (PyObject *self, PyObject *args)
2905 {
2906   PyObject *py_g;
2907   guestfs_h *g;
2908   PyObject *py_r;
2909   int r;
2910   const char *device;
2911   const char *label;
2912
2913   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label",
2914                          &py_g, &device, &label))
2915     return NULL;
2916   g = get_handle (py_g);
2917
2918   r = guestfs_set_e2label (g, device, label);
2919   if (r == -1) {
2920     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2921     return NULL;
2922   }
2923
2924   Py_INCREF (Py_None);
2925   py_r = Py_None;
2926   return py_r;
2927 }
2928
2929 static PyObject *
2930 py_guestfs_get_e2label (PyObject *self, PyObject *args)
2931 {
2932   PyObject *py_g;
2933   guestfs_h *g;
2934   PyObject *py_r;
2935   char *r;
2936   const char *device;
2937
2938   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label",
2939                          &py_g, &device))
2940     return NULL;
2941   g = get_handle (py_g);
2942
2943   r = guestfs_get_e2label (g, device);
2944   if (r == NULL) {
2945     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2946     return NULL;
2947   }
2948
2949   py_r = PyString_FromString (r);
2950   free (r);
2951   return py_r;
2952 }
2953
2954 static PyObject *
2955 py_guestfs_set_e2uuid (PyObject *self, PyObject *args)
2956 {
2957   PyObject *py_g;
2958   guestfs_h *g;
2959   PyObject *py_r;
2960   int r;
2961   const char *device;
2962   const char *uuid;
2963
2964   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid",
2965                          &py_g, &device, &uuid))
2966     return NULL;
2967   g = get_handle (py_g);
2968
2969   r = guestfs_set_e2uuid (g, device, uuid);
2970   if (r == -1) {
2971     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2972     return NULL;
2973   }
2974
2975   Py_INCREF (Py_None);
2976   py_r = Py_None;
2977   return py_r;
2978 }
2979
2980 static PyObject *
2981 py_guestfs_get_e2uuid (PyObject *self, PyObject *args)
2982 {
2983   PyObject *py_g;
2984   guestfs_h *g;
2985   PyObject *py_r;
2986   char *r;
2987   const char *device;
2988
2989   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid",
2990                          &py_g, &device))
2991     return NULL;
2992   g = get_handle (py_g);
2993
2994   r = guestfs_get_e2uuid (g, device);
2995   if (r == NULL) {
2996     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2997     return NULL;
2998   }
2999
3000   py_r = PyString_FromString (r);
3001   free (r);
3002   return py_r;
3003 }
3004
3005 static PyObject *
3006 py_guestfs_fsck (PyObject *self, PyObject *args)
3007 {
3008   PyObject *py_g;
3009   guestfs_h *g;
3010   PyObject *py_r;
3011   int r;
3012   const char *fstype;
3013   const char *device;
3014
3015   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck",
3016                          &py_g, &fstype, &device))
3017     return NULL;
3018   g = get_handle (py_g);
3019
3020   r = guestfs_fsck (g, fstype, device);
3021   if (r == -1) {
3022     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3023     return NULL;
3024   }
3025
3026   py_r = PyInt_FromLong ((long) r);
3027   return py_r;
3028 }
3029
3030 static PyObject *
3031 py_guestfs_zero (PyObject *self, PyObject *args)
3032 {
3033   PyObject *py_g;
3034   guestfs_h *g;
3035   PyObject *py_r;
3036   int r;
3037   const char *device;
3038
3039   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero",
3040                          &py_g, &device))
3041     return NULL;
3042   g = get_handle (py_g);
3043
3044   r = guestfs_zero (g, device);
3045   if (r == -1) {
3046     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3047     return NULL;
3048   }
3049
3050   Py_INCREF (Py_None);
3051   py_r = Py_None;
3052   return py_r;
3053 }
3054
3055 static PyObject *
3056 py_guestfs_grub_install (PyObject *self, PyObject *args)
3057 {
3058   PyObject *py_g;
3059   guestfs_h *g;
3060   PyObject *py_r;
3061   int r;
3062   const char *root;
3063   const char *device;
3064
3065   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install",
3066                          &py_g, &root, &device))
3067     return NULL;
3068   g = get_handle (py_g);
3069
3070   r = guestfs_grub_install (g, root, device);
3071   if (r == -1) {
3072     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3073     return NULL;
3074   }
3075
3076   Py_INCREF (Py_None);
3077   py_r = Py_None;
3078   return py_r;
3079 }
3080
3081 static PyObject *
3082 py_guestfs_cp (PyObject *self, PyObject *args)
3083 {
3084   PyObject *py_g;
3085   guestfs_h *g;
3086   PyObject *py_r;
3087   int r;
3088   const char *src;
3089   const char *dest;
3090
3091   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp",
3092                          &py_g, &src, &dest))
3093     return NULL;
3094   g = get_handle (py_g);
3095
3096   r = guestfs_cp (g, src, dest);
3097   if (r == -1) {
3098     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3099     return NULL;
3100   }
3101
3102   Py_INCREF (Py_None);
3103   py_r = Py_None;
3104   return py_r;
3105 }
3106
3107 static PyObject *
3108 py_guestfs_cp_a (PyObject *self, PyObject *args)
3109 {
3110   PyObject *py_g;
3111   guestfs_h *g;
3112   PyObject *py_r;
3113   int r;
3114   const char *src;
3115   const char *dest;
3116
3117   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a",
3118                          &py_g, &src, &dest))
3119     return NULL;
3120   g = get_handle (py_g);
3121
3122   r = guestfs_cp_a (g, src, dest);
3123   if (r == -1) {
3124     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3125     return NULL;
3126   }
3127
3128   Py_INCREF (Py_None);
3129   py_r = Py_None;
3130   return py_r;
3131 }
3132
3133 static PyObject *
3134 py_guestfs_mv (PyObject *self, PyObject *args)
3135 {
3136   PyObject *py_g;
3137   guestfs_h *g;
3138   PyObject *py_r;
3139   int r;
3140   const char *src;
3141   const char *dest;
3142
3143   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv",
3144                          &py_g, &src, &dest))
3145     return NULL;
3146   g = get_handle (py_g);
3147
3148   r = guestfs_mv (g, src, dest);
3149   if (r == -1) {
3150     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3151     return NULL;
3152   }
3153
3154   Py_INCREF (Py_None);
3155   py_r = Py_None;
3156   return py_r;
3157 }
3158
3159 static PyObject *
3160 py_guestfs_drop_caches (PyObject *self, PyObject *args)
3161 {
3162   PyObject *py_g;
3163   guestfs_h *g;
3164   PyObject *py_r;
3165   int r;
3166   int whattodrop;
3167
3168   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches",
3169                          &py_g, &whattodrop))
3170     return NULL;
3171   g = get_handle (py_g);
3172
3173   r = guestfs_drop_caches (g, whattodrop);
3174   if (r == -1) {
3175     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3176     return NULL;
3177   }
3178
3179   Py_INCREF (Py_None);
3180   py_r = Py_None;
3181   return py_r;
3182 }
3183
3184 static PyObject *
3185 py_guestfs_dmesg (PyObject *self, PyObject *args)
3186 {
3187   PyObject *py_g;
3188   guestfs_h *g;
3189   PyObject *py_r;
3190   char *r;
3191
3192   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_dmesg",
3193                          &py_g))
3194     return NULL;
3195   g = get_handle (py_g);
3196
3197   r = guestfs_dmesg (g);
3198   if (r == NULL) {
3199     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
3200     return NULL;
3201   }
3202
3203   py_r = PyString_FromString (r);
3204   free (r);
3205   return py_r;
3206 }
3207
3208 static PyMethodDef methods[] = {
3209   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
3210   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
3211   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
3212   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
3213   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
3214   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
3215   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
3216   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
3217   { (char *) "set_qemu", py_guestfs_set_qemu, METH_VARARGS, NULL },
3218   { (char *) "get_qemu", py_guestfs_get_qemu, METH_VARARGS, NULL },
3219   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
3220   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
3221   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
3222   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
3223   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
3224   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
3225   { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
3226   { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
3227   { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
3228   { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
3229   { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
3230   { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL },
3231   { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL },
3232   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
3233   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
3234   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
3235   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
3236   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
3237   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
3238   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
3239   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
3240   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
3241   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
3242   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
3243   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
3244   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
3245   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
3246   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
3247   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
3248   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
3249   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
3250   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
3251   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
3252   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
3253   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
3254   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
3255   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
3256   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
3257   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
3258   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
3259   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
3260   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
3261   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
3262   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
3263   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
3264   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
3265   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
3266   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
3267   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
3268   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
3269   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
3270   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
3271   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
3272   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
3273   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
3274   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
3275   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
3276   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
3277   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
3278   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
3279   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
3280   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
3281   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
3282   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
3283   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
3284   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
3285   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
3286   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
3287   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
3288   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
3289   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
3290   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
3291   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
3292   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
3293   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
3294   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
3295   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
3296   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
3297   { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
3298   { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
3299   { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL },
3300   { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL },
3301   { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL },
3302   { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL },
3303   { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL },
3304   { (char *) "mount_ro", py_guestfs_mount_ro, METH_VARARGS, NULL },
3305   { (char *) "mount_options", py_guestfs_mount_options, METH_VARARGS, NULL },
3306   { (char *) "mount_vfs", py_guestfs_mount_vfs, METH_VARARGS, NULL },
3307   { (char *) "debug", py_guestfs_debug, METH_VARARGS, NULL },
3308   { (char *) "lvremove", py_guestfs_lvremove, METH_VARARGS, NULL },
3309   { (char *) "vgremove", py_guestfs_vgremove, METH_VARARGS, NULL },
3310   { (char *) "pvremove", py_guestfs_pvremove, METH_VARARGS, NULL },
3311   { (char *) "set_e2label", py_guestfs_set_e2label, METH_VARARGS, NULL },
3312   { (char *) "get_e2label", py_guestfs_get_e2label, METH_VARARGS, NULL },
3313   { (char *) "set_e2uuid", py_guestfs_set_e2uuid, METH_VARARGS, NULL },
3314   { (char *) "get_e2uuid", py_guestfs_get_e2uuid, METH_VARARGS, NULL },
3315   { (char *) "fsck", py_guestfs_fsck, METH_VARARGS, NULL },
3316   { (char *) "zero", py_guestfs_zero, METH_VARARGS, NULL },
3317   { (char *) "grub_install", py_guestfs_grub_install, METH_VARARGS, NULL },
3318   { (char *) "cp", py_guestfs_cp, METH_VARARGS, NULL },
3319   { (char *) "cp_a", py_guestfs_cp_a, METH_VARARGS, NULL },
3320   { (char *) "mv", py_guestfs_mv, METH_VARARGS, NULL },
3321   { (char *) "drop_caches", py_guestfs_drop_caches, METH_VARARGS, NULL },
3322   { (char *) "dmesg", py_guestfs_dmesg, METH_VARARGS, NULL },
3323   { NULL, NULL, 0, NULL }
3324 };
3325
3326 void
3327 initlibguestfsmod (void)
3328 {
3329   static int initialized = 0;
3330
3331   if (initialized) return;
3332   Py_InitModule ((char *) "libguestfsmod", methods);
3333   initialized = 1;
3334 }