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 put_stat (struct guestfs_stat *stat)
 307 {
 308   PyObject *dict;
 309
 310   dict = PyDict_New ();
 311   PyDict_SetItemString (dict, "dev",
 312                         PyLong_FromLongLong (stat->dev));
 313   PyDict_SetItemString (dict, "ino",
 314                         PyLong_FromLongLong (stat->ino));
 315   PyDict_SetItemString (dict, "mode",
 316                         PyLong_FromLongLong (stat->mode));
 317   PyDict_SetItemString (dict, "nlink",
 318                         PyLong_FromLongLong (stat->nlink));
 319   PyDict_SetItemString (dict, "uid",
 320                         PyLong_FromLongLong (stat->uid));
 321   PyDict_SetItemString (dict, "gid",
 322                         PyLong_FromLongLong (stat->gid));
 323   PyDict_SetItemString (dict, "rdev",
 324                         PyLong_FromLongLong (stat->rdev));
 325   PyDict_SetItemString (dict, "size",
 326                         PyLong_FromLongLong (stat->size));
 327   PyDict_SetItemString (dict, "blksize",
 328                         PyLong_FromLongLong (stat->blksize));
 329   PyDict_SetItemString (dict, "blocks",
 330                         PyLong_FromLongLong (stat->blocks));
 331   PyDict_SetItemString (dict, "atime",
 332                         PyLong_FromLongLong (stat->atime));
 333   PyDict_SetItemString (dict, "mtime",
 334                         PyLong_FromLongLong (stat->mtime));
 335   PyDict_SetItemString (dict, "ctime",
 336                         PyLong_FromLongLong (stat->ctime));
 337   return dict;
 338 };
 339
 340 static PyObject *
 341 put_statvfs (struct guestfs_statvfs *statvfs)
 342 {
 343   PyObject *dict;
 344
 345   dict = PyDict_New ();
 346   PyDict_SetItemString (dict, "bsize",
 347                         PyLong_FromLongLong (statvfs->bsize));
 348   PyDict_SetItemString (dict, "frsize",
 349                         PyLong_FromLongLong (statvfs->frsize));
 350   PyDict_SetItemString (dict, "blocks",
 351                         PyLong_FromLongLong (statvfs->blocks));
 352   PyDict_SetItemString (dict, "bfree",
 353                         PyLong_FromLongLong (statvfs->bfree));
 354   PyDict_SetItemString (dict, "bavail",
 355                         PyLong_FromLongLong (statvfs->bavail));
 356   PyDict_SetItemString (dict, "files",
 357                         PyLong_FromLongLong (statvfs->files));
 358   PyDict_SetItemString (dict, "ffree",
 359                         PyLong_FromLongLong (statvfs->ffree));
 360   PyDict_SetItemString (dict, "favail",
 361                         PyLong_FromLongLong (statvfs->favail));
 362   PyDict_SetItemString (dict, "fsid",
 363                         PyLong_FromLongLong (statvfs->fsid));
 364   PyDict_SetItemString (dict, "flag",
 365                         PyLong_FromLongLong (statvfs->flag));
 366   PyDict_SetItemString (dict, "namemax",
 367                         PyLong_FromLongLong (statvfs->namemax));
 368   return dict;
 369 };
 370
 371 static PyObject *
 372 py_guestfs_launch (PyObject *self, PyObject *args)
 373 {
 374   PyObject *py_g;
 375   guestfs_h *g;
 376   PyObject *py_r;
 377   int r;
 378
 379   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch",
 380                          &py_g))
 381     return NULL;
 382   g = get_handle (py_g);
 383
 384   r = guestfs_launch (g);
 385   if (r == -1) {
 386     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 387     return NULL;
 388   }
 389
 390   Py_INCREF (Py_None);
 391   py_r = Py_None;
 392   return py_r;
 393 }
 394
 395 static PyObject *
 396 py_guestfs_wait_ready (PyObject *self, PyObject *args)
 397 {
 398   PyObject *py_g;
 399   guestfs_h *g;
 400   PyObject *py_r;
 401   int r;
 402
 403   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready",
 404                          &py_g))
 405     return NULL;
 406   g = get_handle (py_g);
 407
 408   r = guestfs_wait_ready (g);
 409   if (r == -1) {
 410     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 411     return NULL;
 412   }
 413
 414   Py_INCREF (Py_None);
 415   py_r = Py_None;
 416   return py_r;
 417 }
 418
 419 static PyObject *
 420 py_guestfs_kill_subprocess (PyObject *self, PyObject *args)
 421 {
 422   PyObject *py_g;
 423   guestfs_h *g;
 424   PyObject *py_r;
 425   int r;
 426
 427   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess",
 428                          &py_g))
 429     return NULL;
 430   g = get_handle (py_g);
 431
 432   r = guestfs_kill_subprocess (g);
 433   if (r == -1) {
 434     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 435     return NULL;
 436   }
 437
 438   Py_INCREF (Py_None);
 439   py_r = Py_None;
 440   return py_r;
 441 }
 442
 443 static PyObject *
 444 py_guestfs_add_drive (PyObject *self, PyObject *args)
 445 {
 446   PyObject *py_g;
 447   guestfs_h *g;
 448   PyObject *py_r;
 449   int r;
 450   const char *filename;
 451
 452   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive",
 453                          &py_g, &filename))
 454     return NULL;
 455   g = get_handle (py_g);
 456
 457   r = guestfs_add_drive (g, filename);
 458   if (r == -1) {
 459     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 460     return NULL;
 461   }
 462
 463   Py_INCREF (Py_None);
 464   py_r = Py_None;
 465   return py_r;
 466 }
 467
 468 static PyObject *
 469 py_guestfs_add_cdrom (PyObject *self, PyObject *args)
 470 {
 471   PyObject *py_g;
 472   guestfs_h *g;
 473   PyObject *py_r;
 474   int r;
 475   const char *filename;
 476
 477   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom",
 478                          &py_g, &filename))
 479     return NULL;
 480   g = get_handle (py_g);
 481
 482   r = guestfs_add_cdrom (g, filename);
 483   if (r == -1) {
 484     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 485     return NULL;
 486   }
 487
 488   Py_INCREF (Py_None);
 489   py_r = Py_None;
 490   return py_r;
 491 }
 492
 493 static PyObject *
 494 py_guestfs_config (PyObject *self, PyObject *args)
 495 {
 496   PyObject *py_g;
 497   guestfs_h *g;
 498   PyObject *py_r;
 499   int r;
 500   const char *qemuparam;
 501   const char *qemuvalue;
 502
 503   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config",
 504                          &py_g, &qemuparam, &qemuvalue))
 505     return NULL;
 506   g = get_handle (py_g);
 507
 508   r = guestfs_config (g, qemuparam, qemuvalue);
 509   if (r == -1) {
 510     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 511     return NULL;
 512   }
 513
 514   Py_INCREF (Py_None);
 515   py_r = Py_None;
 516   return py_r;
 517 }
 518
 519 static PyObject *
 520 py_guestfs_set_path (PyObject *self, PyObject *args)
 521 {
 522   PyObject *py_g;
 523   guestfs_h *g;
 524   PyObject *py_r;
 525   int r;
 526   const char *path;
 527
 528   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
 529                          &py_g, &path))
 530     return NULL;
 531   g = get_handle (py_g);
 532
 533   r = guestfs_set_path (g, path);
 534   if (r == -1) {
 535     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 536     return NULL;
 537   }
 538
 539   Py_INCREF (Py_None);
 540   py_r = Py_None;
 541   return py_r;
 542 }
 543
 544 static PyObject *
 545 py_guestfs_get_path (PyObject *self, PyObject *args)
 546 {
 547   PyObject *py_g;
 548   guestfs_h *g;
 549   PyObject *py_r;
 550   const char *r;
 551
 552   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
 553                          &py_g))
 554     return NULL;
 555   g = get_handle (py_g);
 556
 557   r = guestfs_get_path (g);
 558   if (r == NULL) {
 559     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 560     return NULL;
 561   }
 562
 563   py_r = PyString_FromString (r);
 564   return py_r;
 565 }
 566
 567 static PyObject *
 568 py_guestfs_set_autosync (PyObject *self, PyObject *args)
 569 {
 570   PyObject *py_g;
 571   guestfs_h *g;
 572   PyObject *py_r;
 573   int r;
 574   int autosync;
 575
 576   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
 577                          &py_g, &autosync))
 578     return NULL;
 579   g = get_handle (py_g);
 580
 581   r = guestfs_set_autosync (g, autosync);
 582   if (r == -1) {
 583     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 584     return NULL;
 585   }
 586
 587   Py_INCREF (Py_None);
 588   py_r = Py_None;
 589   return py_r;
 590 }
 591
 592 static PyObject *
 593 py_guestfs_get_autosync (PyObject *self, PyObject *args)
 594 {
 595   PyObject *py_g;
 596   guestfs_h *g;
 597   PyObject *py_r;
 598   int r;
 599
 600   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
 601                          &py_g))
 602     return NULL;
 603   g = get_handle (py_g);
 604
 605   r = guestfs_get_autosync (g);
 606   if (r == -1) {
 607     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 608     return NULL;
 609   }
 610
 611   py_r = PyInt_FromLong ((long) r);
 612   return py_r;
 613 }
 614
 615 static PyObject *
 616 py_guestfs_set_verbose (PyObject *self, PyObject *args)
 617 {
 618   PyObject *py_g;
 619   guestfs_h *g;
 620   PyObject *py_r;
 621   int r;
 622   int verbose;
 623
 624   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
 625                          &py_g, &verbose))
 626     return NULL;
 627   g = get_handle (py_g);
 628
 629   r = guestfs_set_verbose (g, verbose);
 630   if (r == -1) {
 631     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 632     return NULL;
 633   }
 634
 635   Py_INCREF (Py_None);
 636   py_r = Py_None;
 637   return py_r;
 638 }
 639
 640 static PyObject *
 641 py_guestfs_get_verbose (PyObject *self, PyObject *args)
 642 {
 643   PyObject *py_g;
 644   guestfs_h *g;
 645   PyObject *py_r;
 646   int r;
 647
 648   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
 649                          &py_g))
 650     return NULL;
 651   g = get_handle (py_g);
 652
 653   r = guestfs_get_verbose (g);
 654   if (r == -1) {
 655     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 656     return NULL;
 657   }
 658
 659   py_r = PyInt_FromLong ((long) r);
 660   return py_r;
 661 }
 662
 663 static PyObject *
 664 py_guestfs_mount (PyObject *self, PyObject *args)
 665 {
 666   PyObject *py_g;
 667   guestfs_h *g;
 668   PyObject *py_r;
 669   int r;
 670   const char *device;
 671   const char *mountpoint;
 672
 673   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
 674                          &py_g, &device, &mountpoint))
 675     return NULL;
 676   g = get_handle (py_g);
 677
 678   r = guestfs_mount (g, device, mountpoint);
 679   if (r == -1) {
 680     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 681     return NULL;
 682   }
 683
 684   Py_INCREF (Py_None);
 685   py_r = Py_None;
 686   return py_r;
 687 }
 688
 689 static PyObject *
 690 py_guestfs_sync (PyObject *self, PyObject *args)
 691 {
 692   PyObject *py_g;
 693   guestfs_h *g;
 694   PyObject *py_r;
 695   int r;
 696
 697   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
 698                          &py_g))
 699     return NULL;
 700   g = get_handle (py_g);
 701
 702   r = guestfs_sync (g);
 703   if (r == -1) {
 704     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 705     return NULL;
 706   }
 707
 708   Py_INCREF (Py_None);
 709   py_r = Py_None;
 710   return py_r;
 711 }
 712
 713 static PyObject *
 714 py_guestfs_touch (PyObject *self, PyObject *args)
 715 {
 716   PyObject *py_g;
 717   guestfs_h *g;
 718   PyObject *py_r;
 719   int r;
 720   const char *path;
 721
 722   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
 723                          &py_g, &path))
 724     return NULL;
 725   g = get_handle (py_g);
 726
 727   r = guestfs_touch (g, path);
 728   if (r == -1) {
 729     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 730     return NULL;
 731   }
 732
 733   Py_INCREF (Py_None);
 734   py_r = Py_None;
 735   return py_r;
 736 }
 737
 738 static PyObject *
 739 py_guestfs_cat (PyObject *self, PyObject *args)
 740 {
 741   PyObject *py_g;
 742   guestfs_h *g;
 743   PyObject *py_r;
 744   char *r;
 745   const char *path;
 746
 747   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
 748                          &py_g, &path))
 749     return NULL;
 750   g = get_handle (py_g);
 751
 752   r = guestfs_cat (g, path);
 753   if (r == NULL) {
 754     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 755     return NULL;
 756   }
 757
 758   py_r = PyString_FromString (r);
 759   free (r);
 760   return py_r;
 761 }
 762
 763 static PyObject *
 764 py_guestfs_ll (PyObject *self, PyObject *args)
 765 {
 766   PyObject *py_g;
 767   guestfs_h *g;
 768   PyObject *py_r;
 769   char *r;
 770   const char *directory;
 771
 772   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
 773                          &py_g, &directory))
 774     return NULL;
 775   g = get_handle (py_g);
 776
 777   r = guestfs_ll (g, directory);
 778   if (r == NULL) {
 779     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 780     return NULL;
 781   }
 782
 783   py_r = PyString_FromString (r);
 784   free (r);
 785   return py_r;
 786 }
 787
 788 static PyObject *
 789 py_guestfs_ls (PyObject *self, PyObject *args)
 790 {
 791   PyObject *py_g;
 792   guestfs_h *g;
 793   PyObject *py_r;
 794   char **r;
 795   const char *directory;
 796
 797   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
 798                          &py_g, &directory))
 799     return NULL;
 800   g = get_handle (py_g);
 801
 802   r = guestfs_ls (g, directory);
 803   if (r == NULL) {
 804     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 805     return NULL;
 806   }
 807
 808   py_r = put_string_list (r);
 809   free_strings (r);
 810   return py_r;
 811 }
 812
 813 static PyObject *
 814 py_guestfs_list_devices (PyObject *self, PyObject *args)
 815 {
 816   PyObject *py_g;
 817   guestfs_h *g;
 818   PyObject *py_r;
 819   char **r;
 820
 821   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
 822                          &py_g))
 823     return NULL;
 824   g = get_handle (py_g);
 825
 826   r = guestfs_list_devices (g);
 827   if (r == NULL) {
 828     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 829     return NULL;
 830   }
 831
 832   py_r = put_string_list (r);
 833   free_strings (r);
 834   return py_r;
 835 }
 836
 837 static PyObject *
 838 py_guestfs_list_partitions (PyObject *self, PyObject *args)
 839 {
 840   PyObject *py_g;
 841   guestfs_h *g;
 842   PyObject *py_r;
 843   char **r;
 844
 845   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
 846                          &py_g))
 847     return NULL;
 848   g = get_handle (py_g);
 849
 850   r = guestfs_list_partitions (g);
 851   if (r == NULL) {
 852     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 853     return NULL;
 854   }
 855
 856   py_r = put_string_list (r);
 857   free_strings (r);
 858   return py_r;
 859 }
 860
 861 static PyObject *
 862 py_guestfs_pvs (PyObject *self, PyObject *args)
 863 {
 864   PyObject *py_g;
 865   guestfs_h *g;
 866   PyObject *py_r;
 867   char **r;
 868
 869   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
 870                          &py_g))
 871     return NULL;
 872   g = get_handle (py_g);
 873
 874   r = guestfs_pvs (g);
 875   if (r == NULL) {
 876     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 877     return NULL;
 878   }
 879
 880   py_r = put_string_list (r);
 881   free_strings (r);
 882   return py_r;
 883 }
 884
 885 static PyObject *
 886 py_guestfs_vgs (PyObject *self, PyObject *args)
 887 {
 888   PyObject *py_g;
 889   guestfs_h *g;
 890   PyObject *py_r;
 891   char **r;
 892
 893   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
 894                          &py_g))
 895     return NULL;
 896   g = get_handle (py_g);
 897
 898   r = guestfs_vgs (g);
 899   if (r == NULL) {
 900     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 901     return NULL;
 902   }
 903
 904   py_r = put_string_list (r);
 905   free_strings (r);
 906   return py_r;
 907 }
 908
 909 static PyObject *
 910 py_guestfs_lvs (PyObject *self, PyObject *args)
 911 {
 912   PyObject *py_g;
 913   guestfs_h *g;
 914   PyObject *py_r;
 915   char **r;
 916
 917   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
 918                          &py_g))
 919     return NULL;
 920   g = get_handle (py_g);
 921
 922   r = guestfs_lvs (g);
 923   if (r == NULL) {
 924     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 925     return NULL;
 926   }
 927
 928   py_r = put_string_list (r);
 929   free_strings (r);
 930   return py_r;
 931 }
 932
 933 static PyObject *
 934 py_guestfs_pvs_full (PyObject *self, PyObject *args)
 935 {
 936   PyObject *py_g;
 937   guestfs_h *g;
 938   PyObject *py_r;
 939   struct guestfs_lvm_pv_list *r;
 940
 941   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
 942                          &py_g))
 943     return NULL;
 944   g = get_handle (py_g);
 945
 946   r = guestfs_pvs_full (g);
 947   if (r == NULL) {
 948     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 949     return NULL;
 950   }
 951
 952   py_r = put_lvm_pv_list (r);
 953   guestfs_free_lvm_pv_list (r);
 954   return py_r;
 955 }
 956
 957 static PyObject *
 958 py_guestfs_vgs_full (PyObject *self, PyObject *args)
 959 {
 960   PyObject *py_g;
 961   guestfs_h *g;
 962   PyObject *py_r;
 963   struct guestfs_lvm_vg_list *r;
 964
 965   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
 966                          &py_g))
 967     return NULL;
 968   g = get_handle (py_g);
 969
 970   r = guestfs_vgs_full (g);
 971   if (r == NULL) {
 972     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 973     return NULL;
 974   }
 975
 976   py_r = put_lvm_vg_list (r);
 977   guestfs_free_lvm_vg_list (r);
 978   return py_r;
 979 }
 980
 981 static PyObject *
 982 py_guestfs_lvs_full (PyObject *self, PyObject *args)
 983 {
 984   PyObject *py_g;
 985   guestfs_h *g;
 986   PyObject *py_r;
 987   struct guestfs_lvm_lv_list *r;
 988
 989   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
 990                          &py_g))
 991     return NULL;
 992   g = get_handle (py_g);
 993
 994   r = guestfs_lvs_full (g);
 995   if (r == NULL) {
 996     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 997     return NULL;
 998   }
 999
