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 void
  96 free_strings (char **argv)
  97 {
  98   int argc;
  99
 100   for (argc = 0; argv[argc] != NULL; ++argc)
 101     free (argv[argc]);
 102   free (argv);
 103 }
 104
 105 static PyObject *
 106 py_guestfs_create (PyObject *self, PyObject *args)
 107 {
 108   guestfs_h *g;
 109
 110   g = guestfs_create ();
 111   if (g == NULL) {
 112     PyErr_SetString (PyExc_RuntimeError,
 113                      "guestfs.create: failed to allocate handle");
 114     return NULL;
 115   }
 116   guestfs_set_error_handler (g, NULL, NULL);
 117   return put_handle (g);
 118 }
 119
 120 static PyObject *
 121 py_guestfs_close (PyObject *self, PyObject *args)
 122 {
 123   PyObject *py_g;
 124   guestfs_h *g;
 125
 126   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_close", &py_g))
 127     return NULL;
 128   g = get_handle (py_g);
 129
 130   guestfs_close (g);
 131
 132   Py_INCREF (Py_None);
 133   return Py_None;
 134 }
 135
 136 static PyObject *
 137 put_lvm_pv (struct guestfs_lvm_pv *pv)
 138 {
 139   PyObject *dict;
 140
 141   dict = PyDict_New ();
 142   PyDict_SetItemString (dict, "pv_name",
 143                         PyString_FromString (pv->pv_name));
 144   PyDict_SetItemString (dict, "pv_uuid",
 145                         PyString_FromStringAndSize (pv->pv_uuid, 32));
 146   PyDict_SetItemString (dict, "pv_fmt",
 147                         PyString_FromString (pv->pv_fmt));
 148   PyDict_SetItemString (dict, "pv_size",
 149                         PyLong_FromUnsignedLongLong (pv->pv_size));
 150   PyDict_SetItemString (dict, "dev_size",
 151                         PyLong_FromUnsignedLongLong (pv->dev_size));
 152   PyDict_SetItemString (dict, "pv_free",
 153                         PyLong_FromUnsignedLongLong (pv->pv_free));
 154   PyDict_SetItemString (dict, "pv_used",
 155                         PyLong_FromUnsignedLongLong (pv->pv_used));
 156   PyDict_SetItemString (dict, "pv_attr",
 157                         PyString_FromString (pv->pv_attr));
 158   PyDict_SetItemString (dict, "pv_pe_count",
 159                         PyLong_FromLongLong (pv->pv_pe_count));
 160   PyDict_SetItemString (dict, "pv_pe_alloc_count",
 161                         PyLong_FromLongLong (pv->pv_pe_alloc_count));
 162   PyDict_SetItemString (dict, "pv_tags",
 163                         PyString_FromString (pv->pv_tags));
 164   PyDict_SetItemString (dict, "pe_start",
 165                         PyLong_FromUnsignedLongLong (pv->pe_start));
 166   PyDict_SetItemString (dict, "pv_mda_count",
 167                         PyLong_FromLongLong (pv->pv_mda_count));
 168   PyDict_SetItemString (dict, "pv_mda_free",
 169                         PyLong_FromUnsignedLongLong (pv->pv_mda_free));
 170   return dict;
 171 };
 172
 173 static PyObject *
 174 put_lvm_pv_list (struct guestfs_lvm_pv_list *pvs)
 175 {
 176   PyObject *list;
 177   int i;
 178
 179   list = PyList_New (pvs->len);
 180   for (i = 0; i < pvs->len; ++i)
 181     PyList_SetItem (list, i, put_lvm_pv (&pvs->val[i]));
 182   return list;
 183 };
 184
 185 static PyObject *
 186 put_lvm_vg (struct guestfs_lvm_vg *vg)
 187 {
 188   PyObject *dict;
 189
 190   dict = PyDict_New ();
 191   PyDict_SetItemString (dict, "vg_name",
 192                         PyString_FromString (vg->vg_name));
 193   PyDict_SetItemString (dict, "vg_uuid",
 194                         PyString_FromStringAndSize (vg->vg_uuid, 32));
 195   PyDict_SetItemString (dict, "vg_fmt",
 196                         PyString_FromString (vg->vg_fmt));
 197   PyDict_SetItemString (dict, "vg_attr",
 198                         PyString_FromString (vg->vg_attr));
 199   PyDict_SetItemString (dict, "vg_size",
 200                         PyLong_FromUnsignedLongLong (vg->vg_size));
 201   PyDict_SetItemString (dict, "vg_free",
 202                         PyLong_FromUnsignedLongLong (vg->vg_free));
 203   PyDict_SetItemString (dict, "vg_sysid",
 204                         PyString_FromString (vg->vg_sysid));
 205   PyDict_SetItemString (dict, "vg_extent_size",
 206                         PyLong_FromUnsignedLongLong (vg->vg_extent_size));
 207   PyDict_SetItemString (dict, "vg_extent_count",
 208                         PyLong_FromLongLong (vg->vg_extent_count));
 209   PyDict_SetItemString (dict, "vg_free_count",
 210                         PyLong_FromLongLong (vg->vg_free_count));
 211   PyDict_SetItemString (dict, "max_lv",
 212                         PyLong_FromLongLong (vg->max_lv));
 213   PyDict_SetItemString (dict, "max_pv",
 214                         PyLong_FromLongLong (vg->max_pv));
 215   PyDict_SetItemString (dict, "pv_count",
 216                         PyLong_FromLongLong (vg->pv_count));
 217   PyDict_SetItemString (dict, "lv_count",
 218                         PyLong_FromLongLong (vg->lv_count));
 219   PyDict_SetItemString (dict, "snap_count",
 220                         PyLong_FromLongLong (vg->snap_count));
 221   PyDict_SetItemString (dict, "vg_seqno",
 222                         PyLong_FromLongLong (vg->vg_seqno));
 223   PyDict_SetItemString (dict, "vg_tags",
 224                         PyString_FromString (vg->vg_tags));
 225   PyDict_SetItemString (dict, "vg_mda_count",
 226                         PyLong_FromLongLong (vg->vg_mda_count));
 227   PyDict_SetItemString (dict, "vg_mda_free",
 228                         PyLong_FromUnsignedLongLong (vg->vg_mda_free));
 229   return dict;
 230 };
 231
 232 static PyObject *
 233 put_lvm_vg_list (struct guestfs_lvm_vg_list *vgs)
 234 {
 235   PyObject *list;
 236   int i;
 237
 238   list = PyList_New (vgs->len);
 239   for (i = 0; i < vgs->len; ++i)
 240     PyList_SetItem (list, i, put_lvm_vg (&vgs->val[i]));
 241   return list;
 242 };
 243
 244 static PyObject *
 245 put_lvm_lv (struct guestfs_lvm_lv *lv)
 246 {
 247   PyObject *dict;
 248
 249   dict = PyDict_New ();
 250   PyDict_SetItemString (dict, "lv_name",
 251                         PyString_FromString (lv->lv_name));
 252   PyDict_SetItemString (dict, "lv_uuid",
 253                         PyString_FromStringAndSize (lv->lv_uuid, 32));
 254   PyDict_SetItemString (dict, "lv_attr",
 255                         PyString_FromString (lv->lv_attr));
 256   PyDict_SetItemString (dict, "lv_major",
 257                         PyLong_FromLongLong (lv->lv_major));
 258   PyDict_SetItemString (dict, "lv_minor",
 259                         PyLong_FromLongLong (lv->lv_minor));
 260   PyDict_SetItemString (dict, "lv_kernel_major",
 261                         PyLong_FromLongLong (lv->lv_kernel_major));
 262   PyDict_SetItemString (dict, "lv_kernel_minor",
 263                         PyLong_FromLongLong (lv->lv_kernel_minor));
 264   PyDict_SetItemString (dict, "lv_size",
 265                         PyLong_FromUnsignedLongLong (lv->lv_size));
 266   PyDict_SetItemString (dict, "seg_count",
 267                         PyLong_FromLongLong (lv->seg_count));
 268   PyDict_SetItemString (dict, "origin",
 269                         PyString_FromString (lv->origin));
 270   if (lv->snap_percent >= 0)
 271     PyDict_SetItemString (dict, "snap_percent",
 272                           PyFloat_FromDouble ((double) lv->snap_percent));
 273   else {
 274     Py_INCREF (Py_None);
 275     PyDict_SetItemString (dict, "snap_percent", Py_None);  }
 276   if (lv->copy_percent >= 0)
 277     PyDict_SetItemString (dict, "copy_percent",
 278                           PyFloat_FromDouble ((double) lv->copy_percent));
 279   else {
 280     Py_INCREF (Py_None);
 281     PyDict_SetItemString (dict, "copy_percent", Py_None);  }
 282   PyDict_SetItemString (dict, "move_pv",
 283                         PyString_FromString (lv->move_pv));
 284   PyDict_SetItemString (dict, "lv_tags",
 285                         PyString_FromString (lv->lv_tags));
 286   PyDict_SetItemString (dict, "mirror_log",
 287                         PyString_FromString (lv->mirror_log));
 288   PyDict_SetItemString (dict, "modules",
 289                         PyString_FromString (lv->modules));
 290   return dict;
 291 };
 292
 293 static PyObject *
 294 put_lvm_lv_list (struct guestfs_lvm_lv_list *lvs)
 295 {
 296   PyObject *list;
 297   int i;
 298
 299   list = PyList_New (lvs->len);
 300   for (i = 0; i < lvs->len; ++i)
 301     PyList_SetItem (list, i, put_lvm_lv (&lvs->val[i]));
 302   return list;
 303 };
 304
 305 static PyObject *
 306 py_guestfs_launch (PyObject *self, PyObject *args)
 307 {
 308   PyObject *py_g;
 309   guestfs_h *g;
 310   PyObject *py_r;
 311   int r;
 312
 313   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch",
 314                          &py_g))
 315     return NULL;
 316   g = get_handle (py_g);
 317
 318   r = guestfs_launch (g);
 319   if (r == -1) {
 320     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 321     return NULL;
 322   }
 323
 324   Py_INCREF (Py_None);
 325   py_r = Py_None;
 326   return py_r;
 327 }
 328
 329 static PyObject *
 330 py_guestfs_wait_ready (PyObject *self, PyObject *args)
 331 {
 332   PyObject *py_g;
 333   guestfs_h *g;
 334   PyObject *py_r;
 335   int r;
 336
 337   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready",
 338                          &py_g))
 339     return NULL;
 340   g = get_handle (py_g);
 341
 342   r = guestfs_wait_ready (g);
 343   if (r == -1) {
 344     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 345     return NULL;
 346   }
 347
 348   Py_INCREF (Py_None);
 349   py_r = Py_None;
 350   return py_r;
 351 }
 352
 353 static PyObject *
 354 py_guestfs_kill_subprocess (PyObject *self, PyObject *args)
 355 {
 356   PyObject *py_g;
 357   guestfs_h *g;
 358   PyObject *py_r;
 359   int r;
 360
 361   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess",
 362                          &py_g))
 363     return NULL;
 364   g = get_handle (py_g);
 365
 366   r = guestfs_kill_subprocess (g);
 367   if (r == -1) {
 368     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 369     return NULL;
 370   }
 371
 372   Py_INCREF (Py_None);
 373   py_r = Py_None;
 374   return py_r;
 375 }
 376
 377 static PyObject *
 378 py_guestfs_add_drive (PyObject *self, PyObject *args)
 379 {
 380   PyObject *py_g;
 381   guestfs_h *g;
 382   PyObject *py_r;
 383   int r;
 384   const char *filename;
 385
 386   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive",
 387                          &py_g, &filename))
 388     return NULL;
 389   g = get_handle (py_g);
 390
 391   r = guestfs_add_drive (g, filename);
 392   if (r == -1) {
 393     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 394     return NULL;
 395   }
 396
 397   Py_INCREF (Py_None);
 398   py_r = Py_None;
 399   return py_r;
 400 }
 401
 402 static PyObject *
 403 py_guestfs_add_cdrom (PyObject *self, PyObject *args)
 404 {
 405   PyObject *py_g;
 406   guestfs_h *g;
 407   PyObject *py_r;
 408   int r;
 409   const char *filename;
 410
 411   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom",
 412                          &py_g, &filename))
 413     return NULL;
 414   g = get_handle (py_g);
 415
 416   r = guestfs_add_cdrom (g, filename);
 417   if (r == -1) {
 418     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 419     return NULL;
 420   }
 421
 422   Py_INCREF (Py_None);
 423   py_r = Py_None;
 424   return py_r;
 425 }
 426
 427 static PyObject *
 428 py_guestfs_config (PyObject *self, PyObject *args)
 429 {
 430   PyObject *py_g;
 431   guestfs_h *g;
 432   PyObject *py_r;
 433   int r;
 434   const char *qemuparam;
 435   const char *qemuvalue;
 436
 437   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config",
 438                          &py_g, &qemuparam, &qemuvalue))
 439     return NULL;
 440   g = get_handle (py_g);
 441
 442   r = guestfs_config (g, qemuparam, qemuvalue);
 443   if (r == -1) {
 444     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 445     return NULL;
 446   }
 447
 448   Py_INCREF (Py_None);
 449   py_r = Py_None;
 450   return py_r;
 451 }
 452
 453 static PyObject *
 454 py_guestfs_set_path (PyObject *self, PyObject *args)
 455 {
 456   PyObject *py_g;
 457   guestfs_h *g;
 458   PyObject *py_r;
 459   int r;
 460   const char *path;
 461
 462   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
 463                          &py_g, &path))
 464     return NULL;
 465   g = get_handle (py_g);
 466
 467   r = guestfs_set_path (g, path);
 468   if (r == -1) {
 469     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 470     return NULL;
 471   }
 472
 473   Py_INCREF (Py_None);
 474   py_r = Py_None;
 475   return py_r;
 476 }
 477
 478 static PyObject *
 479 py_guestfs_get_path (PyObject *self, PyObject *args)
 480 {
 481   PyObject *py_g;
 482   guestfs_h *g;
 483   PyObject *py_r;
 484   const char *r;
 485
 486   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
 487                          &py_g))
 488     return NULL;
 489   g = get_handle (py_g);
 490
 491   r = guestfs_get_path (g);
 492   if (r == NULL) {
 493     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 494     return NULL;
 495   }
 496
 497   py_r = PyString_FromString (r);
 498   return py_r;
 499 }
 500
 501 static PyObject *
 502 py_guestfs_set_autosync (PyObject *self, PyObject *args)
 503 {
 504   PyObject *py_g;
 505   guestfs_h *g;
 506   PyObject *py_r;
 507   int r;
 508   int autosync;
 509
 510   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
 511                          &py_g, &autosync))
 512     return NULL;
 513   g = get_handle (py_g);
 514
 515   r = guestfs_set_autosync (g, autosync);
 516   if (r == -1) {
 517     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 518     return NULL;
 519   }
 520
 521   Py_INCREF (Py_None);
 522   py_r = Py_None;
 523   return py_r;
 524 }
 525
 526 static PyObject *
 527 py_guestfs_get_autosync (PyObject *self, PyObject *args)
 528 {
 529   PyObject *py_g;
 530   guestfs_h *g;
 531   PyObject *py_r;
 532   int r;
 533
 534   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
 535                          &py_g))
 536     return NULL;
 537   g = get_handle (py_g);
 538
 539   r = guestfs_get_autosync (g);
 540   if (r == -1) {
 541     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 542     return NULL;
 543   }
 544
 545   py_r = PyInt_FromLong ((long) r);
 546   return py_r;
 547 }
 548
 549 static PyObject *
 550 py_guestfs_set_verbose (PyObject *self, PyObject *args)
 551 {
 552   PyObject *py_g;
 553   guestfs_h *g;
 554   PyObject *py_r;
 555   int r;
 556   int verbose;
 557
 558   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
 559                          &py_g, &verbose))
 560     return NULL;
 561   g = get_handle (py_g);
 562
 563   r = guestfs_set_verbose (g, verbose);
 564   if (r == -1) {
 565     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 566     return NULL;
 567   }
 568
 569   Py_INCREF (Py_None);
 570   py_r = Py_None;
 571   return py_r;
 572 }
 573
 574 static PyObject *
 575 py_guestfs_get_verbose (PyObject *self, PyObject *args)
 576 {
 577   PyObject *py_g;
 578   guestfs_h *g;
 579   PyObject *py_r;
 580   int r;
 581
 582   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
 583                          &py_g))
 584     return NULL;
 585   g = get_handle (py_g);
 586
 587   r = guestfs_get_verbose (g);
 588   if (r == -1) {
 589     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 590     return NULL;
 591   }
 592
 593   py_r = PyInt_FromLong ((long) r);
 594   return py_r;
 595 }
 596
 597 static PyObject *
 598 py_guestfs_mount (PyObject *self, PyObject *args)
 599 {
 600   PyObject *py_g;
 601   guestfs_h *g;
 602   PyObject *py_r;
 603   int r;
 604   const char *device;
 605   const char *mountpoint;
 606
 607   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
 608                          &py_g, &device, &mountpoint))
 609     return NULL;
 610   g = get_handle (py_g);
 611
 612   r = guestfs_mount (g, device, mountpoint);
 613   if (r == -1) {
 614     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 615     return NULL;
 616   }
 617
 618   Py_INCREF (Py_None);
 619   py_r = Py_None;
 620   return py_r;
 621 }
 622
 623 static PyObject *
 624 py_guestfs_sync (PyObject *self, PyObject *args)
 625 {
 626   PyObject *py_g;
 627   guestfs_h *g;
 628   PyObject *py_r;
 629   int r;
 630
 631   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
 632                          &py_g))
 633     return NULL;
 634   g = get_handle (py_g);
 635
 636   r = guestfs_sync (g);
 637   if (r == -1) {
 638     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 639     return NULL;
 640   }
 641
 642   Py_INCREF (Py_None);
 643   py_r = Py_None;
 644   return py_r;
 645 }
 646
 647 static PyObject *
 648 py_guestfs_touch (PyObject *self, PyObject *args)
 649 {
 650   PyObject *py_g;
 651   guestfs_h *g;
 652   PyObject *py_r;
 653   int r;
 654   const char *path;
 655
 656   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
 657                          &py_g, &path))
 658     return NULL;
 659   g = get_handle (py_g);
 660
 661   r = guestfs_touch (g, path);
 662   if (r == -1) {
 663     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 664     return NULL;
 665   }
 666
 667   Py_INCREF (Py_None);
 668   py_r = Py_None;
 669   return py_r;
 670 }
 671
 672 static PyObject *
 673 py_guestfs_cat (PyObject *self, PyObject *args)
 674 {
 675   PyObject *py_g;
 676   guestfs_h *g;
 677   PyObject *py_r;
 678   char *r;
 679   const char *path;
 680
 681   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
 682                          &py_g, &path))
 683     return NULL;
 684   g = get_handle (py_g);
 685
 686   r = guestfs_cat (g, path);
 687   if (r == NULL) {
 688     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 689     return NULL;
 690   }
 691
 692   py_r = PyString_FromString (r);
 693   free (r);
 694   return py_r;
 695 }
 696
 697 static PyObject *
 698 py_guestfs_ll (PyObject *self, PyObject *args)
 699 {
 700   PyObject *py_g;
 701   guestfs_h *g;
 702   PyObject *py_r;
 703   char *r;
 704   const char *directory;
 705
 706   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
 707                          &py_g, &directory))
 708     return NULL;
 709   g = get_handle (py_g);
 710
 711   r = guestfs_ll (g, directory);
 712   if (r == NULL) {
 713     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 714     return NULL;
 715   }
 716
 717   py_r = PyString_FromString (r);
 718   free (r);
 719   return py_r;
 720 }
 721
 722 static PyObject *
 723 py_guestfs_ls (PyObject *self, PyObject *args)
 724 {
 725   PyObject *py_g;
 726   guestfs_h *g;
 727   PyObject *py_r;
 728   char **r;
 729   const char *directory;
 730
 731   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
 732                          &py_g, &directory))
 733     return NULL;
 734   g = get_handle (py_g);
 735
 736   r = guestfs_ls (g, directory);
 737   if (r == NULL) {
 738     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 739     return NULL;
 740   }
 741
 742   py_r = put_string_list (r);
 743   free_strings (r);
 744   return py_r;
 745 }
 746
 747 static PyObject *
 748 py_guestfs_list_devices (PyObject *self, PyObject *args)
 749 {
 750   PyObject *py_g;
 751   guestfs_h *g;
 752   PyObject *py_r;
 753   char **r;
 754
 755   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
 756                          &py_g))
 757     return NULL;
 758   g = get_handle (py_g);
 759
 760   r = guestfs_list_devices (g);
 761   if (r == NULL) {
 762     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 763     return NULL;
 764   }
 765
 766   py_r = put_string_list (r);
 767   free_strings (r);
 768   return py_r;
 769 }
 770
 771 static PyObject *
 772 py_guestfs_list_partitions (PyObject *self, PyObject *args)
 773 {
 774   PyObject *py_g;
 775   guestfs_h *g;
 776   PyObject *py_r;
 777   char **r;
 778
 779   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
 780                          &py_g))
 781     return NULL;
 782   g = get_handle (py_g);
 783
 784   r = guestfs_list_partitions (g);
 785   if (r == NULL) {
 786     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 787     return NULL;
 788   }
 789
 790   py_r = put_string_list (r);
 791   free_strings (r);
 792   return py_r;
 793 }
 794
 795 static PyObject *
 796 py_guestfs_pvs (PyObject *self, PyObject *args)
 797 {
 798   PyObject *py_g;
 799   guestfs_h *g;
 800   PyObject *py_r;
 801   char **r;
 802
 803   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
 804                          &py_g))
 805     return NULL;
 806   g = get_handle (py_g);
 807
 808   r = guestfs_pvs (g);
 809   if (r == NULL) {
 810     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 811     return NULL;
 812   }
 813
 814   py_r = put_string_list (r);
 815   free_strings (r);
 816   return py_r;
 817 }
 818
 819 static PyObject *
 820 py_guestfs_vgs (PyObject *self, PyObject *args)
 821 {
 822   PyObject *py_g;
 823   guestfs_h *g;
 824   PyObject *py_r;
 825   char **r;
 826
 827   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
 828                          &py_g))
 829     return NULL;
 830   g = get_handle (py_g);
 831
 832   r = guestfs_vgs (g);
 833   if (r == NULL) {
 834     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 835     return NULL;
 836   }
 837
 838   py_r = put_string_list (r);
 839   free_strings (r);
 840   return py_r;
 841 }
 842
 843 static PyObject *
 844 py_guestfs_lvs (PyObject *self, PyObject *args)
 845 {
 846   PyObject *py_g;
 847   guestfs_h *g;
 848   PyObject *py_r;
 849   char **r;
 850
 851   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
 852                          &py_g))
 853     return NULL;
 854   g = get_handle (py_g);
 855
 856   r = guestfs_lvs (g);
 857   if (r == NULL) {
 858     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 859     return NULL;
 860   }
 861
 862   py_r = put_string_list (r);
 863   free_strings (r);
 864   return py_r;
 865 }
 866
 867 static PyObject *
 868 py_guestfs_pvs_full (PyObject *self, PyObject *args)
 869 {
 870   PyObject *py_g;
 871   guestfs_h *g;
 872   PyObject *py_r;
 873   struct guestfs_lvm_pv_list *r;
 874
 875   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
 876                          &py_g))
 877     return NULL;
 878   g = get_handle (py_g);
 879
 880   r = guestfs_pvs_full (g);
 881   if (r == NULL) {
 882     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 883     return NULL;
 884   }
 885
 886   py_r = put_lvm_pv_list (r);
 887   guestfs_free_lvm_pv_list (r);
 888   return py_r;
 889 }
 890
 891 static PyObject *
 892 py_guestfs_vgs_full (PyObject *self, PyObject *args)
 893 {
 894   PyObject *py_g;
 895   guestfs_h *g;
 896   PyObject *py_r;
 897   struct guestfs_lvm_vg_list *r;
 898
 899   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
 900                          &py_g))
 901     return NULL;
 902   g = get_handle (py_g);
 903
 904   r = guestfs_vgs_full (g);
 905   if (r == NULL) {
 906     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 907     return NULL;
 908   }
 909
 910   py_r = put_lvm_vg_list (r);
 911   guestfs_free_lvm_vg_list (r);
 912   return py_r;
 913 }
 914
 915 static PyObject *
 916 py_guestfs_lvs_full (PyObject *self, PyObject *args)
 917 {
 918   PyObject *py_g;
 919   guestfs_h *g;
 920   PyObject *py_r;
 921   struct guestfs_lvm_lv_list *r;
 922
 923   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
 924                          &py_g))
 925     return NULL;
 926   g = get_handle (py_g);
 927
 928   r = guestfs_lvs_full (g);
 929   if (r == NULL) {
 930     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 931     return NULL;
 932   }
 933
 934   py_r = put_lvm_lv_list (r);
 935   guestfs_free_lvm_lv_list (r);
 936   return py_r;
 937 }
 938
 939 static PyObject *
 940 py_guestfs_read_lines (PyObject *self, PyObject *args)
 941 {
 942   PyObject *py_g;
 943   guestfs_h *g;
 944   PyObject *py_r;
 945   char **r;
 946   const char *path;
 947
 948   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
 949                          &py_g, &path))
 950     return NULL;
 951   g = get_handle (py_g);
 952
 953   r = guestfs_read_lines (g, path);
 954   if (r == NULL) {
 955     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 956     return NULL;
 957   }
 958
 959   py_r = put_string_list (r);
 960   free_strings (r);
 961   return py_r;
 962 }
 963
 964 static PyObject *
 965 py_guestfs_aug_init (PyObject *self, PyObject *args)
 966 {
 967   PyObject *py_g;
 968   guestfs_h *g;
 969   PyObject *py_r;
 970   int r;
 971   const char *root;
 972   int flags;
 973
 974   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
 975                          &py_g, &root, &flags))
 976     return NULL;
 977   g = get_handle (py_g);
 978
 979   r = guestfs_aug_init (g, root, flags);
 980   if (r == -1) {
 981     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 982     return NULL;
 983   }
 984
 985   Py_INCREF (Py_None);
 986   py_r = Py_None;
 987   return py_r;
 988 }
 989
 990 static PyObject *
 991 py_guestfs_aug_close (PyObject *self, PyObject *args)
 992 {
 993   PyObject *py_g;
 994   guestfs_h *g;
 995   PyObject *py_r;
 996   int r;
 997
 998   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
 999                          &py_g))
