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_path (PyObject *self, PyObject *args)
 541 {
 542   PyObject *py_g;
 543   guestfs_h *g;
 544   PyObject *py_r;
 545   int r;
 546   const char *path;
 547
 548   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
 549                          &py_g, &path))
 550     return NULL;
 551   g = get_handle (py_g);
 552
 553   r = guestfs_set_path (g, path);
 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_path (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_path",
 573                          &py_g))
 574     return NULL;
 575   g = get_handle (py_g);
 576
 577   r = guestfs_get_path (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_autosync (PyObject *self, PyObject *args)
 589 {
 590   PyObject *py_g;
 591   guestfs_h *g;
 592   PyObject *py_r;
 593   int r;
 594   int autosync;
 595
 596   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
 597                          &py_g, &autosync))
 598     return NULL;
 599   g = get_handle (py_g);
 600
 601   r = guestfs_set_autosync (g, autosync);
 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_autosync (PyObject *self, PyObject *args)
 614 {
 615   PyObject *py_g;
 616   guestfs_h *g;
 617   PyObject *py_r;
 618   int r;
 619
 620   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
 621                          &py_g))
 622     return NULL;
 623   g = get_handle (py_g);
 624
 625   r = guestfs_get_autosync (g);
 626   if (r == -1) {
 627     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 628     return NULL;
 629   }
 630
 631   py_r = PyInt_FromLong ((long) r);
 632   return py_r;
 633 }
 634
 635 static PyObject *
 636 py_guestfs_set_verbose (PyObject *self, PyObject *args)
 637 {
 638   PyObject *py_g;
 639   guestfs_h *g;
 640   PyObject *py_r;
 641   int r;
 642   int verbose;
 643
 644   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
 645                          &py_g, &verbose))
 646     return NULL;
 647   g = get_handle (py_g);
 648
 649   r = guestfs_set_verbose (g, verbose);
 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_verbose (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_verbose",
 669                          &py_g))
 670     return NULL;
 671   g = get_handle (py_g);
 672
 673   r = guestfs_get_verbose (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_is_ready (PyObject *self, PyObject *args)
 685 {
 686   PyObject *py_g;
 687   guestfs_h *g;
 688   PyObject *py_r;
 689   int r;
 690
 691   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready",
 692                          &py_g))
 693     return NULL;
 694   g = get_handle (py_g);
 695
 696   r = guestfs_is_ready (g);
 697   if (r == -1) {
 698     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 699     return NULL;
 700   }
 701
 702   py_r = PyInt_FromLong ((long) r);
 703   return py_r;
 704 }
 705
 706 static PyObject *
 707 py_guestfs_is_config (PyObject *self, PyObject *args)
 708 {
 709   PyObject *py_g;
 710   guestfs_h *g;
 711   PyObject *py_r;
 712   int r;
 713
 714   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config",
 715                          &py_g))
 716     return NULL;
 717   g = get_handle (py_g);
 718
 719   r = guestfs_is_config (g);
 720   if (r == -1) {
 721     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 722     return NULL;
 723   }
 724
 725   py_r = PyInt_FromLong ((long) r);
 726   return py_r;
 727 }
 728
 729 static PyObject *
 730 py_guestfs_is_launching (PyObject *self, PyObject *args)
 731 {
 732   PyObject *py_g;
 733   guestfs_h *g;
 734   PyObject *py_r;
 735   int r;
 736
 737   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching",
 738                          &py_g))
 739     return NULL;
 740   g = get_handle (py_g);
 741
 742   r = guestfs_is_launching (g);
 743   if (r == -1) {
 744     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 745     return NULL;
 746   }
 747
 748   py_r = PyInt_FromLong ((long) r);
 749   return py_r;
 750 }
 751
 752 static PyObject *
 753 py_guestfs_is_busy (PyObject *self, PyObject *args)
 754 {
 755   PyObject *py_g;
 756   guestfs_h *g;
 757   PyObject *py_r;
 758   int r;
 759
 760   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy",
 761                          &py_g))
 762     return NULL;
 763   g = get_handle (py_g);
 764
 765   r = guestfs_is_busy (g);
 766   if (r == -1) {
 767     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 768     return NULL;
 769   }
 770
 771   py_r = PyInt_FromLong ((long) r);
 772   return py_r;
 773 }
 774
 775 static PyObject *
 776 py_guestfs_get_state (PyObject *self, PyObject *args)
 777 {
 778   PyObject *py_g;
 779   guestfs_h *g;
 780   PyObject *py_r;
 781   int r;
 782
 783   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state",
 784                          &py_g))
 785     return NULL;
 786   g = get_handle (py_g);
 787
 788   r = guestfs_get_state (g);
 789   if (r == -1) {
 790     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 791     return NULL;
 792   }
 793
 794   py_r = PyInt_FromLong ((long) r);
 795   return py_r;
 796 }
 797
 798 static PyObject *
 799 py_guestfs_mount (PyObject *self, PyObject *args)
 800 {
 801   PyObject *py_g;
 802   guestfs_h *g;
 803   PyObject *py_r;
 804   int r;
 805   const char *device;
 806   const char *mountpoint;
 807
 808   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
 809                          &py_g, &device, &mountpoint))
 810     return NULL;
 811   g = get_handle (py_g);
 812
 813   r = guestfs_mount (g, device, mountpoint);
 814   if (r == -1) {
 815     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 816     return NULL;
 817   }
 818
 819   Py_INCREF (Py_None);
 820   py_r = Py_None;
 821   return py_r;
 822 }
 823
 824 static PyObject *
 825 py_guestfs_sync (PyObject *self, PyObject *args)
 826 {
 827   PyObject *py_g;
 828   guestfs_h *g;
 829   PyObject *py_r;
 830   int r;
 831
 832   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
 833                          &py_g))
 834     return NULL;
 835   g = get_handle (py_g);
 836
 837   r = guestfs_sync (g);
 838   if (r == -1) {
 839     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 840     return NULL;
 841   }
 842
 843   Py_INCREF (Py_None);
 844   py_r = Py_None;
 845   return py_r;
 846 }
 847
 848 static PyObject *
 849 py_guestfs_touch (PyObject *self, PyObject *args)
 850 {
 851   PyObject *py_g;
 852   guestfs_h *g;
 853   PyObject *py_r;
 854   int r;
 855   const char *path;
 856
 857   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
 858                          &py_g, &path))
 859     return NULL;
 860   g = get_handle (py_g);
 861
 862   r = guestfs_touch (g, path);
 863   if (r == -1) {
 864     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 865     return NULL;
 866   }
 867
 868   Py_INCREF (Py_None);
 869   py_r = Py_None;
 870   return py_r;
 871 }
 872
 873 static PyObject *
 874 py_guestfs_cat (PyObject *self, PyObject *args)
 875 {
 876   PyObject *py_g;
 877   guestfs_h *g;
 878   PyObject *py_r;
 879   char *r;
 880   const char *path;
 881
 882   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
 883                          &py_g, &path))
 884     return NULL;
 885   g = get_handle (py_g);
 886
 887   r = guestfs_cat (g, path);
 888   if (r == NULL) {
 889     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 890     return NULL;
 891   }
 892
 893   py_r = PyString_FromString (r);
 894   free (r);
 895   return py_r;
 896 }
 897
 898 static PyObject *
 899 py_guestfs_ll (PyObject *self, PyObject *args)
 900 {
 901   PyObject *py_g;
 902   guestfs_h *g;
 903   PyObject *py_r;
 904   char *r;
 905   const char *directory;
 906
 907   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
 908                          &py_g, &directory))
 909     return NULL;
 910   g = get_handle (py_g);
 911
 912   r = guestfs_ll (g, directory);
 913   if (r == NULL) {
 914     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 915     return NULL;
 916   }
 917
 918   py_r = PyString_FromString (r);
 919   free (r);
 920   return py_r;
 921 }
 922
 923 static PyObject *
 924 py_guestfs_ls (PyObject *self, PyObject *args)
 925 {
 926   PyObject *py_g;
 927   guestfs_h *g;
 928   PyObject *py_r;
 929   char **r;
 930   const char *directory;
 931
 932   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
 933                          &py_g, &directory))
 934     return NULL;
 935   g = get_handle (py_g);
 936
 937   r = guestfs_ls (g, directory);
 938   if (r == NULL) {
 939     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 940     return NULL;
 941   }
 942
 943   py_r = put_string_list (r);
 944   free_strings (r);
 945   return py_r;
 946 }
 947
 948 static PyObject *
 949 py_guestfs_list_devices (PyObject *self, PyObject *args)
 950 {
 951   PyObject *py_g;
 952   guestfs_h *g;
 953   PyObject *py_r;
 954   char **r;
 955
 956   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
 957                          &py_g))
 958     return NULL;
 959   g = get_handle (py_g);
 960
 961   r = guestfs_list_devices (g);
 962   if (r == NULL) {
 963     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 964     return NULL;
 965   }
 966
 967   py_r = put_string_list (r);
 968   free_strings (r);
 969   return py_r;
 970 }
 971
 972 static PyObject *
 973 py_guestfs_list_partitions (PyObject *self, PyObject *args)
 974 {
 975   PyObject *py_g;
 976   guestfs_h *g;
 977   PyObject *py_r;
 978   char **r;
 979
 980   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
 981                          &py_g))
 982     return NULL;
 983   g = get_handle (py_g);
 984
 985   r = guestfs_list_partitions (g);
 986   if (r == NULL) {
 987     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 988     return NULL;
 989   }
 990
 991   py_r = put_string_list (r);
 992   free_strings (r);
 993   return py_r;
 994 }
 995
 996 static PyObject *
 997 py_guestfs_pvs (PyObject *self, PyObject *args)
 998 {
 999   PyObject *py_g;
1000   guestfs_h *g;
1001   PyObject *py_r;
1002   char **r;
1003
1004   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
1005                          &py_g))
1006     return NULL;
1007   g = get_handle (py_g);
1008
1009   r = guestfs_pvs (g);
1010   if (r == NULL) {
1011     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1012     return NULL;
1013   }
1014
1015   py_r = put_string_list (r);
1016   free_strings (r);
1017   return py_r;
1018 }
1019
1020 static PyObject *
1021 py_guestfs_vgs (PyObject *self, PyObject *args)
1022 {
1023   PyObject *py_g;
1024   guestfs_h *g;
1025   PyObject *py_r;
1026   char **r;
1027
1028   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
1029                          &py_g))
1030     return NULL;
1031   g = get_handle (py_g);
1032
1033   r = guestfs_vgs (g);
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_lvs (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_lvs",
1053                          &py_g))
1054     return NULL;
1055   g = get_handle (py_g);
1056
1057   r = guestfs_lvs (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_pvs_full (PyObject *self, PyObject *args)
1070 {
1071   PyObject *py_g;
1072   guestfs_h *g;
1073   PyObject *py_r;
1074   struct guestfs_lvm_pv_list *r;
1075
1076   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
1077                          &py_g))
1078     return NULL;
1079   g = get_handle (py_g);
1080
1081   r = guestfs_pvs_full (g);
1082   if (r == NULL) {
1083     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1084     return NULL;
1085   }
1086
1087   py_r = put_lvm_pv_list (r);
1088   guestfs_free_lvm_pv_list (r);
1089   return py_r;
1090 }
1091
1092 static PyObject *
1093 py_guestfs_vgs_full (PyObject *self, PyObject *args)
1094 {
1095   PyObject *py_g;
1096   guestfs_h *g;
1097   PyObject *py_r;
1098   struct guestfs_lvm_vg_list *r;
1099
1100   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
1101                          &py_g))
1102     return NULL;
1103   g = get_handle (py_g);
1104
1105   r = guestfs_vgs_full (g);
1106   if (r == NULL) {
1107     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1108     return NULL;
1109   }
1110
1111   py_r = put_lvm_vg_list (r);
1112   guestfs_free_lvm_vg_list (r);
1113   return py_r;
1114 }
1115
1116 static PyObject *
1117 py_guestfs_lvs_full (PyObject *self, PyObject *args)
1118 {
1119   PyObject *py_g;
1120   guestfs_h *g;
1121   PyObject *py_r;
1122   struct guestfs_lvm_lv_list *r;
1123
1124   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
1125                          &py_g))
1126     return NULL;
1127   g = get_handle (py_g);
1128
1129   r = guestfs_lvs_full (g);
1130   if (r == NULL) {
1131     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1132     return NULL;
1133   }
1134
1135   py_r = put_lvm_lv_list (r);
1136   guestfs_free_lvm_lv_list (r);
1137   return py_r;
1138 }
1139
1140 static PyObject *
1141 py_guestfs_read_lines (PyObject *self, PyObject *args)
1142 {
1143   PyObject *py_g;
1144   guestfs_h *g;
1145   PyObject *py_r;
1146   char **r;
1147   const char *path;
1148
1149   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
1150                          &py_g, &path))
1151     return NULL;
1152   g = get_handle (py_g);
1153
1154   r = guestfs_read_lines (g, path);
1155   if (r == NULL) {
1156     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1157     return NULL;
1158   }
1159
1160   py_r = put_string_list (r);
1161   free_strings (r);
1162   return py_r;
1163 }
1164
1165 static PyObject *
1166 py_guestfs_aug_init (PyObject *self, PyObject *args)
1167 {
1168   PyObject *py_g;
1169   guestfs_h *g;
1170   PyObject *py_r;
1171   int r;
1172   const char *root;
1173   int flags;
1174
1175   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
1176                          &py_g, &root, &flags))
1177     return NULL;
1178   g = get_handle (py_g);
1179
1180   r = guestfs_aug_init (g, root, flags);
1181   if (r == -1) {
1182     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1183     return NULL;
1184   }
1185
1186   Py_INCREF (Py_None);
1187   py_r = Py_None;
1188   return py_r;
1189 }
1190
1191 static PyObject *
1192 py_guestfs_aug_close (PyObject *self, PyObject *args)
1193 {
1194   PyObject *py_g;
1195   guestfs_h *g;
1196   PyObject *py_r;
1197   int r;
1198
1199   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
1200                          &py_g))
1201     return NULL;
1202   g = get_handle (py_g);
1203
1204   r = guestfs_aug_close (g);
1205   if (r == -1) {
1206     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1207     return NULL;
1208   }
1209
1210   Py_INCREF (Py_None);
1211   py_r = Py_None;
1212   return py_r;
1213 }
1214
1215 static PyObject *
1216 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
1217 {
1218   PyObject *py_g;
1219   guestfs_h *g;
1220   PyObject *py_r;
1221   int r;
1222   const char *name;
1223   const char *expr;
1224
1225   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
1226                          &py_g, &name, &expr))
1227     return NULL;
1228   g = get_handle (py_g);
1229
1230   r = guestfs_aug_defvar (g, name, expr);
1231   if (r == -1) {
1232     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1233     return NULL;
1234   }
1235
1236   py_r = PyInt_FromLong ((long) r);
1237   return py_r;
1238 }
1239
1240 static PyObject *
1241 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
1242 {
1243   PyObject *py_g;
1244   guestfs_h *g;
1245   PyObject *py_r;
1246   struct guestfs_int_bool *r;
1247   const char *name;
1248   const char *expr;
1249   const char *val;
1250
1251   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
1252                          &py_g, &name, &expr, &val))
1253     return NULL;
1254   g = get_handle (py_g);
1255
1256   r = guestfs_aug_defnode (g, name, expr, val);
1257   if (r == NULL) {
1258     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1259     return NULL;
1260   }
1261
1262   py_r = PyTuple_New (2);
1263   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
1264   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
1265   guestfs_free_int_bool (r);
1266   return py_r;
1267 }
1268
1269 static PyObject *
1270 py_guestfs_aug_get (PyObject *self, PyObject *args)
1271 {
1272   PyObject *py_g;
1273   guestfs_h *g;
1274   PyObject *py_r;
1275   char *r;
1276   const char *path;
1277
1278   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
1279                          &py_g, &path))
1280     return NULL;
1281   g = get_handle (py_g);
1282
1283   r = guestfs_aug_get (g, path);
1284   if (r == NULL) {
1285     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1286     return NULL;
1287   }
1288
1289   py_r = PyString_FromString (r);
1290   free (r);
1291   return py_r;
1292 }
1293
1294 static PyObject *
1295 py_guestfs_aug_set (PyObject *self, PyObject *args)
1296 {
1297   PyObject *py_g;
1298   guestfs_h *g;
1299   PyObject *py_r;
1300   int r;
1301   const char *path;
1302   const char *val;
1303
1304   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
1305                          &py_g, &path, &val))
1306     return NULL;
1307   g = get_handle (py_g);
1308
1309   r = guestfs_aug_set (g, path, val);
1310   if (r == -1) {
1311     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1312     return NULL;
1313   }
1314
1315   Py_INCREF (Py_None);
1316   py_r = Py_None;
1317   return py_r;
1318 }
1319
1320 static PyObject *
1321 py_guestfs_aug_insert (PyObject *self, PyObject *args)
1322 {
1323   PyObject *py_g;
1324   guestfs_h *g;
1325   PyObject *py_r;
1326   int r;
1327   const char *path;
1328   const char *label;
1329   int before;
1330
1331   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
1332                          &py_g, &path, &label, &before))
1333     return NULL;
1334   g = get_handle (py_g);
1335
1336   r = guestfs_aug_insert (g, path, label, before);
1337   if (r == -1) {
1338     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1339     return NULL;
1340   }
1341
1342   Py_INCREF (Py_None);
1343   py_r = Py_None;
1344   return py_r;
1345 }
1346
1347 static PyObject *
1348 py_guestfs_aug_rm (PyObject *self, PyObject *args)
1349 {
1350   PyObject *py_g;
1351   guestfs_h *g;
1352   PyObject *py_r;
1353   int r;
1354   const char *path;
1355
1356   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
1357                          &py_g, &path))
1358     return NULL;
1359   g = get_handle (py_g);
1360
1361   r = guestfs_aug_rm (g, path);
1362   if (r == -1) {
1363     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1364     return NULL;
1365   }
1366
1367   py_r = PyInt_FromLong ((long) r);
1368   return py_r;
1369 }
1370
1371 static PyObject *
1372 py_guestfs_aug_mv (PyObject *self, PyObject *args)
1373 {
1374   PyObject *py_g;
1375   guestfs_h *g;
1376   PyObject *py_r;
1377   int r;
1378   const char *src;
1379   const char *dest;
1380
1381   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
1382                          &py_g, &src, &dest))
1383     return NULL;
1384   g = get_handle (py_g);
1385
1386   r = guestfs_aug_mv (g, src, dest);
1387   if (r == -1) {
1388     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1389     return NULL;
1390   }
1391
1392   Py_INCREF (Py_None);
1393   py_r = Py_None;
1394   return py_r;
1395 }
1396
1397 static PyObject *
1398 py_guestfs_aug_match (PyObject *self, PyObject *args)
1399 {
1400   PyObject *py_g;
1401   guestfs_h *g;
1402   PyObject *py_r;
1403   char **r;
1404   const char *path;
1405
1406   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
1407                          &py_g, &path))
1408     return NULL;
1409   g = get_handle (py_g);
1410
1411   r = guestfs_aug_match (g, path);
1412   if (r == NULL) {
1413     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1414     return NULL;
1415   }
1416
1417   py_r = put_string_list (r);
1418   free_strings (r);
1419   return py_r;
1420 }
1421
1422 static PyObject *
1423 py_guestfs_aug_save (PyObject *self, PyObject *args)
1424 {
1425   PyObject *py_g;
1426   guestfs_h *g;
1427   PyObject *py_r;
1428   int r;
1429
1430   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
1431                          &py_g))
1432     return NULL;
1433   g = get_handle (py_g);
1434
1435   r = guestfs_aug_save (g);
1436   if (r == -1) {
1437     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1438     return NULL;
1439   }
1440
1441   Py_INCREF (Py_None);
1442   py_r = Py_None;
1443   return py_r;
1444 }
1445
1446 static PyObject *
1447 py_guestfs_aug_load (PyObject *self, PyObject *args)
1448 {
1449   PyObject *py_g;
1450   guestfs_h *g;
1451   PyObject *py_r;
1452   int r;
1453
1454   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
1455                          &py_g))
1456     return NULL;
1457   g = get_handle (py_g);
1458
1459   r = guestfs_aug_load (g);
1460   if (r == -1) {
1461     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1462     return NULL;
1463   }
1464
1465   Py_INCREF (Py_None);
1466   py_r = Py_None;
1467   return py_r;
1468 }
1469
1470 static PyObject *
1471 py_guestfs_aug_ls (PyObject *self, PyObject *args)
1472 {
1473   PyObject *py_g;
1474   guestfs_h *g;
1475   PyObject *py_r;
1476   char **r;
1477   const char *path;
1478
1479   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
1480                          &py_g, &path))
1481     return NULL;
1482   g = get_handle (py_g);
1483
1484   r = guestfs_aug_ls (g, path);
1485   if (r == NULL) {
1486     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1487     return NULL;
1488   }
1489
1490   py_r = put_string_list (r);
1491   free_strings (r);
1492   return py_r;
1493 }
1494
1495 static PyObject *
1496 py_guestfs_rm (PyObject *self, PyObject *args)
1497 {
1498   PyObject *py_g;
1499   guestfs_h *g;
1500   PyObject *py_r;
1501   int r;
1502   const char *path;
1503
1504   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
1505                          &py_g, &path))
1506     return NULL;
1507   g = get_handle (py_g);
1508
1509   r = guestfs_rm (g, path);
1510   if (r == -1) {
1511     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1512     return NULL;
1513   }
1514
1515   Py_INCREF (Py_None);
1516   py_r = Py_None;
1517   return py_r;
1518 }
1519
1520 static PyObject *
1521 py_guestfs_rmdir (PyObject *self, PyObject *args)
1522 {
1523   PyObject *py_g;
1524   guestfs_h *g;
1525   PyObject *py_r;
1526   int r;
1527   const char *path;
1528
1529   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
1530                          &py_g, &path))
1531     return NULL;
1532   g = get_handle (py_g);
1533
1534   r = guestfs_rmdir (g, path);
1535   if (r == -1) {
1536     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1537     return NULL;
1538   }
1539
1540   Py_INCREF (Py_None);
1541   py_r = Py_None;
1542   return py_r;
1543 }
1544
1545 static PyObject *
1546 py_guestfs_rm_rf (PyObject *self, PyObject *args)
1547 {
1548   PyObject *py_g;
1549   guestfs_h *g;
1550   PyObject *py_r;
1551   int r;
1552   const char *path;
1553
1554   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
1555                          &py_g, &path))
1556     return NULL;
1557   g = get_handle (py_g);
1558
1559   r = guestfs_rm_rf (g, path);
1560   if (r == -1) {
1561     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1562     return NULL;
1563   }
1564
1565   Py_INCREF (Py_None);
1566   py_r = Py_None;
1567   return py_r;
1568 }
1569
1570 static PyObject *
1571 py_guestfs_mkdir (PyObject *self, PyObject *args)
1572 {
1573   PyObject *py_g;
1574   guestfs_h *g;
1575   PyObject *py_r;
1576   int r;
1577   const char *path;
1578
1579   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
1580                          &py_g, &path))
1581     return NULL;
1582   g = get_handle (py_g);
1583
1584   r = guestfs_mkdir (g, path);
1585   if (r == -1) {
1586     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1587     return NULL;
1588   }
1589
1590   Py_INCREF (Py_None);
1591   py_r = Py_None;
1592   return py_r;
1593 }
1594
1595 static PyObject *
1596 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
1597 {
1598   PyObject *py_g;
1599   guestfs_h *g;
1600   PyObject *py_r;
1601   int r;
1602   const char *path;
1603
1604   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
1605                          &py_g, &path))
1606     return NULL;
1607   g = get_handle (py_g);
1608
1609   r = guestfs_mkdir_p (g, path);
1610   if (r == -1) {
1611     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1612     return NULL;
1613   }
1614
1615   Py_INCREF (Py_None);
1616   py_r = Py_None;
1617   return py_r;
1618 }
1619
1620 static PyObject *
1621 py_guestfs_chmod (PyObject *self, PyObject *args)
1622 {
1623   PyObject *py_g;
1624   guestfs_h *g;
1625   PyObject *py_r;
1626   int r;
1627   int mode;
1628   const char *path;
1629
1630   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
1631                          &py_g, &mode, &path))
1632     return NULL;
1633   g = get_handle (py_g);
1634
1635   r = guestfs_chmod (g, mode, path);
1636   if (r == -1) {
1637     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1638     return NULL;
1639   }
1640
1641   Py_INCREF (Py_None);
1642   py_r = Py_None;
1643   return py_r;
1644 }
1645
1646 static PyObject *
1647 py_guestfs_chown (PyObject *self, PyObject *args)
1648 {
1649   PyObject *py_g;
1650   guestfs_h *g;
1651   PyObject *py_r;
1652   int r;
1653   int owner;
1654   int group;
1655   const char *path;
1656
1657   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
1658                          &py_g, &owner, &group, &path))
1659     return NULL;
1660   g = get_handle (py_g);
1661
1662   r = guestfs_chown (g, owner, group, path);
1663   if (r == -1) {
1664     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1665     return NULL;
1666   }
1667
1668   Py_INCREF (Py_None);
1669   py_r = Py_None;
1670   return py_r;
1671 }
1672
1673 static PyObject *
1674 py_guestfs_exists (PyObject *self, PyObject *args)
1675 {
1676   PyObject *py_g;
1677   guestfs_h *g;
1678   PyObject *py_r;
1679   int r;
1680   const char *path;
1681
1682   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
1683                          &py_g, &path))
1684     return NULL;
1685   g = get_handle (py_g);
1686
1687   r = guestfs_exists (g, path);
1688   if (r == -1) {
1689     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1690     return NULL;
1691   }
1692
1693   py_r = PyInt_FromLong ((long) r);
1694   return py_r;
1695 }
1696
1697 static PyObject *
1698 py_guestfs_is_file (PyObject *self, PyObject *args)
1699 {
1700   PyObject *py_g;
1701   guestfs_h *g;
1702   PyObject *py_r;
1703   int r;
1704   const char *path;
1705
1706   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
1707                          &py_g, &path))
1708     return NULL;
1709   g = get_handle (py_g);
1710
1711   r = guestfs_is_file (g, path);
1712   if (r == -1) {
1713     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1714     return NULL;
1715   }
1716
1717   py_r = PyInt_FromLong ((long) r);
1718   return py_r;
1719 }
1720
1721 static PyObject *
1722 py_guestfs_is_dir (PyObject *self, PyObject *args)
1723 {
1724   PyObject *py_g;
1725   guestfs_h *g;
1726   PyObject *py_r;
1727   int r;
1728   const char *path;
1729
1730   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
1731                          &py_g, &path))
1732     return NULL;
1733   g = get_handle (py_g);
1734
1735   r = guestfs_is_dir (g, path);
1736   if (r == -1) {
1737     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1738     return NULL;
1739   }
1740
1741   py_r = PyInt_FromLong ((long) r);
1742   return py_r;
1743 }
1744
1745 static PyObject *
1746 py_guestfs_pvcreate (PyObject *self, PyObject *args)
1747 {
1748   PyObject *py_g;
1749   guestfs_h *g;
1750   PyObject *py_r;
1751   int r;
1752   const char *device;
1753
1754   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
1755                          &py_g, &device))
1756     return NULL;
1757   g = get_handle (py_g);
1758
1759   r = guestfs_pvcreate (g, device);
1760   if (r == -1) {
1761     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1762     return NULL;
1763   }
1764
1765   Py_INCREF (Py_None);
1766   py_r = Py_None;
1767   return py_r;
1768 }
1769
1770 static PyObject *
1771 py_guestfs_vgcreate (PyObject *self, PyObject *args)
1772 {
1773   PyObject *py_g;
1774   guestfs_h *g;
1775   PyObject *py_r;
1776   int r;
1777   const char *volgroup;
1778   PyObject *py_physvols;
1779   const char **physvols;
1780
1781   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
1782                          &py_g, &volgroup, &py_physvols))
1783     return NULL;
1784   g = get_handle (py_g);
1785   physvols = get_string_list (py_physvols);
1786   if (!physvols) return NULL;
1787
1788   r = guestfs_vgcreate (g, volgroup, physvols);
1789   free (physvols);
1790   if (r == -1) {
1791     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1792     return NULL;
1793   }
1794
1795   Py_INCREF (Py_None);
1796   py_r = Py_None;
1797   return py_r;
1798 }
1799
1800 static PyObject *
1801 py_guestfs_lvcreate (PyObject *self, PyObject *args)
1802 {
1803   PyObject *py_g;
1804   guestfs_h *g;
1805   PyObject *py_r;
1806   int r;
1807   const char *logvol;
1808   const char *volgroup;
1809   int mbytes;
1810
1811   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
1812                          &py_g, &logvol, &volgroup, &mbytes))
1813     return NULL;
1814   g = get_handle (py_g);
1815
1816   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1817   if (r == -1) {
1818     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1819     return NULL;
1820   }
1821
1822   Py_INCREF (Py_None);
1823   py_r = Py_None;
1824   return py_r;
1825 }
1826
1827 static PyObject *
1828 py_guestfs_mkfs (PyObject *self, PyObject *args)
1829 {
1830   PyObject *py_g;
1831   guestfs_h *g;
1832   PyObject *py_r;
1833   int r;
1834   const char *fstype;
1835   const char *device;
1836
1837   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
1838                          &py_g, &fstype, &device))
1839     return NULL;
1840   g = get_handle (py_g);
1841
1842   r = guestfs_mkfs (g, fstype, device);
1843   if (r == -1) {
1844     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1845     return NULL;
1846   }
1847
1848   Py_INCREF (Py_None);
1849   py_r = Py_None;
1850   return py_r;
1851 }
1852
1853 static PyObject *
1854 py_guestfs_sfdisk (PyObject *self, PyObject *args)
1855 {
1856   PyObject *py_g;
1857   guestfs_h *g;
1858   PyObject *py_r;
1859   int r;
1860   const char *device;
1861   int cyls;
1862   int heads;
1863   int sectors;
1864   PyObject *py_lines;
1865   const char **lines;
1866
1867   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
1868                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
1869     return NULL;
1870   g = get_handle (py_g);
1871   lines = get_string_list (py_lines);
1872   if (!lines) return NULL;
1873
1874   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1875   free (lines);
1876   if (r == -1) {
1877     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1878     return NULL;
1879   }
1880
1881   Py_INCREF (Py_None);
1882   py_r = Py_None;
1883   return py_r;
1884 }
1885
1886 static PyObject *
1887 py_guestfs_write_file (PyObject *self, PyObject *args)
1888 {
1889   PyObject *py_g;
1890   guestfs_h *g;
1891   PyObject *py_r;
1892   int r;
1893   const char *path;
1894   const char *content;
1895   int size;
1896
1897   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
1898                          &py_g, &path, &content, &size))
1899     return NULL;
1900   g = get_handle (py_g);
1901
1902   r = guestfs_write_file (g, path, content, size);
1903   if (r == -1) {
1904     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1905     return NULL;
1906   }
1907
1908   Py_INCREF (Py_None);
1909   py_r = Py_None;
1910   return py_r;
1911 }
1912
1913 static PyObject *
1914 py_guestfs_umount (PyObject *self, PyObject *args)
1915 {
1916   PyObject *py_g;
1917   guestfs_h *g;
1918   PyObject *py_r;
1919   int r;
1920   const char *pathordevice;
1921
1922   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
1923                          &py_g, &pathordevice))
1924     return NULL;
1925   g = get_handle (py_g);
1926
1927   r = guestfs_umount (g, pathordevice);
1928   if (r == -1) {
1929     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1930     return NULL;
1931   }
1932
1933   Py_INCREF (Py_None);
1934   py_r = Py_None;
1935   return py_r;
1936 }
1937
1938 static PyObject *
1939 py_guestfs_mounts (PyObject *self, PyObject *args)
1940 {
1941   PyObject *py_g;
1942   guestfs_h *g;
1943   PyObject *py_r;
1944   char **r;
1945
1946   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
1947                          &py_g))
1948     return NULL;
1949   g = get_handle (py_g);
1950
1951   r = guestfs_mounts (g);
1952   if (r == NULL) {
1953     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1954     return NULL;
1955   }
1956
1957   py_r = put_string_list (r);
1958   free_strings (r);
1959   return py_r;
1960 }
1961
1962 static PyObject *
1963 py_guestfs_umount_all (PyObject *self, PyObject *args)
1964 {
1965   PyObject *py_g;
1966   guestfs_h *g;
1967   PyObject *py_r;
1968   int r;
1969
1970   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
1971                          &py_g))
1972     return NULL;
1973   g = get_handle (py_g);
1974
1975   r = guestfs_umount_all (g);
1976   if (r == -1) {
1977     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1978     return NULL;
1979   }
1980
1981   Py_INCREF (Py_None);
1982   py_r = Py_None;
1983   return py_r;
1984 }
1985
1986 static PyObject *
1987 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
1988 {
1989   PyObject *py_g;
1990   guestfs_h *g;
1991   PyObject *py_r;
1992   int r;
1993
1994   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
1995                          &py_g))
1996     return NULL;
1997   g = get_handle (py_g);
1998
1999   r = guestfs_lvm_remove_all (g);
2000   if (r == -1) {
2001     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2002     return NULL;
2003   }
2004
2005   Py_INCREF (Py_None);
2006   py_r = Py_None;
2007   return py_r;
2008 }
2009
2010 static PyObject *
2011 py_guestfs_file (PyObject *self, PyObject *args)
2012 {
2013   PyObject *py_g;
2014   guestfs_h *g;
2015   PyObject *py_r;
2016   char *r;
2017   const char *path;
2018
2019   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
2020                          &py_g, &path))
2021     return NULL;
2022   g = get_handle (py_g);
2023
2024   r = guestfs_file (g, path);
2025   if (r == NULL) {
2026     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2027     return NULL;
2028   }
2029
2030   py_r = PyString_FromString (r);
2031   free (r);
2032   return py_r;
2033 }
2034
2035 static PyObject *
2036 py_guestfs_command (PyObject *self, PyObject *args)
2037 {
2038   PyObject *py_g;
2039   guestfs_h *g;
2040   PyObject *py_r;
2041   char *r;
2042   PyObject *py_arguments;
2043   const char **arguments;
2044
2045   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
2046                          &py_g, &py_arguments))
2047     return NULL;
2048   g = get_handle (py_g);
2049   arguments = get_string_list (py_arguments);
2050   if (!arguments) return NULL;
2051
2052   r = guestfs_command (g, arguments);
2053   free (arguments);
2054   if (r == NULL) {
2055     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2056     return NULL;
2057   }
2058
2059   py_r = PyString_FromString (r);
2060   free (r);
2061   return py_r;
2062 }
2063
2064 static PyObject *
2065 py_guestfs_command_lines (PyObject *self, PyObject *args)
2066 {
2067   PyObject *py_g;
2068   guestfs_h *g;
2069   PyObject *py_r;
2070   char **r;
2071   PyObject *py_arguments;
2072   const char **arguments;
2073
2074   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
2075                          &py_g, &py_arguments))
2076     return NULL;
2077   g = get_handle (py_g);
2078   arguments = get_string_list (py_arguments);
2079   if (!arguments) return NULL;
2080
2081   r = guestfs_command_lines (g, arguments);
2082   free (arguments);
2083   if (r == NULL) {
2084     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2085     return NULL;
2086   }
2087
2088   py_r = put_string_list (r);
2089   free_strings (r);
2090   return py_r;
2091 }
2092
2093 static PyObject *
2094 py_guestfs_stat (PyObject *self, PyObject *args)
2095 {
2096   PyObject *py_g;
2097   guestfs_h *g;
2098   PyObject *py_r;
2099   struct guestfs_stat *r;
2100   const char *path;
2101
2102   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
2103                          &py_g, &path))
2104     return NULL;
2105   g = get_handle (py_g);
2106
2107   r = guestfs_stat (g, path);
2108   if (r == NULL) {
2109     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2110     return NULL;
2111   }
2112
2113   py_r = put_stat (r);
2114   free (r);
2115   return py_r;
2116 }
2117
2118 static PyObject *
2119 py_guestfs_lstat (PyObject *self, PyObject *args)
2120 {
2121   PyObject *py_g;
2122   guestfs_h *g;
2123   PyObject *py_r;
2124   struct guestfs_stat *r;
2125   const char *path;
2126
2127   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
2128                          &py_g, &path))
2129     return NULL;
2130   g = get_handle (py_g);
2131
2132   r = guestfs_lstat (g, path);
2133   if (r == NULL) {
2134     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2135     return NULL;
2136   }
2137
2138   py_r = put_stat (r);
2139   free (r);
2140   return py_r;
2141 }
2142
2143 static PyObject *
2144 py_guestfs_statvfs (PyObject *self, PyObject *args)
2145 {
2146   PyObject *py_g;
2147   guestfs_h *g;
2148   PyObject *py_r;
2149   struct guestfs_statvfs *r;
2150   const char *path;
2151
2152   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
2153                          &py_g, &path))
2154     return NULL;
2155   g = get_handle (py_g);
2156
2157   r = guestfs_statvfs (g, path);
2158   if (r == NULL) {
2159     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2160     return NULL;
2161   }
2162
2163   py_r = put_statvfs (r);
2164   free (r);
2165   return py_r;
2166 }
2167
2168 static PyObject *
2169 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
2170 {
2171   PyObject *py_g;
2172   guestfs_h *g;
2173   PyObject *py_r;
2174   char **r;
2175   const char *device;
2176
2177   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
2178                          &py_g, &device))
2179     return NULL;
2180   g = get_handle (py_g);
2181
2182   r = guestfs_tune2fs_l (g, device);
2183   if (r == NULL) {
2184     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2185     return NULL;
2186   }
2187
2188   py_r = put_table (r);
2189   free_strings (r);
2190   return py_r;
2191 }
2192
2193 static PyObject *
2194 py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
2195 {
2196   PyObject *py_g;
2197   guestfs_h *g;
2198   PyObject *py_r;
2199   int r;
2200   const char *device;
2201
2202   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
2203                          &py_g, &device))
2204     return NULL;
2205   g = get_handle (py_g);
2206
2207   r = guestfs_blockdev_setro (g, device);
2208   if (r == -1) {
2209     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2210     return NULL;
2211   }
2212
2213   Py_INCREF (Py_None);
2214   py_r = Py_None;
2215   return py_r;
2216 }
2217
2218 static PyObject *
2219 py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
2220 {
2221   PyObject *py_g;
2222   guestfs_h *g;
2223   PyObject *py_r;
2224   int r;
2225   const char *device;
2226
2227   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
2228                          &py_g, &device))
2229     return NULL;
2230   g = get_handle (py_g);
2231
2232   r = guestfs_blockdev_setrw (g, device);
2233   if (r == -1) {
2234     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2235     return NULL;
2236   }
2237
2238   Py_INCREF (Py_None);
2239   py_r = Py_None;
2240   return py_r;
2241 }
2242
2243 static PyObject *
2244 py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
2245 {
2246   PyObject *py_g;
2247   guestfs_h *g;
2248   PyObject *py_r;
2249   int r;
2250   const char *device;
2251
2252   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
2253                          &py_g, &device))
2254     return NULL;
2255   g = get_handle (py_g);
2256
2257   r = guestfs_blockdev_getro (g, device);
2258   if (r == -1) {
2259     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2260     return NULL;
2261   }
2262
2263   py_r = PyInt_FromLong ((long) r);
2264   return py_r;
2265 }
2266
2267 static PyObject *
2268 py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
2269 {
2270   PyObject *py_g;
2271   guestfs_h *g;
2272   PyObject *py_r;
2273   int r;
2274   const char *device;
2275
2276   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
2277                          &py_g, &device))
2278     return NULL;
2279   g = get_handle (py_g);
2280
2281   r = guestfs_blockdev_getss (g, device);
2282   if (r == -1) {
2283     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2284     return NULL;
2285   }
2286
2287   py_r = PyInt_FromLong ((long) r);
2288   return py_r;
2289 }
2290
2291 static PyObject *
2292 py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
2293 {
2294   PyObject *py_g;
2295   guestfs_h *g;
2296   PyObject *py_r;
2297   int r;
2298   const char *device;
2299
2300   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
2301                          &py_g, &device))
2302     return NULL;
2303   g = get_handle (py_g);
2304
2305   r = guestfs_blockdev_getbsz (g, device);
2306   if (r == -1) {
2307     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2308     return NULL;
2309   }
2310
2311   py_r = PyInt_FromLong ((long) r);
2312   return py_r;
2313 }
2314
2315 static PyObject *
2316 py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
2317 {
2318   PyObject *py_g;
2319   guestfs_h *g;
2320   PyObject *py_r;
2321   int r;
2322   const char *device;
2323   int blocksize;
2324
2325   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
2326                          &py_g, &device, &blocksize))
2327     return NULL;
2328   g = get_handle (py_g);
2329
2330   r = guestfs_blockdev_setbsz (g, device, blocksize);
2331   if (r == -1) {
2332     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2333     return NULL;
2334   }
2335
2336   Py_INCREF (Py_None);
2337   py_r = Py_None;
2338   return py_r;
2339 }
2340
2341 static PyObject *
2342 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
2343 {
2344   PyObject *py_g;
2345   guestfs_h *g;
2346   PyObject *py_r;
2347   int64_t r;
2348   const char *device;
2349
2350   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
2351                          &py_g, &device))
2352     return NULL;
2353   g = get_handle (py_g);
2354
2355   r = guestfs_blockdev_getsz (g, device);
2356   if (r == -1) {
2357     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2358     return NULL;
2359   }
2360
2361   py_r = PyLong_FromLongLong (r);
2362   return py_r;
2363 }
2364
2365 static PyObject *
2366 py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
2367 {
2368   PyObject *py_g;
2369   guestfs_h *g;
2370   PyObject *py_r;
2371   int64_t r;
2372   const char *device;
2373
2374   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
2375                          &py_g, &device))
2376     return NULL;
2377   g = get_handle (py_g);
2378
2379   r = guestfs_blockdev_getsize64 (g, device);
2380   if (r == -1) {
2381     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2382     return NULL;
2383   }
2384
2385   py_r = PyLong_FromLongLong (r);
2386   return py_r;
2387 }
2388
2389 static PyObject *
2390 py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
2391 {
2392   PyObject *py_g;
2393   guestfs_h *g;
2394   PyObject *py_r;
2395   int r;
2396   const char *device;
2397
2398   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
2399                          &py_g, &device))
2400     return NULL;
2401   g = get_handle (py_g);
2402
2403   r = guestfs_blockdev_flushbufs (g, device);
2404   if (r == -1) {
2405     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2406     return NULL;
2407   }
2408
2409   Py_INCREF (Py_None);
2410   py_r = Py_None;
2411   return py_r;
2412 }
2413
2414 static PyObject *
2415 py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
2416 {
2417   PyObject *py_g;
2418   guestfs_h *g;
2419   PyObject *py_r;
2420   int r;
2421   const char *device;
2422
2423   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
2424                          &py_g, &device))
2425     return NULL;
2426   g = get_handle (py_g);
2427
2428   r = guestfs_blockdev_rereadpt (g, device);
2429   if (r == -1) {
2430     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2431     return NULL;
2432   }
2433
2434   Py_INCREF (Py_None);
2435   py_r = Py_None;
2436   return py_r;
2437 }
2438
2439 static PyObject *
2440 py_guestfs_upload (PyObject *self, PyObject *args)
2441 {
2442   PyObject *py_g;
2443   guestfs_h *g;
2444   PyObject *py_r;
2445   int r;
2446   const char *filename;
2447   const char *remotefilename;
2448
2449   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
2450                          &py_g, &filename, &remotefilename))
2451     return NULL;
2452   g = get_handle (py_g);
2453
2454   r = guestfs_upload (g, filename, remotefilename);
2455   if (r == -1) {
2456     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2457     return NULL;
2458   }
2459
2460   Py_INCREF (Py_None);
2461   py_r = Py_None;
2462   return py_r;
2463 }
2464
2465 static PyObject *
2466 py_guestfs_download (PyObject *self, PyObject *args)
2467 {
2468   PyObject *py_g;
2469   guestfs_h *g;
2470   PyObject *py_r;
2471   int r;
2472   const char *remotefilename;
2473   const char *filename;
2474
2475   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
2476                          &py_g, &remotefilename, &filename))
2477     return NULL;
2478   g = get_handle (py_g);
2479
2480   r = guestfs_download (g, remotefilename, filename);
2481   if (r == -1) {
2482     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2483     return NULL;
2484   }
2485
2486   Py_INCREF (Py_None);
2487   py_r = Py_None;
2488   return py_r;
2489 }
2490
2491 static PyMethodDef methods[] = {
2492   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
2493   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
2494   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
2495   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
2496   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
2497   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
2498   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
2499   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
2500   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
2501   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
2502   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
2503   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
2504   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
2505   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
2506   { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
2507   { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
2508   { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
2509   { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
2510   { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
2511   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
2512   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
2513   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
2514   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
2515   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
2516   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
2517   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
2518   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
2519   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
2520   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
2521   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
2522   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
2523   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
2524   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
2525   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
2526   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
2527   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
2528   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
2529   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
2530   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
2531   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
2532   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
2533   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
2534   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
2535   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
2536   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
2537   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
2538   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
2539   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
2540   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
2541   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
2542   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
2543   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
2544   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
2545   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
2546   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
2547   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
2548   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
2549   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
2550   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
2551   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
2552   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
2553   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
2554   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
2555   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
2556   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
2557   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
2558   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
2559   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
2560   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
2561   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
2562   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
2563   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
2564   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
2565   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
2566   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
2567   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
2568   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
2569   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
2570   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
2571   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
2572   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
2573   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
2574   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
2575   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
2576   { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
2577   { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
2578   { NULL, NULL, 0, NULL }
2579 };
2580
2581 void
2582 initlibguestfsmod (void)
2583 {
2584   static int initialized = 0;
2585
2586   if (initialized) return;
2587   Py_InitModule ((char *) "libguestfsmod", methods);
2588   initialized = 1;
2589 }