1000   py_r = put_lvm_lv_list (r);
1001   guestfs_free_lvm_lv_list (r);
1002   return py_r;
1003 }
1004
1005 static PyObject *
1006 py_guestfs_read_lines (PyObject *self, PyObject *args)
1007 {
1008   PyObject *py_g;
1009   guestfs_h *g;
1010   PyObject *py_r;
1011   char **r;
1012   const char *path;
1013
1014   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
1015                          &py_g, &path))
1016     return NULL;
1017   g = get_handle (py_g);
1018
1019   r = guestfs_read_lines (g, path);
1020   if (r == NULL) {
1021     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1022     return NULL;
1023   }
1024
1025   py_r = put_string_list (r);
1026   free_strings (r);
1027   return py_r;
1028 }
1029
1030 static PyObject *
1031 py_guestfs_aug_init (PyObject *self, PyObject *args)
1032 {
1033   PyObject *py_g;
1034   guestfs_h *g;
1035   PyObject *py_r;
1036   int r;
1037   const char *root;
1038   int flags;
1039
1040   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
1041                          &py_g, &root, &flags))
1042     return NULL;
1043   g = get_handle (py_g);
1044
1045   r = guestfs_aug_init (g, root, flags);
1046   if (r == -1) {
1047     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1048     return NULL;
1049   }
1050
1051   Py_INCREF (Py_None);
1052   py_r = Py_None;
1053   return py_r;
1054 }
1055
1056 static PyObject *
1057 py_guestfs_aug_close (PyObject *self, PyObject *args)
1058 {
1059   PyObject *py_g;
1060   guestfs_h *g;
1061   PyObject *py_r;
1062   int r;
1063
1064   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
1065                          &py_g))
1066     return NULL;
1067   g = get_handle (py_g);
1068
1069   r = guestfs_aug_close (g);
1070   if (r == -1) {
1071     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1072     return NULL;
1073   }
1074
1075   Py_INCREF (Py_None);
1076   py_r = Py_None;
1077   return py_r;
1078 }
1079
1080 static PyObject *
1081 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
1082 {
1083   PyObject *py_g;
1084   guestfs_h *g;
1085   PyObject *py_r;
1086   int r;
1087   const char *name;
1088   const char *expr;
1089
1090   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
1091                          &py_g, &name, &expr))
1092     return NULL;
1093   g = get_handle (py_g);
1094
1095   r = guestfs_aug_defvar (g, name, expr);
1096   if (r == -1) {
1097     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1098     return NULL;
1099   }
1100
1101   py_r = PyInt_FromLong ((long) r);
1102   return py_r;
1103 }
1104
1105 static PyObject *
1106 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
1107 {
1108   PyObject *py_g;
1109   guestfs_h *g;
1110   PyObject *py_r;
1111   struct guestfs_int_bool *r;
1112   const char *name;
1113   const char *expr;
1114   const char *val;
1115
1116   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
1117                          &py_g, &name, &expr, &val))
1118     return NULL;
1119   g = get_handle (py_g);
1120
1121   r = guestfs_aug_defnode (g, name, expr, val);
1122   if (r == NULL) {
1123     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1124     return NULL;
1125   }
1126
1127   py_r = PyTuple_New (2);
1128   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
1129   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
1130   guestfs_free_int_bool (r);
1131   return py_r;
1132 }
1133
1134 static PyObject *
1135 py_guestfs_aug_get (PyObject *self, PyObject *args)
1136 {
1137   PyObject *py_g;
1138   guestfs_h *g;
1139   PyObject *py_r;
1140   char *r;
1141   const char *path;
1142
1143   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
1144                          &py_g, &path))
1145     return NULL;
1146   g = get_handle (py_g);
1147
1148   r = guestfs_aug_get (g, path);
1149   if (r == NULL) {
1150     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1151     return NULL;
1152   }
1153
1154   py_r = PyString_FromString (r);
1155   free (r);
1156   return py_r;
1157 }
1158
1159 static PyObject *
1160 py_guestfs_aug_set (PyObject *self, PyObject *args)
1161 {
1162   PyObject *py_g;
1163   guestfs_h *g;
1164   PyObject *py_r;
1165   int r;
1166   const char *path;
1167   const char *val;
1168
1169   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
1170                          &py_g, &path, &val))
1171     return NULL;
1172   g = get_handle (py_g);
1173
1174   r = guestfs_aug_set (g, path, val);
1175   if (r == -1) {
1176     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1177     return NULL;
1178   }
1179
1180   Py_INCREF (Py_None);
1181   py_r = Py_None;
1182   return py_r;
1183 }
1184
1185 static PyObject *
1186 py_guestfs_aug_insert (PyObject *self, PyObject *args)
1187 {
1188   PyObject *py_g;
1189   guestfs_h *g;
1190   PyObject *py_r;
1191   int r;
1192   const char *path;
1193   const char *label;
1194   int before;
1195
1196   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
1197                          &py_g, &path, &label, &before))
1198     return NULL;
1199   g = get_handle (py_g);
1200
1201   r = guestfs_aug_insert (g, path, label, before);
1202   if (r == -1) {
1203     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1204     return NULL;
1205   }
1206
1207   Py_INCREF (Py_None);
1208   py_r = Py_None;
1209   return py_r;
1210 }
1211
1212 static PyObject *
1213 py_guestfs_aug_rm (PyObject *self, PyObject *args)
1214 {
1215   PyObject *py_g;
1216   guestfs_h *g;
1217   PyObject *py_r;
1218   int r;
1219   const char *path;
1220
1221   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
1222                          &py_g, &path))
1223     return NULL;
1224   g = get_handle (py_g);
1225
1226   r = guestfs_aug_rm (g, path);
1227   if (r == -1) {
1228     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1229     return NULL;
1230   }
1231
1232   py_r = PyInt_FromLong ((long) r);
1233   return py_r;
1234 }
1235
1236 static PyObject *
1237 py_guestfs_aug_mv (PyObject *self, PyObject *args)
1238 {
1239   PyObject *py_g;
1240   guestfs_h *g;
1241   PyObject *py_r;
1242   int r;
1243   const char *src;
1244   const char *dest;
1245
1246   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
1247                          &py_g, &src, &dest))
1248     return NULL;
1249   g = get_handle (py_g);
1250
1251   r = guestfs_aug_mv (g, src, dest);
1252   if (r == -1) {
1253     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1254     return NULL;
1255   }
1256
1257   Py_INCREF (Py_None);
1258   py_r = Py_None;
1259   return py_r;
1260 }
1261
1262 static PyObject *
1263 py_guestfs_aug_match (PyObject *self, PyObject *args)
1264 {
1265   PyObject *py_g;
1266   guestfs_h *g;
1267   PyObject *py_r;
1268   char **r;
1269   const char *path;
1270
1271   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
1272                          &py_g, &path))
1273     return NULL;
1274   g = get_handle (py_g);
1275
1276   r = guestfs_aug_match (g, path);
1277   if (r == NULL) {
1278     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1279     return NULL;
1280   }
1281
1282   py_r = put_string_list (r);
1283   free_strings (r);
1284   return py_r;
1285 }
1286
1287 static PyObject *
1288 py_guestfs_aug_save (PyObject *self, PyObject *args)
1289 {
1290   PyObject *py_g;
1291   guestfs_h *g;
1292   PyObject *py_r;
1293   int r;
1294
1295   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
1296                          &py_g))
1297     return NULL;
1298   g = get_handle (py_g);
1299
1300   r = guestfs_aug_save (g);
1301   if (r == -1) {
1302     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1303     return NULL;
1304   }
1305
1306   Py_INCREF (Py_None);
1307   py_r = Py_None;
1308   return py_r;
1309 }
1310
1311 static PyObject *
1312 py_guestfs_aug_load (PyObject *self, PyObject *args)
1313 {
1314   PyObject *py_g;
1315   guestfs_h *g;
1316   PyObject *py_r;
1317   int r;
1318
1319   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
1320                          &py_g))
1321     return NULL;
1322   g = get_handle (py_g);
1323
1324   r = guestfs_aug_load (g);
1325   if (r == -1) {
1326     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1327     return NULL;
1328   }
1329
1330   Py_INCREF (Py_None);
1331   py_r = Py_None;
1332   return py_r;
1333 }
1334
1335 static PyObject *
1336 py_guestfs_aug_ls (PyObject *self, PyObject *args)
1337 {
1338   PyObject *py_g;
1339   guestfs_h *g;
1340   PyObject *py_r;
1341   char **r;
1342   const char *path;
1343
1344   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
1345                          &py_g, &path))
1346     return NULL;
1347   g = get_handle (py_g);
1348
1349   r = guestfs_aug_ls (g, path);
1350   if (r == NULL) {
1351     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1352     return NULL;
1353   }
1354
1355   py_r = put_string_list (r);
1356   free_strings (r);
1357   return py_r;
1358 }
1359
1360 static PyObject *
1361 py_guestfs_rm (PyObject *self, PyObject *args)
1362 {
1363   PyObject *py_g;
1364   guestfs_h *g;
1365   PyObject *py_r;
1366   int r;
1367   const char *path;
1368
1369   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
1370                          &py_g, &path))
1371     return NULL;
1372   g = get_handle (py_g);
1373
1374   r = guestfs_rm (g, path);
1375   if (r == -1) {
1376     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1377     return NULL;
1378   }
1379
1380   Py_INCREF (Py_None);
1381   py_r = Py_None;
1382   return py_r;
1383 }
1384
1385 static PyObject *
1386 py_guestfs_rmdir (PyObject *self, PyObject *args)
1387 {
1388   PyObject *py_g;
1389   guestfs_h *g;
1390   PyObject *py_r;
1391   int r;
1392   const char *path;
1393
1394   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
1395                          &py_g, &path))
1396     return NULL;
1397   g = get_handle (py_g);
1398
1399   r = guestfs_rmdir (g, path);
1400   if (r == -1) {
1401     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1402     return NULL;
1403   }
1404
1405   Py_INCREF (Py_None);
1406   py_r = Py_None;
1407   return py_r;
1408 }
1409
1410 static PyObject *
1411 py_guestfs_rm_rf (PyObject *self, PyObject *args)
1412 {
1413   PyObject *py_g;
1414   guestfs_h *g;
1415   PyObject *py_r;
1416   int r;
1417   const char *path;
1418
1419   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
1420                          &py_g, &path))
1421     return NULL;
1422   g = get_handle (py_g);
1423
1424   r = guestfs_rm_rf (g, path);
1425   if (r == -1) {
1426     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1427     return NULL;
1428   }
1429
1430   Py_INCREF (Py_None);
1431   py_r = Py_None;
1432   return py_r;
1433 }
1434
1435 static PyObject *
1436 py_guestfs_mkdir (PyObject *self, PyObject *args)
1437 {
1438   PyObject *py_g;
1439   guestfs_h *g;
1440   PyObject *py_r;
1441   int r;
1442   const char *path;
1443
1444   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
1445                          &py_g, &path))
1446     return NULL;
1447   g = get_handle (py_g);
1448
1449   r = guestfs_mkdir (g, path);
1450   if (r == -1) {
1451     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1452     return NULL;
1453   }
1454
1455   Py_INCREF (Py_None);
1456   py_r = Py_None;
1457   return py_r;
1458 }
1459
1460 static PyObject *
1461 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
1462 {
1463   PyObject *py_g;
1464   guestfs_h *g;
1465   PyObject *py_r;
1466   int r;
1467   const char *path;
1468
1469   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
1470                          &py_g, &path))
1471     return NULL;
1472   g = get_handle (py_g);
1473
1474   r = guestfs_mkdir_p (g, path);
1475   if (r == -1) {
1476     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1477     return NULL;
1478   }
1479
1480   Py_INCREF (Py_None);
1481   py_r = Py_None;
1482   return py_r;
1483 }
1484
1485 static PyObject *
1486 py_guestfs_chmod (PyObject *self, PyObject *args)
1487 {
1488   PyObject *py_g;
1489   guestfs_h *g;
1490   PyObject *py_r;
1491   int r;
1492   int mode;
1493   const char *path;
1494
1495   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
1496                          &py_g, &mode, &path))
1497     return NULL;
1498   g = get_handle (py_g);
1499
1500   r = guestfs_chmod (g, mode, path);
1501   if (r == -1) {
1502     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1503     return NULL;
1504   }
1505
1506   Py_INCREF (Py_None);
1507   py_r = Py_None;
1508   return py_r;
1509 }
1510
1511 static PyObject *
1512 py_guestfs_chown (PyObject *self, PyObject *args)
1513 {
1514   PyObject *py_g;
1515   guestfs_h *g;
1516   PyObject *py_r;
1517   int r;
1518   int owner;
1519   int group;
1520   const char *path;
1521
1522   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
1523                          &py_g, &owner, &group, &path))
1524     return NULL;
1525   g = get_handle (py_g);
1526
1527   r = guestfs_chown (g, owner, group, path);
1528   if (r == -1) {
1529     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1530     return NULL;
1531   }
1532
1533   Py_INCREF (Py_None);
1534   py_r = Py_None;
1535   return py_r;
1536 }
1537
1538 static PyObject *
1539 py_guestfs_exists (PyObject *self, PyObject *args)
1540 {
1541   PyObject *py_g;
1542   guestfs_h *g;
1543   PyObject *py_r;
1544   int r;
1545   const char *path;
1546
1547   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
1548                          &py_g, &path))
1549     return NULL;
1550   g = get_handle (py_g);
1551
1552   r = guestfs_exists (g, path);
1553   if (r == -1) {
1554     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1555     return NULL;
1556   }
1557
1558   py_r = PyInt_FromLong ((long) r);
1559   return py_r;
1560 }
1561
1562 static PyObject *
1563 py_guestfs_is_file (PyObject *self, PyObject *args)
1564 {
1565   PyObject *py_g;
1566   guestfs_h *g;
1567   PyObject *py_r;
1568   int r;
1569   const char *path;
1570
1571   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
1572                          &py_g, &path))
1573     return NULL;
1574   g = get_handle (py_g);
1575
1576   r = guestfs_is_file (g, path);
1577   if (r == -1) {
1578     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1579     return NULL;
1580   }
1581
1582   py_r = PyInt_FromLong ((long) r);
1583   return py_r;
1584 }
1585
1586 static PyObject *
1587 py_guestfs_is_dir (PyObject *self, PyObject *args)
1588 {
1589   PyObject *py_g;
1590   guestfs_h *g;
1591   PyObject *py_r;
1592   int r;
1593   const char *path;
1594
1595   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
1596                          &py_g, &path))
1597     return NULL;
1598   g = get_handle (py_g);
1599
1600   r = guestfs_is_dir (g, path);
1601   if (r == -1) {
1602     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1603     return NULL;
1604   }
1605
1606   py_r = PyInt_FromLong ((long) r);
1607   return py_r;
1608 }
1609
1610 static PyObject *
1611 py_guestfs_pvcreate (PyObject *self, PyObject *args)
1612 {
1613   PyObject *py_g;
1614   guestfs_h *g;
1615   PyObject *py_r;
1616   int r;
1617   const char *device;
1618
1619   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
1620                          &py_g, &device))
1621     return NULL;
1622   g = get_handle (py_g);
1623
1624   r = guestfs_pvcreate (g, device);
1625   if (r == -1) {
1626     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1627     return NULL;
1628   }
1629
1630   Py_INCREF (Py_None);
1631   py_r = Py_None;
1632   return py_r;
1633 }
1634
1635 static PyObject *
1636 py_guestfs_vgcreate (PyObject *self, PyObject *args)
1637 {
1638   PyObject *py_g;
1639   guestfs_h *g;
1640   PyObject *py_r;
1641   int r;
1642   const char *volgroup;
1643   PyObject *py_physvols;
1644   const char **physvols;
1645
1646   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
1647                          &py_g, &volgroup, &py_physvols))
1648     return NULL;
1649   g = get_handle (py_g);
1650   physvols = get_string_list (py_physvols);
1651   if (!physvols) return NULL;
1652
1653   r = guestfs_vgcreate (g, volgroup, physvols);
1654   free (physvols);
1655   if (r == -1) {
1656     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1657     return NULL;
1658   }
1659
1660   Py_INCREF (Py_None);
1661   py_r = Py_None;
1662   return py_r;
1663 }
1664
1665 static PyObject *
1666 py_guestfs_lvcreate (PyObject *self, PyObject *args)
1667 {
1668   PyObject *py_g;
1669   guestfs_h *g;
1670   PyObject *py_r;
1671   int r;
1672   const char *logvol;
1673   const char *volgroup;
1674   int mbytes;
1675
1676   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
1677                          &py_g, &logvol, &volgroup, &mbytes))
1678     return NULL;
1679   g = get_handle (py_g);
1680
1681   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1682   if (r == -1) {
1683     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1684     return NULL;
1685   }
1686
1687   Py_INCREF (Py_None);
1688   py_r = Py_None;
1689   return py_r;
1690 }
1691
1692 static PyObject *
1693 py_guestfs_mkfs (PyObject *self, PyObject *args)
1694 {
1695   PyObject *py_g;
1696   guestfs_h *g;
1697   PyObject *py_r;
1698   int r;
1699   const char *fstype;
1700   const char *device;
1701
1702   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
1703                          &py_g, &fstype, &device))
1704     return NULL;
1705   g = get_handle (py_g);
1706
1707   r = guestfs_mkfs (g, fstype, device);
1708   if (r == -1) {
1709     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1710     return NULL;
1711   }
1712
1713   Py_INCREF (Py_None);
1714   py_r = Py_None;
1715   return py_r;
1716 }
1717
1718 static PyObject *
1719 py_guestfs_sfdisk (PyObject *self, PyObject *args)
1720 {
1721   PyObject *py_g;
1722   guestfs_h *g;
1723   PyObject *py_r;
1724   int r;
1725   const char *device;
1726   int cyls;
1727   int heads;
1728   int sectors;
1729   PyObject *py_lines;
1730   const char **lines;
1731
1732   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
1733                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
1734     return NULL;
1735   g = get_handle (py_g);
1736   lines = get_string_list (py_lines);
1737   if (!lines) return NULL;
1738
1739   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1740   free (lines);
1741   if (r == -1) {
1742     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1743     return NULL;
1744   }
1745
1746   Py_INCREF (Py_None);
1747   py_r = Py_None;
1748   return py_r;
1749 }
1750
1751 static PyObject *
1752 py_guestfs_write_file (PyObject *self, PyObject *args)
1753 {
1754   PyObject *py_g;
1755   guestfs_h *g;
1756   PyObject *py_r;
1757   int r;
1758   const char *path;
1759   const char *content;
1760   int size;
1761
1762   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
1763                          &py_g, &path, &content, &size))
1764     return NULL;
1765   g = get_handle (py_g);
1766
1767   r = guestfs_write_file (g, path, content, size);
1768   if (r == -1) {
1769     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1770     return NULL;
1771   }
1772
1773   Py_INCREF (Py_None);
1774   py_r = Py_None;
1775   return py_r;
1776 }
1777
1778 static PyObject *
1779 py_guestfs_umount (PyObject *self, PyObject *args)
1780 {
1781   PyObject *py_g;
1782   guestfs_h *g;
1783   PyObject *py_r;
1784   int r;
1785   const char *pathordevice;
1786
1787   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
1788                          &py_g, &pathordevice))
1789     return NULL;
1790   g = get_handle (py_g);
1791
1792   r = guestfs_umount (g, pathordevice);
1793   if (r == -1) {
1794     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1795     return NULL;
1796   }
1797
1798   Py_INCREF (Py_None);
1799   py_r = Py_None;
1800   return py_r;
1801 }
1802
1803 static PyObject *
1804 py_guestfs_mounts (PyObject *self, PyObject *args)
1805 {
1806   PyObject *py_g;
1807   guestfs_h *g;
1808   PyObject *py_r;
1809   char **r;
1810
1811   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
1812                          &py_g))
1813     return NULL;
1814   g = get_handle (py_g);
1815
1816   r = guestfs_mounts (g);
1817   if (r == NULL) {
1818     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1819     return NULL;
1820   }
1821
1822   py_r = put_string_list (r);
1823   free_strings (r);
1824   return py_r;
1825 }
1826
1827 static PyObject *
1828 py_guestfs_umount_all (PyObject *self, PyObject *args)
1829 {
1830   PyObject *py_g;
1831   guestfs_h *g;
1832   PyObject *py_r;
1833   int r;
1834
1835   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
1836                          &py_g))
1837     return NULL;
1838   g = get_handle (py_g);
1839
1840   r = guestfs_umount_all (g);
1841   if (r == -1) {
1842     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1843     return NULL;
1844   }
1845
1846   Py_INCREF (Py_None);
1847   py_r = Py_None;
1848   return py_r;
1849 }
1850
1851 static PyObject *
1852 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
1853 {
1854   PyObject *py_g;
1855   guestfs_h *g;
1856   PyObject *py_r;
1857   int r;
1858
1859   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
1860                          &py_g))
1861     return NULL;
1862   g = get_handle (py_g);
1863
1864   r = guestfs_lvm_remove_all (g);
1865   if (r == -1) {
1866     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1867     return NULL;
1868   }
1869
1870   Py_INCREF (Py_None);
1871   py_r = Py_None;
1872   return py_r;
1873 }
1874
1875 static PyObject *
1876 py_guestfs_file (PyObject *self, PyObject *args)
1877 {
1878   PyObject *py_g;
1879   guestfs_h *g;
1880   PyObject *py_r;
1881   char *r;
1882   const char *path;
1883
1884   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
1885                          &py_g, &path))
1886     return NULL;
1887   g = get_handle (py_g);
1888
1889   r = guestfs_file (g, path);
1890   if (r == NULL) {
1891     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1892     return NULL;
1893   }
1894
1895   py_r = PyString_FromString (r);
1896   free (r);
1897   return py_r;
1898 }
1899
1900 static PyObject *
1901 py_guestfs_command (PyObject *self, PyObject *args)
1902 {
1903   PyObject *py_g;
1904   guestfs_h *g;
1905   PyObject *py_r;
1906   char *r;
1907   PyObject *py_arguments;
1908   const char **arguments;
1909
1910   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
1911                          &py_g, &py_arguments))
1912     return NULL;
1913   g = get_handle (py_g);
1914   arguments = get_string_list (py_arguments);
1915   if (!arguments) return NULL;
1916
1917   r = guestfs_command (g, arguments);
1918   free (arguments);
1919   if (r == NULL) {
1920     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1921     return NULL;
1922   }
1923
1924   py_r = PyString_FromString (r);
1925   free (r);
1926   return py_r;
1927 }
1928
1929 static PyObject *
1930 py_guestfs_command_lines (PyObject *self, PyObject *args)
1931 {
1932   PyObject *py_g;
1933   guestfs_h *g;
1934   PyObject *py_r;
1935   char **r;
1936   PyObject *py_arguments;
1937   const char **arguments;
1938
1939   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
1940                          &py_g, &py_arguments))
1941     return NULL;
1942   g = get_handle (py_g);
1943   arguments = get_string_list (py_arguments);
1944   if (!arguments) return NULL;
1945
1946   r = guestfs_command_lines (g, arguments);
1947   free (arguments);
1948   if (r == NULL) {
1949     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1950     return NULL;
1951   }
1952
1953   py_r = put_string_list (r);
1954   free_strings (r);
1955   return py_r;
1956 }
1957
1958 static PyObject *
1959 py_guestfs_stat (PyObject *self, PyObject *args)
1960 {
1961   PyObject *py_g;
1962   guestfs_h *g;
1963   PyObject *py_r;
1964   struct guestfs_stat *r;
1965   const char *path;
1966
1967   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
1968                          &py_g, &path))
1969     return NULL;
1970   g = get_handle (py_g);
1971
1972   r = guestfs_stat (g, path);
1973   if (r == NULL) {
1974     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1975     return NULL;
1976   }
1977
1978   py_r = put_stat (r);
1979   free (r);
1980   return py_r;
1981 }
1982
1983 static PyObject *
1984 py_guestfs_lstat (PyObject *self, PyObject *args)
1985 {
1986   PyObject *py_g;
1987   guestfs_h *g;
1988   PyObject *py_r;
1989   struct guestfs_stat *r;
1990   const char *path;
1991
1992   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
1993                          &py_g, &path))
1994     return NULL;
1995   g = get_handle (py_g);
1996
1997   r = guestfs_lstat (g, path);
1998   if (r == NULL) {
1999     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2000     return NULL;
2001   }
2002
2003   py_r = put_stat (r);
2004   free (r);
2005   return py_r;
2006 }
2007
2008 static PyObject *
2009 py_guestfs_statvfs (PyObject *self, PyObject *args)
2010 {
2011   PyObject *py_g;
2012   guestfs_h *g;
2013   PyObject *py_r;
2014   struct guestfs_statvfs *r;
2015   const char *path;
2016
2017   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
2018                          &py_g, &path))
2019     return NULL;
2020   g = get_handle (py_g);
2021
2022   r = guestfs_statvfs (g, path);
2023   if (r == NULL) {
2024     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2025     return NULL;
2026   }
2027
2028   py_r = put_statvfs (r);
2029   free (r);
2030   return py_r;
2031 }
2032
2033 static PyMethodDef methods[] = {
2034   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
2035   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
2036   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
2037   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
2038   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
2039   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
2040   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
2041   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
2042   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
2043   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
2044   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
2045   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
2046   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
2047   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
2048   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
2049   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
2050   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
2051   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
2052   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
2053   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
2054   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
2055   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
2056   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
2057   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
2058   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
2059   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
2060   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
2061   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
2062   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
2063   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
2064   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
2065   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
2066   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
2067   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
2068   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
2069   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
2070   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
2071   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
2072   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
2073   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
2074   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
2075   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
2076   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
2077   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
2078   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
2079   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
2080   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
2081   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
2082   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
2083   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
2084   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
2085   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
2086   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
2087   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
2088   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
2089   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
2090   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
2091   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
2092   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
2093   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
2094   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
2095   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
2096   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
2097   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
2098   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
2099   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
2100   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
2101   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
2102   { NULL, NULL, 0, NULL }
2103 };
2104
2105 void
2106 initlibguestfsmod (void)
2107 {
2108   static int initialized = 0;
2109
2110   if (initialized) return;
2111   Py_InitModule ((char *) "libguestfsmod", methods);
2112   initialized = 1;
2113 }