1000     return NULL;
1001   g = get_handle (py_g);
1002
1003   r = guestfs_aug_close (g);
1004   if (r == -1) {
1005     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1006     return NULL;
1007   }
1008
1009   Py_INCREF (Py_None);
1010   py_r = Py_None;
1011   return py_r;
1012 }
1013
1014 static PyObject *
1015 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
1016 {
1017   PyObject *py_g;
1018   guestfs_h *g;
1019   PyObject *py_r;
1020   int r;
1021   const char *name;
1022   const char *expr;
1023
1024   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
1025                          &py_g, &name, &expr))
1026     return NULL;
1027   g = get_handle (py_g);
1028
1029   r = guestfs_aug_defvar (g, name, expr);
1030   if (r == -1) {
1031     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1032     return NULL;
1033   }
1034
1035   py_r = PyInt_FromLong ((long) r);
1036   return py_r;
1037 }
1038
1039 static PyObject *
1040 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
1041 {
1042   PyObject *py_g;
1043   guestfs_h *g;
1044   PyObject *py_r;
1045   struct guestfs_int_bool *r;
1046   const char *name;
1047   const char *expr;
1048   const char *val;
1049
1050   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
1051                          &py_g, &name, &expr, &val))
1052     return NULL;
1053   g = get_handle (py_g);
1054
1055   r = guestfs_aug_defnode (g, name, expr, val);
1056   if (r == NULL) {
1057     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1058     return NULL;
1059   }
1060
1061   py_r = PyTuple_New (2);
1062   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
1063   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
1064   guestfs_free_int_bool (r);
1065   return py_r;
1066 }
1067
1068 static PyObject *
1069 py_guestfs_aug_get (PyObject *self, PyObject *args)
1070 {
1071   PyObject *py_g;
1072   guestfs_h *g;
1073   PyObject *py_r;
1074   char *r;
1075   const char *path;
1076
1077   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
1078                          &py_g, &path))
1079     return NULL;
1080   g = get_handle (py_g);
1081
1082   r = guestfs_aug_get (g, path);
1083   if (r == NULL) {
1084     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1085     return NULL;
1086   }
1087
1088   py_r = PyString_FromString (r);
1089   free (r);
1090   return py_r;
1091 }
1092
1093 static PyObject *
1094 py_guestfs_aug_set (PyObject *self, PyObject *args)
1095 {
1096   PyObject *py_g;
1097   guestfs_h *g;
1098   PyObject *py_r;
1099   int r;
1100   const char *path;
1101   const char *val;
1102
1103   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
1104                          &py_g, &path, &val))
1105     return NULL;
1106   g = get_handle (py_g);
1107
1108   r = guestfs_aug_set (g, path, val);
1109   if (r == -1) {
1110     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1111     return NULL;
1112   }
1113
1114   Py_INCREF (Py_None);
1115   py_r = Py_None;
1116   return py_r;
1117 }
1118
1119 static PyObject *
1120 py_guestfs_aug_insert (PyObject *self, PyObject *args)
1121 {
1122   PyObject *py_g;
1123   guestfs_h *g;
1124   PyObject *py_r;
1125   int r;
1126   const char *path;
1127   const char *label;
1128   int before;
1129
1130   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
1131                          &py_g, &path, &label, &before))
1132     return NULL;
1133   g = get_handle (py_g);
1134
1135   r = guestfs_aug_insert (g, path, label, before);
1136   if (r == -1) {
1137     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1138     return NULL;
1139   }
1140
1141   Py_INCREF (Py_None);
1142   py_r = Py_None;
1143   return py_r;
1144 }
1145
1146 static PyObject *
1147 py_guestfs_aug_rm (PyObject *self, PyObject *args)
1148 {
1149   PyObject *py_g;
1150   guestfs_h *g;
1151   PyObject *py_r;
1152   int r;
1153   const char *path;
1154
1155   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
1156                          &py_g, &path))
1157     return NULL;
1158   g = get_handle (py_g);
1159
1160   r = guestfs_aug_rm (g, path);
1161   if (r == -1) {
1162     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1163     return NULL;
1164   }
1165
1166   py_r = PyInt_FromLong ((long) r);
1167   return py_r;
1168 }
1169
1170 static PyObject *
1171 py_guestfs_aug_mv (PyObject *self, PyObject *args)
1172 {
1173   PyObject *py_g;
1174   guestfs_h *g;
1175   PyObject *py_r;
1176   int r;
1177   const char *src;
1178   const char *dest;
1179
1180   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
1181                          &py_g, &src, &dest))
1182     return NULL;
1183   g = get_handle (py_g);
1184
1185   r = guestfs_aug_mv (g, src, dest);
1186   if (r == -1) {
1187     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1188     return NULL;
1189   }
1190
1191   Py_INCREF (Py_None);
1192   py_r = Py_None;
1193   return py_r;
1194 }
1195
1196 static PyObject *
1197 py_guestfs_aug_match (PyObject *self, PyObject *args)
1198 {
1199   PyObject *py_g;
1200   guestfs_h *g;
1201   PyObject *py_r;
1202   char **r;
1203   const char *path;
1204
1205   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
1206                          &py_g, &path))
1207     return NULL;
1208   g = get_handle (py_g);
1209
1210   r = guestfs_aug_match (g, path);
1211   if (r == NULL) {
1212     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1213     return NULL;
1214   }
1215
1216   py_r = put_string_list (r);
1217   free_strings (r);
1218   return py_r;
1219 }
1220
1221 static PyObject *
1222 py_guestfs_aug_save (PyObject *self, PyObject *args)
1223 {
1224   PyObject *py_g;
1225   guestfs_h *g;
1226   PyObject *py_r;
1227   int r;
1228
1229   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
1230                          &py_g))
1231     return NULL;
1232   g = get_handle (py_g);
1233
1234   r = guestfs_aug_save (g);
1235   if (r == -1) {
1236     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1237     return NULL;
1238   }
1239
1240   Py_INCREF (Py_None);
1241   py_r = Py_None;
1242   return py_r;
1243 }
1244
1245 static PyObject *
1246 py_guestfs_aug_load (PyObject *self, PyObject *args)
1247 {
1248   PyObject *py_g;
1249   guestfs_h *g;
1250   PyObject *py_r;
1251   int r;
1252
1253   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
1254                          &py_g))
1255     return NULL;
1256   g = get_handle (py_g);
1257
1258   r = guestfs_aug_load (g);
1259   if (r == -1) {
1260     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1261     return NULL;
1262   }
1263
1264   Py_INCREF (Py_None);
1265   py_r = Py_None;
1266   return py_r;
1267 }
1268
1269 static PyObject *
1270 py_guestfs_aug_ls (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_ls",
1279                          &py_g, &path))
1280     return NULL;
1281   g = get_handle (py_g);
1282
1283   r = guestfs_aug_ls (g, path);
1284   if (r == NULL) {
1285     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1286     return NULL;
1287   }
1288
1289   py_r = put_string_list (r);
1290   free_strings (r);
1291   return py_r;
1292 }
1293
1294 static PyObject *
1295 py_guestfs_rm (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
1303   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
1304                          &py_g, &path))
1305     return NULL;
1306   g = get_handle (py_g);
1307
1308   r = guestfs_rm (g, path);
1309   if (r == -1) {
1310     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1311     return NULL;
1312   }
1313
1314   Py_INCREF (Py_None);
1315   py_r = Py_None;
1316   return py_r;
1317 }
1318
1319 static PyObject *
1320 py_guestfs_rmdir (PyObject *self, PyObject *args)
1321 {
1322   PyObject *py_g;
1323   guestfs_h *g;
1324   PyObject *py_r;
1325   int r;
1326   const char *path;
1327
1328   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
1329                          &py_g, &path))
1330     return NULL;
1331   g = get_handle (py_g);
1332
1333   r = guestfs_rmdir (g, path);
1334   if (r == -1) {
1335     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1336     return NULL;
1337   }
1338
1339   Py_INCREF (Py_None);
1340   py_r = Py_None;
1341   return py_r;
1342 }
1343
1344 static PyObject *
1345 py_guestfs_rm_rf (PyObject *self, PyObject *args)
1346 {
1347   PyObject *py_g;
1348   guestfs_h *g;
1349   PyObject *py_r;
1350   int r;
1351   const char *path;
1352
1353   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
1354                          &py_g, &path))
1355     return NULL;
1356   g = get_handle (py_g);
1357
1358   r = guestfs_rm_rf (g, path);
1359   if (r == -1) {
1360     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1361     return NULL;
1362   }
1363
1364   Py_INCREF (Py_None);
1365   py_r = Py_None;
1366   return py_r;
1367 }
1368
1369 static PyObject *
1370 py_guestfs_mkdir (PyObject *self, PyObject *args)
1371 {
1372   PyObject *py_g;
1373   guestfs_h *g;
1374   PyObject *py_r;
1375   int r;
1376   const char *path;
1377
1378   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
1379                          &py_g, &path))
1380     return NULL;
1381   g = get_handle (py_g);
1382
1383   r = guestfs_mkdir (g, path);
1384   if (r == -1) {
1385     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1386     return NULL;
1387   }
1388
1389   Py_INCREF (Py_None);
1390   py_r = Py_None;
1391   return py_r;
1392 }
1393
1394 static PyObject *
1395 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
1396 {
1397   PyObject *py_g;
1398   guestfs_h *g;
1399   PyObject *py_r;
1400   int r;
1401   const char *path;
1402
1403   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
1404                          &py_g, &path))
1405     return NULL;
1406   g = get_handle (py_g);
1407
1408   r = guestfs_mkdir_p (g, path);
1409   if (r == -1) {
1410     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1411     return NULL;
1412   }
1413
1414   Py_INCREF (Py_None);
1415   py_r = Py_None;
1416   return py_r;
1417 }
1418
1419 static PyObject *
1420 py_guestfs_chmod (PyObject *self, PyObject *args)
1421 {
1422   PyObject *py_g;
1423   guestfs_h *g;
1424   PyObject *py_r;
1425   int r;
1426   int mode;
1427   const char *path;
1428
1429   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
1430                          &py_g, &mode, &path))
1431     return NULL;
1432   g = get_handle (py_g);
1433
1434   r = guestfs_chmod (g, mode, path);
1435   if (r == -1) {
1436     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1437     return NULL;
1438   }
1439
1440   Py_INCREF (Py_None);
1441   py_r = Py_None;
1442   return py_r;
1443 }
1444
1445 static PyObject *
1446 py_guestfs_chown (PyObject *self, PyObject *args)
1447 {
1448   PyObject *py_g;
1449   guestfs_h *g;
1450   PyObject *py_r;
1451   int r;
1452   int owner;
1453   int group;
1454   const char *path;
1455
1456   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
1457                          &py_g, &owner, &group, &path))
1458     return NULL;
1459   g = get_handle (py_g);
1460
1461   r = guestfs_chown (g, owner, group, path);
1462   if (r == -1) {
1463     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1464     return NULL;
1465   }
1466
1467   Py_INCREF (Py_None);
1468   py_r = Py_None;
1469   return py_r;
1470 }
1471
1472 static PyObject *
1473 py_guestfs_exists (PyObject *self, PyObject *args)
1474 {
1475   PyObject *py_g;
1476   guestfs_h *g;
1477   PyObject *py_r;
1478   int r;
1479   const char *path;
1480
1481   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
1482                          &py_g, &path))
1483     return NULL;
1484   g = get_handle (py_g);
1485
1486   r = guestfs_exists (g, path);
1487   if (r == -1) {
1488     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1489     return NULL;
1490   }
1491
1492   py_r = PyInt_FromLong ((long) r);
1493   return py_r;
1494 }
1495
1496 static PyObject *
1497 py_guestfs_is_file (PyObject *self, PyObject *args)
1498 {
1499   PyObject *py_g;
1500   guestfs_h *g;
1501   PyObject *py_r;
1502   int r;
1503   const char *path;
1504
1505   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
1506                          &py_g, &path))
1507     return NULL;
1508   g = get_handle (py_g);
1509
1510   r = guestfs_is_file (g, path);
1511   if (r == -1) {
1512     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1513     return NULL;
1514   }
1515
1516   py_r = PyInt_FromLong ((long) r);
1517   return py_r;
1518 }
1519
1520 static PyObject *
1521 py_guestfs_is_dir (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_is_dir",
1530                          &py_g, &path))
1531     return NULL;
1532   g = get_handle (py_g);
1533
1534   r = guestfs_is_dir (g, path);
1535   if (r == -1) {
1536     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1537     return NULL;
1538   }
1539
1540   py_r = PyInt_FromLong ((long) r);
1541   return py_r;
1542 }
1543
1544 static PyObject *
1545 py_guestfs_pvcreate (PyObject *self, PyObject *args)
1546 {
1547   PyObject *py_g;
1548   guestfs_h *g;
1549   PyObject *py_r;
1550   int r;
1551   const char *device;
1552
1553   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
1554                          &py_g, &device))
1555     return NULL;
1556   g = get_handle (py_g);
1557
1558   r = guestfs_pvcreate (g, device);
1559   if (r == -1) {
1560     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1561     return NULL;
1562   }
1563
1564   Py_INCREF (Py_None);
1565   py_r = Py_None;
1566   return py_r;
1567 }
1568
1569 static PyObject *
1570 py_guestfs_vgcreate (PyObject *self, PyObject *args)
1571 {
1572   PyObject *py_g;
1573   guestfs_h *g;
1574   PyObject *py_r;
1575   int r;
1576   const char *volgroup;
1577   PyObject *py_physvols;
1578   const char **physvols;
1579
1580   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
1581                          &py_g, &volgroup, &py_physvols))
1582     return NULL;
1583   g = get_handle (py_g);
1584   physvols = get_string_list (py_physvols);
1585   if (!physvols) return NULL;
1586
1587   r = guestfs_vgcreate (g, volgroup, physvols);
1588   free (physvols);
1589   if (r == -1) {
1590     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1591     return NULL;
1592   }
1593
1594   Py_INCREF (Py_None);
1595   py_r = Py_None;
1596   return py_r;
1597 }
1598
1599 static PyObject *
1600 py_guestfs_lvcreate (PyObject *self, PyObject *args)
1601 {
1602   PyObject *py_g;
1603   guestfs_h *g;
1604   PyObject *py_r;
1605   int r;
1606   const char *logvol;
1607   const char *volgroup;
1608   int mbytes;
1609
1610   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
1611                          &py_g, &logvol, &volgroup, &mbytes))
1612     return NULL;
1613   g = get_handle (py_g);
1614
1615   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1616   if (r == -1) {
1617     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1618     return NULL;
1619   }
1620
1621   Py_INCREF (Py_None);
1622   py_r = Py_None;
1623   return py_r;
1624 }
1625
1626 static PyObject *
1627 py_guestfs_mkfs (PyObject *self, PyObject *args)
1628 {
1629   PyObject *py_g;
1630   guestfs_h *g;
1631   PyObject *py_r;
1632   int r;
1633   const char *fstype;
1634   const char *device;
1635
1636   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
1637                          &py_g, &fstype, &device))
1638     return NULL;
1639   g = get_handle (py_g);
1640
1641   r = guestfs_mkfs (g, fstype, device);
1642   if (r == -1) {
1643     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1644     return NULL;
1645   }
1646
1647   Py_INCREF (Py_None);
1648   py_r = Py_None;
1649   return py_r;
1650 }
1651
1652 static PyObject *
1653 py_guestfs_sfdisk (PyObject *self, PyObject *args)
1654 {
1655   PyObject *py_g;
1656   guestfs_h *g;
1657   PyObject *py_r;
1658   int r;
1659   const char *device;
1660   int cyls;
1661   int heads;
1662   int sectors;
1663   PyObject *py_lines;
1664   const char **lines;
1665
1666   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
1667                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
1668     return NULL;
1669   g = get_handle (py_g);
1670   lines = get_string_list (py_lines);
1671   if (!lines) return NULL;
1672
1673   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1674   free (lines);
1675   if (r == -1) {
1676     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1677     return NULL;
1678   }
1679
1680   Py_INCREF (Py_None);
1681   py_r = Py_None;
1682   return py_r;
1683 }
1684
1685 static PyObject *
1686 py_guestfs_write_file (PyObject *self, PyObject *args)
1687 {
1688   PyObject *py_g;
1689   guestfs_h *g;
1690   PyObject *py_r;
1691   int r;
1692   const char *path;
1693   const char *content;
1694   int size;
1695
1696   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
1697                          &py_g, &path, &content, &size))
1698     return NULL;
1699   g = get_handle (py_g);
1700
1701   r = guestfs_write_file (g, path, content, size);
1702   if (r == -1) {
1703     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1704     return NULL;
1705   }
1706
1707   Py_INCREF (Py_None);
1708   py_r = Py_None;
1709   return py_r;
1710 }
1711
1712 static PyObject *
1713 py_guestfs_umount (PyObject *self, PyObject *args)
1714 {
1715   PyObject *py_g;
1716   guestfs_h *g;
1717   PyObject *py_r;
1718   int r;
1719   const char *pathordevice;
1720
1721   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
1722                          &py_g, &pathordevice))
1723     return NULL;
1724   g = get_handle (py_g);
1725
1726   r = guestfs_umount (g, pathordevice);
1727   if (r == -1) {
1728     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1729     return NULL;
1730   }
1731
1732   Py_INCREF (Py_None);
1733   py_r = Py_None;
1734   return py_r;
1735 }
1736
1737 static PyObject *
1738 py_guestfs_mounts (PyObject *self, PyObject *args)
1739 {
1740   PyObject *py_g;
1741   guestfs_h *g;
1742   PyObject *py_r;
1743   char **r;
1744
1745   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
1746                          &py_g))
1747     return NULL;
1748   g = get_handle (py_g);
1749
1750   r = guestfs_mounts (g);
1751   if (r == NULL) {
1752     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1753     return NULL;
1754   }
1755
1756   py_r = put_string_list (r);
1757   free_strings (r);
1758   return py_r;
1759 }
1760
1761 static PyObject *
1762 py_guestfs_umount_all (PyObject *self, PyObject *args)
1763 {
1764   PyObject *py_g;
1765   guestfs_h *g;
1766   PyObject *py_r;
1767   int r;
1768
1769   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
1770                          &py_g))
1771     return NULL;
1772   g = get_handle (py_g);
1773
1774   r = guestfs_umount_all (g);
1775   if (r == -1) {
1776     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1777     return NULL;
1778   }
1779
1780   Py_INCREF (Py_None);
1781   py_r = Py_None;
1782   return py_r;
1783 }
1784
1785 static PyObject *
1786 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
1787 {
1788   PyObject *py_g;
1789   guestfs_h *g;
1790   PyObject *py_r;
1791   int r;
1792
1793   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
1794                          &py_g))
1795     return NULL;
1796   g = get_handle (py_g);
1797
1798   r = guestfs_lvm_remove_all (g);
1799   if (r == -1) {
1800     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1801     return NULL;
1802   }
1803
1804   Py_INCREF (Py_None);
1805   py_r = Py_None;
1806   return py_r;
1807 }
1808
1809 static PyObject *
1810 py_guestfs_file (PyObject *self, PyObject *args)
1811 {
1812   PyObject *py_g;
1813   guestfs_h *g;
1814   PyObject *py_r;
1815   char *r;
1816   const char *path;
1817
1818   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
1819                          &py_g, &path))
1820     return NULL;
1821   g = get_handle (py_g);
1822
1823   r = guestfs_file (g, path);
1824   if (r == NULL) {
1825     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1826     return NULL;
1827   }
1828
1829   py_r = PyString_FromString (r);
1830   free (r);
1831   return py_r;
1832 }
1833
1834 static PyObject *
1835 py_guestfs_command (PyObject *self, PyObject *args)
1836 {
1837   PyObject *py_g;
1838   guestfs_h *g;
1839   PyObject *py_r;
1840   char *r;
1841   PyObject *py_arguments;
1842   const char **arguments;
1843
1844   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
1845                          &py_g, &py_arguments))
1846     return NULL;
1847   g = get_handle (py_g);
1848   arguments = get_string_list (py_arguments);
1849   if (!arguments) return NULL;
1850
1851   r = guestfs_command (g, arguments);
1852   free (arguments);
1853   if (r == NULL) {
1854     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1855     return NULL;
1856   }
1857
1858   py_r = PyString_FromString (r);
1859   free (r);
1860   return py_r;
1861 }
1862
1863 static PyObject *
1864 py_guestfs_command_lines (PyObject *self, PyObject *args)
1865 {
1866   PyObject *py_g;
1867   guestfs_h *g;
1868   PyObject *py_r;
1869   char **r;
1870   PyObject *py_arguments;
1871   const char **arguments;
1872
1873   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
1874                          &py_g, &py_arguments))
1875     return NULL;
1876   g = get_handle (py_g);
1877   arguments = get_string_list (py_arguments);
1878   if (!arguments) return NULL;
1879
1880   r = guestfs_command_lines (g, arguments);
1881   free (arguments);
1882   if (r == NULL) {
1883     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1884     return NULL;
1885   }
1886
1887   py_r = put_string_list (r);
1888   free_strings (r);
1889   return py_r;
1890 }
1891
1892 static PyMethodDef methods[] = {
1893   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
1894   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
1895   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
1896   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
1897   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
1898   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
1899   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
1900   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
1901   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
1902   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
1903   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
1904   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
1905   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
1906   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
1907   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
1908   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
1909   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
1910   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
1911   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
1912   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
1913   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
1914   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
1915   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
1916   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
1917   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
1918   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
1919   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
1920   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
1921   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
1922   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
1923   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
1924   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
1925   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
1926   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
1927   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
1928   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
1929   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
1930   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
1931   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
1932   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
1933   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
1934   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
1935   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
1936   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
1937   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
1938   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
1939   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
1940   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
1941   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
1942   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
1943   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
1944   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
1945   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
1946   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
1947   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
1948   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
1949   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
1950   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
1951   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
1952   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
1953   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
1954   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
1955   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
1956   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
1957   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
1958   { NULL, NULL, 0, NULL }
1959 };
1960
1961 void
1962 initlibguestfsmod (void)
1963 {
1964   static int initialized = 0;
1965
1966   if (initialized) return;
1967   Py_InitModule ((char *) "libguestfsmod", methods);
1968   initialized = 1;
1969 }