python/guestfs-py.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <assert.h>
  25
  26 #include <Python.h>
  27
  28 #include "guestfs.h"
  29
  30 typedef struct {
  31   PyObject_HEAD
  32   guestfs_h *g;
  33 } Pyguestfs_Object;
  34
  35 static guestfs_h *
  36 get_handle (PyObject *obj)
  37 {
  38   assert (obj);
  39   assert (obj != Py_None);
  40   return ((Pyguestfs_Object *) obj)->g;
  41 }
  42
  43 static PyObject *
  44 put_handle (guestfs_h *g)
  45 {
  46   assert (g);
  47   return
  48     PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) "guestfs_h", NULL);
  49 }
  50
  51 /* This list should be freed (but not the strings) after use. */
  52 static const char **
  53 get_string_list (PyObject *obj)
  54 {
  55   int i, len;
  56   const char **r;
  57
  58   assert (obj);
  59
  60   if (!PyList_Check (obj)) {
  61     PyErr_SetString (PyExc_RuntimeError, "expecting a list parameter");
  62     return NULL;
  63   }
  64
  65   len = PyList_Size (obj);
  66   r = malloc (sizeof (char *) * (len+1));
  67   if (r == NULL) {
  68     PyErr_SetString (PyExc_RuntimeError, "get_string_list: out of memory");
  69     return NULL;
  70   }
  71
  72   for (i = 0; i < len; ++i)
  73     r[i] = PyString_AsString (PyList_GetItem (obj, i));
  74   r[len] = NULL;
  75
  76   return r;
  77 }
  78
  79 static PyObject *
  80 put_string_list (char * const * const argv)
  81 {
  82   PyObject *list;
  83   int argc, i;
  84
  85   for (argc = 0; argv[argc] != NULL; ++argc)
  86     ;
  87
  88   list = PyList_New (argc);
  89   for (i = 0; i < argc; ++i)
  90     PyList_SetItem (list, i, PyString_FromString (argv[i]));
  91
  92   return list;
  93 }
  94
  95 static PyObject *
  96 put_table (char * const * const argv)
  97 {
  98   PyObject *list, *item;
  99   int argc, i;
 100
 101   for (argc = 0; argv[argc] != NULL; ++argc)
 102     ;
 103
 104   list = PyList_New (argc >> 1);
 105   for (i = 0; i < argc; i += 2) {
 106     item = PyTuple_New (2);
 107     PyTuple_SetItem (item, 0, PyString_FromString (argv[i]));
 108     PyTuple_SetItem (item, 1, PyString_FromString (argv[i+1]));
 109     PyList_SetItem (list, i >> 1, item);
 110   }
 111
 112   return list;
 113 }
 114
 115 static void
 116 free_strings (char **argv)
 117 {
 118   int argc;
 119
 120   for (argc = 0; argv[argc] != NULL; ++argc)
 121     free (argv[argc]);
 122   free (argv);
 123 }
 124
 125 static PyObject *
 126 py_guestfs_create (PyObject *self, PyObject *args)
 127 {
 128   guestfs_h *g;
 129
 130   g = guestfs_create ();
 131   if (g == NULL) {
 132     PyErr_SetString (PyExc_RuntimeError,
 133                      "guestfs.create: failed to allocate handle");
 134     return NULL;
 135   }
 136   guestfs_set_error_handler (g, NULL, NULL);
 137   return put_handle (g);
 138 }
 139
 140 static PyObject *
 141 py_guestfs_close (PyObject *self, PyObject *args)
 142 {
 143   PyObject *py_g;
 144   guestfs_h *g;
 145
 146   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_close", &py_g))
 147     return NULL;
 148   g = get_handle (py_g);
 149
 150   guestfs_close (g);
 151
 152   Py_INCREF (Py_None);
 153   return Py_None;
 154 }
 155
 156 static PyObject *
 157 put_lvm_pv (struct guestfs_lvm_pv *pv)
 158 {
 159   PyObject *dict;
 160
 161   dict = PyDict_New ();
 162   PyDict_SetItemString (dict, "pv_name",
 163                         PyString_FromString (pv->pv_name));
 164   PyDict_SetItemString (dict, "pv_uuid",
 165                         PyString_FromStringAndSize (pv->pv_uuid, 32));
 166   PyDict_SetItemString (dict, "pv_fmt",
 167                         PyString_FromString (pv->pv_fmt));
 168   PyDict_SetItemString (dict, "pv_size",
 169                         PyLong_FromUnsignedLongLong (pv->pv_size));
 170   PyDict_SetItemString (dict, "dev_size",
 171                         PyLong_FromUnsignedLongLong (pv->dev_size));
 172   PyDict_SetItemString (dict, "pv_free",
 173                         PyLong_FromUnsignedLongLong (pv->pv_free));
 174   PyDict_SetItemString (dict, "pv_used",
 175                         PyLong_FromUnsignedLongLong (pv->pv_used));
 176   PyDict_SetItemString (dict, "pv_attr",
 177                         PyString_FromString (pv->pv_attr));
 178   PyDict_SetItemString (dict, "pv_pe_count",
 179                         PyLong_FromLongLong (pv->pv_pe_count));
 180   PyDict_SetItemString (dict, "pv_pe_alloc_count",
 181                         PyLong_FromLongLong (pv->pv_pe_alloc_count));
 182   PyDict_SetItemString (dict, "pv_tags",
 183                         PyString_FromString (pv->pv_tags));
 184   PyDict_SetItemString (dict, "pe_start",
 185                         PyLong_FromUnsignedLongLong (pv->pe_start));
 186   PyDict_SetItemString (dict, "pv_mda_count",
 187                         PyLong_FromLongLong (pv->pv_mda_count));
 188   PyDict_SetItemString (dict, "pv_mda_free",
 189                         PyLong_FromUnsignedLongLong (pv->pv_mda_free));
 190   return dict;
 191 };
 192
 193 static PyObject *
 194 put_lvm_pv_list (struct guestfs_lvm_pv_list *pvs)
 195 {
 196   PyObject *list;
 197   int i;
 198
 199   list = PyList_New (pvs->len);
 200   for (i = 0; i < pvs->len; ++i)
 201     PyList_SetItem (list, i, put_lvm_pv (&pvs->val[i]));
 202   return list;
 203 };
 204
 205 static PyObject *
 206 put_lvm_vg (struct guestfs_lvm_vg *vg)
 207 {
 208   PyObject *dict;
 209
 210   dict = PyDict_New ();
 211   PyDict_SetItemString (dict, "vg_name",
 212                         PyString_FromString (vg->vg_name));
 213   PyDict_SetItemString (dict, "vg_uuid",
 214                         PyString_FromStringAndSize (vg->vg_uuid, 32));
 215   PyDict_SetItemString (dict, "vg_fmt",
 216                         PyString_FromString (vg->vg_fmt));
 217   PyDict_SetItemString (dict, "vg_attr",
 218                         PyString_FromString (vg->vg_attr));
 219   PyDict_SetItemString (dict, "vg_size",
 220                         PyLong_FromUnsignedLongLong (vg->vg_size));
 221   PyDict_SetItemString (dict, "vg_free",
 222                         PyLong_FromUnsignedLongLong (vg->vg_free));
 223   PyDict_SetItemString (dict, "vg_sysid",
 224                         PyString_FromString (vg->vg_sysid));
 225   PyDict_SetItemString (dict, "vg_extent_size",
 226                         PyLong_FromUnsignedLongLong (vg->vg_extent_size));
 227   PyDict_SetItemString (dict, "vg_extent_count",
 228                         PyLong_FromLongLong (vg->vg_extent_count));
 229   PyDict_SetItemString (dict, "vg_free_count",
 230                         PyLong_FromLongLong (vg->vg_free_count));
 231   PyDict_SetItemString (dict, "max_lv",
 232                         PyLong_FromLongLong (vg->max_lv));
 233   PyDict_SetItemString (dict, "max_pv",
 234                         PyLong_FromLongLong (vg->max_pv));
 235   PyDict_SetItemString (dict, "pv_count",
 236                         PyLong_FromLongLong (vg->pv_count));
 237   PyDict_SetItemString (dict, "lv_count",
 238                         PyLong_FromLongLong (vg->lv_count));
 239   PyDict_SetItemString (dict, "snap_count",
 240                         PyLong_FromLongLong (vg->snap_count));
 241   PyDict_SetItemString (dict, "vg_seqno",
 242                         PyLong_FromLongLong (vg->vg_seqno));
 243   PyDict_SetItemString (dict, "vg_tags",
 244                         PyString_FromString (vg->vg_tags));
 245   PyDict_SetItemString (dict, "vg_mda_count",
 246                         PyLong_FromLongLong (vg->vg_mda_count));
 247   PyDict_SetItemString (dict, "vg_mda_free",
 248                         PyLong_FromUnsignedLongLong (vg->vg_mda_free));
 249   return dict;
 250 };
 251
 252 static PyObject *
 253 put_lvm_vg_list (struct guestfs_lvm_vg_list *vgs)
 254 {
 255   PyObject *list;
 256   int i;
 257
 258   list = PyList_New (vgs->len);
 259   for (i = 0; i < vgs->len; ++i)
 260     PyList_SetItem (list, i, put_lvm_vg (&vgs->val[i]));
 261   return list;
 262 };
 263
 264 static PyObject *
 265 put_lvm_lv (struct guestfs_lvm_lv *lv)
 266 {
 267   PyObject *dict;
 268
 269   dict = PyDict_New ();
 270   PyDict_SetItemString (dict, "lv_name",
 271                         PyString_FromString (lv->lv_name));
 272   PyDict_SetItemString (dict, "lv_uuid",
 273                         PyString_FromStringAndSize (lv->lv_uuid, 32));
 274   PyDict_SetItemString (dict, "lv_attr",
 275                         PyString_FromString (lv->lv_attr));
 276   PyDict_SetItemString (dict, "lv_major",
 277                         PyLong_FromLongLong (lv->lv_major));
 278   PyDict_SetItemString (dict, "lv_minor",
 279                         PyLong_FromLongLong (lv->lv_minor));
 280   PyDict_SetItemString (dict, "lv_kernel_major",
 281                         PyLong_FromLongLong (lv->lv_kernel_major));
 282   PyDict_SetItemString (dict, "lv_kernel_minor",
 283                         PyLong_FromLongLong (lv->lv_kernel_minor));
 284   PyDict_SetItemString (dict, "lv_size",
 285                         PyLong_FromUnsignedLongLong (lv->lv_size));
 286   PyDict_SetItemString (dict, "seg_count",
 287                         PyLong_FromLongLong (lv->seg_count));
 288   PyDict_SetItemString (dict, "origin",
 289                         PyString_FromString (lv->origin));
 290   if (lv->snap_percent >= 0)
 291     PyDict_SetItemString (dict, "snap_percent",
 292                           PyFloat_FromDouble ((double) lv->snap_percent));
 293   else {
 294     Py_INCREF (Py_None);
 295     PyDict_SetItemString (dict, "snap_percent", Py_None);  }
 296   if (lv->copy_percent >= 0)
 297     PyDict_SetItemString (dict, "copy_percent",
 298                           PyFloat_FromDouble ((double) lv->copy_percent));
 299   else {
 300     Py_INCREF (Py_None);
 301     PyDict_SetItemString (dict, "copy_percent", Py_None);  }
 302   PyDict_SetItemString (dict, "move_pv",
 303                         PyString_FromString (lv->move_pv));
 304   PyDict_SetItemString (dict, "lv_tags",
 305                         PyString_FromString (lv->lv_tags));
 306   PyDict_SetItemString (dict, "mirror_log",
 307                         PyString_FromString (lv->mirror_log));
 308   PyDict_SetItemString (dict, "modules",
 309                         PyString_FromString (lv->modules));
 310   return dict;
 311 };
 312
 313 static PyObject *
 314 put_lvm_lv_list (struct guestfs_lvm_lv_list *lvs)
 315 {
 316   PyObject *list;
 317   int i;
 318
 319   list = PyList_New (lvs->len);
 320   for (i = 0; i < lvs->len; ++i)
 321     PyList_SetItem (list, i, put_lvm_lv (&lvs->val[i]));
 322   return list;
 323 };
 324
 325 static PyObject *
 326 put_stat (struct guestfs_stat *stat)
 327 {
 328   PyObject *dict;
 329
 330   dict = PyDict_New ();
 331   PyDict_SetItemString (dict, "dev",
 332                         PyLong_FromLongLong (stat->dev));
 333   PyDict_SetItemString (dict, "ino",
 334                         PyLong_FromLongLong (stat->ino));
 335   PyDict_SetItemString (dict, "mode",
 336                         PyLong_FromLongLong (stat->mode));
 337   PyDict_SetItemString (dict, "nlink",
 338                         PyLong_FromLongLong (stat->nlink));
 339   PyDict_SetItemString (dict, "uid",
 340                         PyLong_FromLongLong (stat->uid));
 341   PyDict_SetItemString (dict, "gid",
 342                         PyLong_FromLongLong (stat->gid));
 343   PyDict_SetItemString (dict, "rdev",
 344                         PyLong_FromLongLong (stat->rdev));
 345   PyDict_SetItemString (dict, "size",
 346                         PyLong_FromLongLong (stat->size));
 347   PyDict_SetItemString (dict, "blksize",
 348                         PyLong_FromLongLong (stat->blksize));
 349   PyDict_SetItemString (dict, "blocks",
 350                         PyLong_FromLongLong (stat->blocks));
 351   PyDict_SetItemString (dict, "atime",
 352                         PyLong_FromLongLong (stat->atime));
 353   PyDict_SetItemString (dict, "mtime",
 354                         PyLong_FromLongLong (stat->mtime));
 355   PyDict_SetItemString (dict, "ctime",
 356                         PyLong_FromLongLong (stat->ctime));
 357   return dict;
 358 };
 359
 360 static PyObject *
 361 put_statvfs (struct guestfs_statvfs *statvfs)
 362 {
 363   PyObject *dict;
 364
 365   dict = PyDict_New ();
 366   PyDict_SetItemString (dict, "bsize",
 367                         PyLong_FromLongLong (statvfs->bsize));
 368   PyDict_SetItemString (dict, "frsize",
 369                         PyLong_FromLongLong (statvfs->frsize));
 370   PyDict_SetItemString (dict, "blocks",
 371                         PyLong_FromLongLong (statvfs->blocks));
 372   PyDict_SetItemString (dict, "bfree",
 373                         PyLong_FromLongLong (statvfs->bfree));
 374   PyDict_SetItemString (dict, "bavail",
 375                         PyLong_FromLongLong (statvfs->bavail));
 376   PyDict_SetItemString (dict, "files",
 377                         PyLong_FromLongLong (statvfs->files));
 378   PyDict_SetItemString (dict, "ffree",
 379                         PyLong_FromLongLong (statvfs->ffree));
 380   PyDict_SetItemString (dict, "favail",
 381                         PyLong_FromLongLong (statvfs->favail));
 382   PyDict_SetItemString (dict, "fsid",
 383                         PyLong_FromLongLong (statvfs->fsid));
 384   PyDict_SetItemString (dict, "flag",
 385                         PyLong_FromLongLong (statvfs->flag));
 386   PyDict_SetItemString (dict, "namemax",
 387                         PyLong_FromLongLong (statvfs->namemax));
 388   return dict;
 389 };
 390
 391 static PyObject *
 392 py_guestfs_launch (PyObject *self, PyObject *args)
 393 {
 394   PyObject *py_g;
 395   guestfs_h *g;
 396   PyObject *py_r;
 397   int r;
 398
 399   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch",
 400                          &py_g))
 401     return NULL;
 402   g = get_handle (py_g);
 403
 404   r = guestfs_launch (g);
 405   if (r == -1) {
 406     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 407     return NULL;
 408   }
 409
 410   Py_INCREF (Py_None);
 411   py_r = Py_None;
 412   return py_r;
 413 }
 414
 415 static PyObject *
 416 py_guestfs_wait_ready (PyObject *self, PyObject *args)
 417 {
 418   PyObject *py_g;
 419   guestfs_h *g;
 420   PyObject *py_r;
 421   int r;
 422
 423   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready",
 424                          &py_g))
 425     return NULL;
 426   g = get_handle (py_g);
 427
 428   r = guestfs_wait_ready (g);
 429   if (r == -1) {
 430     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 431     return NULL;
 432   }
 433
 434   Py_INCREF (Py_None);
 435   py_r = Py_None;
 436   return py_r;
 437 }
 438
 439 static PyObject *
 440 py_guestfs_kill_subprocess (PyObject *self, PyObject *args)
 441 {
 442   PyObject *py_g;
 443   guestfs_h *g;
 444   PyObject *py_r;
 445   int r;
 446
 447   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess",
 448                          &py_g))
 449     return NULL;
 450   g = get_handle (py_g);
 451
 452   r = guestfs_kill_subprocess (g);
 453   if (r == -1) {
 454     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 455     return NULL;
 456   }
 457
 458   Py_INCREF (Py_None);
 459   py_r = Py_None;
 460   return py_r;
 461 }
 462
 463 static PyObject *
 464 py_guestfs_add_drive (PyObject *self, PyObject *args)
 465 {
 466   PyObject *py_g;
 467   guestfs_h *g;
 468   PyObject *py_r;
 469   int r;
 470   const char *filename;
 471
 472   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive",
 473                          &py_g, &filename))
 474     return NULL;
 475   g = get_handle (py_g);
 476
 477   r = guestfs_add_drive (g, filename);
 478   if (r == -1) {
 479     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 480     return NULL;
 481   }
 482
 483   Py_INCREF (Py_None);
 484   py_r = Py_None;
 485   return py_r;
 486 }
 487
 488 static PyObject *
 489 py_guestfs_add_cdrom (PyObject *self, PyObject *args)
 490 {
 491   PyObject *py_g;
 492   guestfs_h *g;
 493   PyObject *py_r;
 494   int r;
 495   const char *filename;
 496
 497   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom",
 498                          &py_g, &filename))
 499     return NULL;
 500   g = get_handle (py_g);
 501
 502   r = guestfs_add_cdrom (g, filename);
 503   if (r == -1) {
 504     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 505     return NULL;
 506   }
 507
 508   Py_INCREF (Py_None);
 509   py_r = Py_None;
 510   return py_r;
 511 }
 512
 513 static PyObject *
 514 py_guestfs_config (PyObject *self, PyObject *args)
 515 {
 516   PyObject *py_g;
 517   guestfs_h *g;
 518   PyObject *py_r;
 519   int r;
 520   const char *qemuparam;
 521   const char *qemuvalue;
 522
 523   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config",
 524                          &py_g, &qemuparam, &qemuvalue))
 525     return NULL;
 526   g = get_handle (py_g);
 527
 528   r = guestfs_config (g, qemuparam, qemuvalue);
 529   if (r == -1) {
 530     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 531     return NULL;
 532   }
 533
 534   Py_INCREF (Py_None);
 535   py_r = Py_None;
 536   return py_r;
 537 }
 538
 539 static PyObject *
 540 py_guestfs_set_path (PyObject *self, PyObject *args)
 541 {
 542   PyObject *py_g;
 543   guestfs_h *g;
 544   PyObject *py_r;
 545   int r;
 546   const char *path;
 547
 548   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path",
 549                          &py_g, &path))
 550     return NULL;
 551   g = get_handle (py_g);
 552
 553   r = guestfs_set_path (g, path);
 554   if (r == -1) {
 555     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 556     return NULL;
 557   }
 558
 559   Py_INCREF (Py_None);
 560   py_r = Py_None;
 561   return py_r;
 562 }
 563
 564 static PyObject *
 565 py_guestfs_get_path (PyObject *self, PyObject *args)
 566 {
 567   PyObject *py_g;
 568   guestfs_h *g;
 569   PyObject *py_r;
 570   const char *r;
 571
 572   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path",
 573                          &py_g))
 574     return NULL;
 575   g = get_handle (py_g);
 576
 577   r = guestfs_get_path (g);
 578   if (r == NULL) {
 579     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 580     return NULL;
 581   }
 582
 583   py_r = PyString_FromString (r);
 584   return py_r;
 585 }
 586
 587 static PyObject *
 588 py_guestfs_set_autosync (PyObject *self, PyObject *args)
 589 {
 590   PyObject *py_g;
 591   guestfs_h *g;
 592   PyObject *py_r;
 593   int r;
 594   int autosync;
 595
 596   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync",
 597                          &py_g, &autosync))
 598     return NULL;
 599   g = get_handle (py_g);
 600
 601   r = guestfs_set_autosync (g, autosync);
 602   if (r == -1) {
 603     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 604     return NULL;
 605   }
 606
 607   Py_INCREF (Py_None);
 608   py_r = Py_None;
 609   return py_r;
 610 }
 611
 612 static PyObject *
 613 py_guestfs_get_autosync (PyObject *self, PyObject *args)
 614 {
 615   PyObject *py_g;
 616   guestfs_h *g;
 617   PyObject *py_r;
 618   int r;
 619
 620   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync",
 621                          &py_g))
 622     return NULL;
 623   g = get_handle (py_g);
 624
 625   r = guestfs_get_autosync (g);
 626   if (r == -1) {
 627     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 628     return NULL;
 629   }
 630
 631   py_r = PyInt_FromLong ((long) r);
 632   return py_r;
 633 }
 634
 635 static PyObject *
 636 py_guestfs_set_verbose (PyObject *self, PyObject *args)
 637 {
 638   PyObject *py_g;
 639   guestfs_h *g;
 640   PyObject *py_r;
 641   int r;
 642   int verbose;
 643
 644   if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose",
 645                          &py_g, &verbose))
 646     return NULL;
 647   g = get_handle (py_g);
 648
 649   r = guestfs_set_verbose (g, verbose);
 650   if (r == -1) {
 651     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 652     return NULL;
 653   }
 654
 655   Py_INCREF (Py_None);
 656   py_r = Py_None;
 657   return py_r;
 658 }
 659
 660 static PyObject *
 661 py_guestfs_get_verbose (PyObject *self, PyObject *args)
 662 {
 663   PyObject *py_g;
 664   guestfs_h *g;
 665   PyObject *py_r;
 666   int r;
 667
 668   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose",
 669                          &py_g))
 670     return NULL;
 671   g = get_handle (py_g);
 672
 673   r = guestfs_get_verbose (g);
 674   if (r == -1) {
 675     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 676     return NULL;
 677   }
 678
 679   py_r = PyInt_FromLong ((long) r);
 680   return py_r;
 681 }
 682
 683 static PyObject *
 684 py_guestfs_is_ready (PyObject *self, PyObject *args)
 685 {
 686   PyObject *py_g;
 687   guestfs_h *g;
 688   PyObject *py_r;
 689   int r;
 690
 691   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready",
 692                          &py_g))
 693     return NULL;
 694   g = get_handle (py_g);
 695
 696   r = guestfs_is_ready (g);
 697   if (r == -1) {
 698     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 699     return NULL;
 700   }
 701
 702   py_r = PyInt_FromLong ((long) r);
 703   return py_r;
 704 }
 705
 706 static PyObject *
 707 py_guestfs_is_config (PyObject *self, PyObject *args)
 708 {
 709   PyObject *py_g;
 710   guestfs_h *g;
 711   PyObject *py_r;
 712   int r;
 713
 714   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config",
 715                          &py_g))
 716     return NULL;
 717   g = get_handle (py_g);
 718
 719   r = guestfs_is_config (g);
 720   if (r == -1) {
 721     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 722     return NULL;
 723   }
 724
 725   py_r = PyInt_FromLong ((long) r);
 726   return py_r;
 727 }
 728
 729 static PyObject *
 730 py_guestfs_is_launching (PyObject *self, PyObject *args)
 731 {
 732   PyObject *py_g;
 733   guestfs_h *g;
 734   PyObject *py_r;
 735   int r;
 736
 737   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching",
 738                          &py_g))
 739     return NULL;
 740   g = get_handle (py_g);
 741
 742   r = guestfs_is_launching (g);
 743   if (r == -1) {
 744     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 745     return NULL;
 746   }
 747
 748   py_r = PyInt_FromLong ((long) r);
 749   return py_r;
 750 }
 751
 752 static PyObject *
 753 py_guestfs_is_busy (PyObject *self, PyObject *args)
 754 {
 755   PyObject *py_g;
 756   guestfs_h *g;
 757   PyObject *py_r;
 758   int r;
 759
 760   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy",
 761                          &py_g))
 762     return NULL;
 763   g = get_handle (py_g);
 764
 765   r = guestfs_is_busy (g);
 766   if (r == -1) {
 767     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 768     return NULL;
 769   }
 770
 771   py_r = PyInt_FromLong ((long) r);
 772   return py_r;
 773 }
 774
 775 static PyObject *
 776 py_guestfs_get_state (PyObject *self, PyObject *args)
 777 {
 778   PyObject *py_g;
 779   guestfs_h *g;
 780   PyObject *py_r;
 781   int r;
 782
 783   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state",
 784                          &py_g))
 785     return NULL;
 786   g = get_handle (py_g);
 787
 788   r = guestfs_get_state (g);
 789   if (r == -1) {
 790     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 791     return NULL;
 792   }
 793
 794   py_r = PyInt_FromLong ((long) r);
 795   return py_r;
 796 }
 797
 798 static PyObject *
 799 py_guestfs_set_busy (PyObject *self, PyObject *args)
 800 {
 801   PyObject *py_g;
 802   guestfs_h *g;
 803   PyObject *py_r;
 804   int r;
 805
 806   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy",
 807                          &py_g))
 808     return NULL;
 809   g = get_handle (py_g);
 810
 811   r = guestfs_set_busy (g);
 812   if (r == -1) {
 813     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 814     return NULL;
 815   }
 816
 817   Py_INCREF (Py_None);
 818   py_r = Py_None;
 819   return py_r;
 820 }
 821
 822 static PyObject *
 823 py_guestfs_set_ready (PyObject *self, PyObject *args)
 824 {
 825   PyObject *py_g;
 826   guestfs_h *g;
 827   PyObject *py_r;
 828   int r;
 829
 830   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_ready",
 831                          &py_g))
 832     return NULL;
 833   g = get_handle (py_g);
 834
 835   r = guestfs_set_ready (g);
 836   if (r == -1) {
 837     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 838     return NULL;
 839   }
 840
 841   Py_INCREF (Py_None);
 842   py_r = Py_None;
 843   return py_r;
 844 }
 845
 846 static PyObject *
 847 py_guestfs_mount (PyObject *self, PyObject *args)
 848 {
 849   PyObject *py_g;
 850   guestfs_h *g;
 851   PyObject *py_r;
 852   int r;
 853   const char *device;
 854   const char *mountpoint;
 855
 856   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount",
 857                          &py_g, &device, &mountpoint))
 858     return NULL;
 859   g = get_handle (py_g);
 860
 861   r = guestfs_mount (g, device, mountpoint);
 862   if (r == -1) {
 863     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 864     return NULL;
 865   }
 866
 867   Py_INCREF (Py_None);
 868   py_r = Py_None;
 869   return py_r;
 870 }
 871
 872 static PyObject *
 873 py_guestfs_sync (PyObject *self, PyObject *args)
 874 {
 875   PyObject *py_g;
 876   guestfs_h *g;
 877   PyObject *py_r;
 878   int r;
 879
 880   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync",
 881                          &py_g))
 882     return NULL;
 883   g = get_handle (py_g);
 884
 885   r = guestfs_sync (g);
 886   if (r == -1) {
 887     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 888     return NULL;
 889   }
 890
 891   Py_INCREF (Py_None);
 892   py_r = Py_None;
 893   return py_r;
 894 }
 895
 896 static PyObject *
 897 py_guestfs_touch (PyObject *self, PyObject *args)
 898 {
 899   PyObject *py_g;
 900   guestfs_h *g;
 901   PyObject *py_r;
 902   int r;
 903   const char *path;
 904
 905   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch",
 906                          &py_g, &path))
 907     return NULL;
 908   g = get_handle (py_g);
 909
 910   r = guestfs_touch (g, path);
 911   if (r == -1) {
 912     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 913     return NULL;
 914   }
 915
 916   Py_INCREF (Py_None);
 917   py_r = Py_None;
 918   return py_r;
 919 }
 920
 921 static PyObject *
 922 py_guestfs_cat (PyObject *self, PyObject *args)
 923 {
 924   PyObject *py_g;
 925   guestfs_h *g;
 926   PyObject *py_r;
 927   char *r;
 928   const char *path;
 929
 930   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat",
 931                          &py_g, &path))
 932     return NULL;
 933   g = get_handle (py_g);
 934
 935   r = guestfs_cat (g, path);
 936   if (r == NULL) {
 937     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 938     return NULL;
 939   }
 940
 941   py_r = PyString_FromString (r);
 942   free (r);
 943   return py_r;
 944 }
 945
 946 static PyObject *
 947 py_guestfs_ll (PyObject *self, PyObject *args)
 948 {
 949   PyObject *py_g;
 950   guestfs_h *g;
 951   PyObject *py_r;
 952   char *r;
 953   const char *directory;
 954
 955   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll",
 956                          &py_g, &directory))
 957     return NULL;
 958   g = get_handle (py_g);
 959
 960   r = guestfs_ll (g, directory);
 961   if (r == NULL) {
 962     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 963     return NULL;
 964   }
 965
 966   py_r = PyString_FromString (r);
 967   free (r);
 968   return py_r;
 969 }
 970
 971 static PyObject *
 972 py_guestfs_ls (PyObject *self, PyObject *args)
 973 {
 974   PyObject *py_g;
 975   guestfs_h *g;
 976   PyObject *py_r;
 977   char **r;
 978   const char *directory;
 979
 980   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls",
 981                          &py_g, &directory))
 982     return NULL;
 983   g = get_handle (py_g);
 984
 985   r = guestfs_ls (g, directory);
 986   if (r == NULL) {
 987     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
 988     return NULL;
 989   }
 990
 991   py_r = put_string_list (r);
 992   free_strings (r);
 993   return py_r;
 994 }
 995
 996 static PyObject *
 997 py_guestfs_list_devices (PyObject *self, PyObject *args)
 998 {
 999   PyObject *py_g;
1000   guestfs_h *g;
1001   PyObject *py_r;
1002   char **r;
1003
1004   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices",
1005                          &py_g))
1006     return NULL;
1007   g = get_handle (py_g);
1008
1009   r = guestfs_list_devices (g);
1010   if (r == NULL) {
1011     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1012     return NULL;
1013   }
1014
1015   py_r = put_string_list (r);
1016   free_strings (r);
1017   return py_r;
1018 }
1019
1020 static PyObject *
1021 py_guestfs_list_partitions (PyObject *self, PyObject *args)
1022 {
1023   PyObject *py_g;
1024   guestfs_h *g;
1025   PyObject *py_r;
1026   char **r;
1027
1028   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions",
1029                          &py_g))
1030     return NULL;
1031   g = get_handle (py_g);
1032
1033   r = guestfs_list_partitions (g);
1034   if (r == NULL) {
1035     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1036     return NULL;
1037   }
1038
1039   py_r = put_string_list (r);
1040   free_strings (r);
1041   return py_r;
1042 }
1043
1044 static PyObject *
1045 py_guestfs_pvs (PyObject *self, PyObject *args)
1046 {
1047   PyObject *py_g;
1048   guestfs_h *g;
1049   PyObject *py_r;
1050   char **r;
1051
1052   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs",
1053                          &py_g))
1054     return NULL;
1055   g = get_handle (py_g);
1056
1057   r = guestfs_pvs (g);
1058   if (r == NULL) {
1059     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1060     return NULL;
1061   }
1062
1063   py_r = put_string_list (r);
1064   free_strings (r);
1065   return py_r;
1066 }
1067
1068 static PyObject *
1069 py_guestfs_vgs (PyObject *self, PyObject *args)
1070 {
1071   PyObject *py_g;
1072   guestfs_h *g;
1073   PyObject *py_r;
1074   char **r;
1075
1076   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs",
1077                          &py_g))
1078     return NULL;
1079   g = get_handle (py_g);
1080
1081   r = guestfs_vgs (g);
1082   if (r == NULL) {
1083     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1084     return NULL;
1085   }
1086
1087   py_r = put_string_list (r);
1088   free_strings (r);
1089   return py_r;
1090 }
1091
1092 static PyObject *
1093 py_guestfs_lvs (PyObject *self, PyObject *args)
1094 {
1095   PyObject *py_g;
1096   guestfs_h *g;
1097   PyObject *py_r;
1098   char **r;
1099
1100   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs",
1101                          &py_g))
1102     return NULL;
1103   g = get_handle (py_g);
1104
1105   r = guestfs_lvs (g);
1106   if (r == NULL) {
1107     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1108     return NULL;
1109   }
1110
1111   py_r = put_string_list (r);
1112   free_strings (r);
1113   return py_r;
1114 }
1115
1116 static PyObject *
1117 py_guestfs_pvs_full (PyObject *self, PyObject *args)
1118 {
1119   PyObject *py_g;
1120   guestfs_h *g;
1121   PyObject *py_r;
1122   struct guestfs_lvm_pv_list *r;
1123
1124   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full",
1125                          &py_g))
1126     return NULL;
1127   g = get_handle (py_g);
1128
1129   r = guestfs_pvs_full (g);
1130   if (r == NULL) {
1131     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1132     return NULL;
1133   }
1134
1135   py_r = put_lvm_pv_list (r);
1136   guestfs_free_lvm_pv_list (r);
1137   return py_r;
1138 }
1139
1140 static PyObject *
1141 py_guestfs_vgs_full (PyObject *self, PyObject *args)
1142 {
1143   PyObject *py_g;
1144   guestfs_h *g;
1145   PyObject *py_r;
1146   struct guestfs_lvm_vg_list *r;
1147
1148   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full",
1149                          &py_g))
1150     return NULL;
1151   g = get_handle (py_g);
1152
1153   r = guestfs_vgs_full (g);
1154   if (r == NULL) {
1155     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1156     return NULL;
1157   }
1158
1159   py_r = put_lvm_vg_list (r);
1160   guestfs_free_lvm_vg_list (r);
1161   return py_r;
1162 }
1163
1164 static PyObject *
1165 py_guestfs_lvs_full (PyObject *self, PyObject *args)
1166 {
1167   PyObject *py_g;
1168   guestfs_h *g;
1169   PyObject *py_r;
1170   struct guestfs_lvm_lv_list *r;
1171
1172   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full",
1173                          &py_g))
1174     return NULL;
1175   g = get_handle (py_g);
1176
1177   r = guestfs_lvs_full (g);
1178   if (r == NULL) {
1179     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1180     return NULL;
1181   }
1182
1183   py_r = put_lvm_lv_list (r);
1184   guestfs_free_lvm_lv_list (r);
1185   return py_r;
1186 }
1187
1188 static PyObject *
1189 py_guestfs_read_lines (PyObject *self, PyObject *args)
1190 {
1191   PyObject *py_g;
1192   guestfs_h *g;
1193   PyObject *py_r;
1194   char **r;
1195   const char *path;
1196
1197   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines",
1198                          &py_g, &path))
1199     return NULL;
1200   g = get_handle (py_g);
1201
1202   r = guestfs_read_lines (g, path);
1203   if (r == NULL) {
1204     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1205     return NULL;
1206   }
1207
1208   py_r = put_string_list (r);
1209   free_strings (r);
1210   return py_r;
1211 }
1212
1213 static PyObject *
1214 py_guestfs_aug_init (PyObject *self, PyObject *args)
1215 {
1216   PyObject *py_g;
1217   guestfs_h *g;
1218   PyObject *py_r;
1219   int r;
1220   const char *root;
1221   int flags;
1222
1223   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init",
1224                          &py_g, &root, &flags))
1225     return NULL;
1226   g = get_handle (py_g);
1227
1228   r = guestfs_aug_init (g, root, flags);
1229   if (r == -1) {
1230     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1231     return NULL;
1232   }
1233
1234   Py_INCREF (Py_None);
1235   py_r = Py_None;
1236   return py_r;
1237 }
1238
1239 static PyObject *
1240 py_guestfs_aug_close (PyObject *self, PyObject *args)
1241 {
1242   PyObject *py_g;
1243   guestfs_h *g;
1244   PyObject *py_r;
1245   int r;
1246
1247   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close",
1248                          &py_g))
1249     return NULL;
1250   g = get_handle (py_g);
1251
1252   r = guestfs_aug_close (g);
1253   if (r == -1) {
1254     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1255     return NULL;
1256   }
1257
1258   Py_INCREF (Py_None);
1259   py_r = Py_None;
1260   return py_r;
1261 }
1262
1263 static PyObject *
1264 py_guestfs_aug_defvar (PyObject *self, PyObject *args)
1265 {
1266   PyObject *py_g;
1267   guestfs_h *g;
1268   PyObject *py_r;
1269   int r;
1270   const char *name;
1271   const char *expr;
1272
1273   if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar",
1274                          &py_g, &name, &expr))
1275     return NULL;
1276   g = get_handle (py_g);
1277
1278   r = guestfs_aug_defvar (g, name, expr);
1279   if (r == -1) {
1280     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1281     return NULL;
1282   }
1283
1284   py_r = PyInt_FromLong ((long) r);
1285   return py_r;
1286 }
1287
1288 static PyObject *
1289 py_guestfs_aug_defnode (PyObject *self, PyObject *args)
1290 {
1291   PyObject *py_g;
1292   guestfs_h *g;
1293   PyObject *py_r;
1294   struct guestfs_int_bool *r;
1295   const char *name;
1296   const char *expr;
1297   const char *val;
1298
1299   if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode",
1300                          &py_g, &name, &expr, &val))
1301     return NULL;
1302   g = get_handle (py_g);
1303
1304   r = guestfs_aug_defnode (g, name, expr, val);
1305   if (r == NULL) {
1306     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1307     return NULL;
1308   }
1309
1310   py_r = PyTuple_New (2);
1311   PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i));
1312   PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b));
1313   guestfs_free_int_bool (r);
1314   return py_r;
1315 }
1316
1317 static PyObject *
1318 py_guestfs_aug_get (PyObject *self, PyObject *args)
1319 {
1320   PyObject *py_g;
1321   guestfs_h *g;
1322   PyObject *py_r;
1323   char *r;
1324   const char *path;
1325
1326   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get",
1327                          &py_g, &path))
1328     return NULL;
1329   g = get_handle (py_g);
1330
1331   r = guestfs_aug_get (g, path);
1332   if (r == NULL) {
1333     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1334     return NULL;
1335   }
1336
1337   py_r = PyString_FromString (r);
1338   free (r);
1339   return py_r;
1340 }
1341
1342 static PyObject *
1343 py_guestfs_aug_set (PyObject *self, PyObject *args)
1344 {
1345   PyObject *py_g;
1346   guestfs_h *g;
1347   PyObject *py_r;
1348   int r;
1349   const char *path;
1350   const char *val;
1351
1352   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set",
1353                          &py_g, &path, &val))
1354     return NULL;
1355   g = get_handle (py_g);
1356
1357   r = guestfs_aug_set (g, path, val);
1358   if (r == -1) {
1359     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1360     return NULL;
1361   }
1362
1363   Py_INCREF (Py_None);
1364   py_r = Py_None;
1365   return py_r;
1366 }
1367
1368 static PyObject *
1369 py_guestfs_aug_insert (PyObject *self, PyObject *args)
1370 {
1371   PyObject *py_g;
1372   guestfs_h *g;
1373   PyObject *py_r;
1374   int r;
1375   const char *path;
1376   const char *label;
1377   int before;
1378
1379   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert",
1380                          &py_g, &path, &label, &before))
1381     return NULL;
1382   g = get_handle (py_g);
1383
1384   r = guestfs_aug_insert (g, path, label, before);
1385   if (r == -1) {
1386     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1387     return NULL;
1388   }
1389
1390   Py_INCREF (Py_None);
1391   py_r = Py_None;
1392   return py_r;
1393 }
1394
1395 static PyObject *
1396 py_guestfs_aug_rm (PyObject *self, PyObject *args)
1397 {
1398   PyObject *py_g;
1399   guestfs_h *g;
1400   PyObject *py_r;
1401   int r;
1402   const char *path;
1403
1404   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm",
1405                          &py_g, &path))
1406     return NULL;
1407   g = get_handle (py_g);
1408
1409   r = guestfs_aug_rm (g, path);
1410   if (r == -1) {
1411     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1412     return NULL;
1413   }
1414
1415   py_r = PyInt_FromLong ((long) r);
1416   return py_r;
1417 }
1418
1419 static PyObject *
1420 py_guestfs_aug_mv (PyObject *self, PyObject *args)
1421 {
1422   PyObject *py_g;
1423   guestfs_h *g;
1424   PyObject *py_r;
1425   int r;
1426   const char *src;
1427   const char *dest;
1428
1429   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv",
1430                          &py_g, &src, &dest))
1431     return NULL;
1432   g = get_handle (py_g);
1433
1434   r = guestfs_aug_mv (g, src, dest);
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_aug_match (PyObject *self, PyObject *args)
1447 {
1448   PyObject *py_g;
1449   guestfs_h *g;
1450   PyObject *py_r;
1451   char **r;
1452   const char *path;
1453
1454   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match",
1455                          &py_g, &path))
1456     return NULL;
1457   g = get_handle (py_g);
1458
1459   r = guestfs_aug_match (g, path);
1460   if (r == NULL) {
1461     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1462     return NULL;
1463   }
1464
1465   py_r = put_string_list (r);
1466   free_strings (r);
1467   return py_r;
1468 }
1469
1470 static PyObject *
1471 py_guestfs_aug_save (PyObject *self, PyObject *args)
1472 {
1473   PyObject *py_g;
1474   guestfs_h *g;
1475   PyObject *py_r;
1476   int r;
1477
1478   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save",
1479                          &py_g))
1480     return NULL;
1481   g = get_handle (py_g);
1482
1483   r = guestfs_aug_save (g);
1484   if (r == -1) {
1485     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1486     return NULL;
1487   }
1488
1489   Py_INCREF (Py_None);
1490   py_r = Py_None;
1491   return py_r;
1492 }
1493
1494 static PyObject *
1495 py_guestfs_aug_load (PyObject *self, PyObject *args)
1496 {
1497   PyObject *py_g;
1498   guestfs_h *g;
1499   PyObject *py_r;
1500   int r;
1501
1502   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load",
1503                          &py_g))
1504     return NULL;
1505   g = get_handle (py_g);
1506
1507   r = guestfs_aug_load (g);
1508   if (r == -1) {
1509     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1510     return NULL;
1511   }
1512
1513   Py_INCREF (Py_None);
1514   py_r = Py_None;
1515   return py_r;
1516 }
1517
1518 static PyObject *
1519 py_guestfs_aug_ls (PyObject *self, PyObject *args)
1520 {
1521   PyObject *py_g;
1522   guestfs_h *g;
1523   PyObject *py_r;
1524   char **r;
1525   const char *path;
1526
1527   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls",
1528                          &py_g, &path))
1529     return NULL;
1530   g = get_handle (py_g);
1531
1532   r = guestfs_aug_ls (g, path);
1533   if (r == NULL) {
1534     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1535     return NULL;
1536   }
1537
1538   py_r = put_string_list (r);
1539   free_strings (r);
1540   return py_r;
1541 }
1542
1543 static PyObject *
1544 py_guestfs_rm (PyObject *self, PyObject *args)
1545 {
1546   PyObject *py_g;
1547   guestfs_h *g;
1548   PyObject *py_r;
1549   int r;
1550   const char *path;
1551
1552   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm",
1553                          &py_g, &path))
1554     return NULL;
1555   g = get_handle (py_g);
1556
1557   r = guestfs_rm (g, path);
1558   if (r == -1) {
1559     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1560     return NULL;
1561   }
1562
1563   Py_INCREF (Py_None);
1564   py_r = Py_None;
1565   return py_r;
1566 }
1567
1568 static PyObject *
1569 py_guestfs_rmdir (PyObject *self, PyObject *args)
1570 {
1571   PyObject *py_g;
1572   guestfs_h *g;
1573   PyObject *py_r;
1574   int r;
1575   const char *path;
1576
1577   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir",
1578                          &py_g, &path))
1579     return NULL;
1580   g = get_handle (py_g);
1581
1582   r = guestfs_rmdir (g, path);
1583   if (r == -1) {
1584     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1585     return NULL;
1586   }
1587
1588   Py_INCREF (Py_None);
1589   py_r = Py_None;
1590   return py_r;
1591 }
1592
1593 static PyObject *
1594 py_guestfs_rm_rf (PyObject *self, PyObject *args)
1595 {
1596   PyObject *py_g;
1597   guestfs_h *g;
1598   PyObject *py_r;
1599   int r;
1600   const char *path;
1601
1602   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf",
1603                          &py_g, &path))
1604     return NULL;
1605   g = get_handle (py_g);
1606
1607   r = guestfs_rm_rf (g, path);
1608   if (r == -1) {
1609     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1610     return NULL;
1611   }
1612
1613   Py_INCREF (Py_None);
1614   py_r = Py_None;
1615   return py_r;
1616 }
1617
1618 static PyObject *
1619 py_guestfs_mkdir (PyObject *self, PyObject *args)
1620 {
1621   PyObject *py_g;
1622   guestfs_h *g;
1623   PyObject *py_r;
1624   int r;
1625   const char *path;
1626
1627   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir",
1628                          &py_g, &path))
1629     return NULL;
1630   g = get_handle (py_g);
1631
1632   r = guestfs_mkdir (g, path);
1633   if (r == -1) {
1634     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1635     return NULL;
1636   }
1637
1638   Py_INCREF (Py_None);
1639   py_r = Py_None;
1640   return py_r;
1641 }
1642
1643 static PyObject *
1644 py_guestfs_mkdir_p (PyObject *self, PyObject *args)
1645 {
1646   PyObject *py_g;
1647   guestfs_h *g;
1648   PyObject *py_r;
1649   int r;
1650   const char *path;
1651
1652   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p",
1653                          &py_g, &path))
1654     return NULL;
1655   g = get_handle (py_g);
1656
1657   r = guestfs_mkdir_p (g, path);
1658   if (r == -1) {
1659     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1660     return NULL;
1661   }
1662
1663   Py_INCREF (Py_None);
1664   py_r = Py_None;
1665   return py_r;
1666 }
1667
1668 static PyObject *
1669 py_guestfs_chmod (PyObject *self, PyObject *args)
1670 {
1671   PyObject *py_g;
1672   guestfs_h *g;
1673   PyObject *py_r;
1674   int r;
1675   int mode;
1676   const char *path;
1677
1678   if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod",
1679                          &py_g, &mode, &path))
1680     return NULL;
1681   g = get_handle (py_g);
1682
1683   r = guestfs_chmod (g, mode, path);
1684   if (r == -1) {
1685     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1686     return NULL;
1687   }
1688
1689   Py_INCREF (Py_None);
1690   py_r = Py_None;
1691   return py_r;
1692 }
1693
1694 static PyObject *
1695 py_guestfs_chown (PyObject *self, PyObject *args)
1696 {
1697   PyObject *py_g;
1698   guestfs_h *g;
1699   PyObject *py_r;
1700   int r;
1701   int owner;
1702   int group;
1703   const char *path;
1704
1705   if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown",
1706                          &py_g, &owner, &group, &path))
1707     return NULL;
1708   g = get_handle (py_g);
1709
1710   r = guestfs_chown (g, owner, group, path);
1711   if (r == -1) {
1712     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1713     return NULL;
1714   }
1715
1716   Py_INCREF (Py_None);
1717   py_r = Py_None;
1718   return py_r;
1719 }
1720
1721 static PyObject *
1722 py_guestfs_exists (PyObject *self, PyObject *args)
1723 {
1724   PyObject *py_g;
1725   guestfs_h *g;
1726   PyObject *py_r;
1727   int r;
1728   const char *path;
1729
1730   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists",
1731                          &py_g, &path))
1732     return NULL;
1733   g = get_handle (py_g);
1734
1735   r = guestfs_exists (g, path);
1736   if (r == -1) {
1737     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1738     return NULL;
1739   }
1740
1741   py_r = PyInt_FromLong ((long) r);
1742   return py_r;
1743 }
1744
1745 static PyObject *
1746 py_guestfs_is_file (PyObject *self, PyObject *args)
1747 {
1748   PyObject *py_g;
1749   guestfs_h *g;
1750   PyObject *py_r;
1751   int r;
1752   const char *path;
1753
1754   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file",
1755                          &py_g, &path))
1756     return NULL;
1757   g = get_handle (py_g);
1758
1759   r = guestfs_is_file (g, path);
1760   if (r == -1) {
1761     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1762     return NULL;
1763   }
1764
1765   py_r = PyInt_FromLong ((long) r);
1766   return py_r;
1767 }
1768
1769 static PyObject *
1770 py_guestfs_is_dir (PyObject *self, PyObject *args)
1771 {
1772   PyObject *py_g;
1773   guestfs_h *g;
1774   PyObject *py_r;
1775   int r;
1776   const char *path;
1777
1778   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir",
1779                          &py_g, &path))
1780     return NULL;
1781   g = get_handle (py_g);
1782
1783   r = guestfs_is_dir (g, path);
1784   if (r == -1) {
1785     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1786     return NULL;
1787   }
1788
1789   py_r = PyInt_FromLong ((long) r);
1790   return py_r;
1791 }
1792
1793 static PyObject *
1794 py_guestfs_pvcreate (PyObject *self, PyObject *args)
1795 {
1796   PyObject *py_g;
1797   guestfs_h *g;
1798   PyObject *py_r;
1799   int r;
1800   const char *device;
1801
1802   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate",
1803                          &py_g, &device))
1804     return NULL;
1805   g = get_handle (py_g);
1806
1807   r = guestfs_pvcreate (g, device);
1808   if (r == -1) {
1809     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1810     return NULL;
1811   }
1812
1813   Py_INCREF (Py_None);
1814   py_r = Py_None;
1815   return py_r;
1816 }
1817
1818 static PyObject *
1819 py_guestfs_vgcreate (PyObject *self, PyObject *args)
1820 {
1821   PyObject *py_g;
1822   guestfs_h *g;
1823   PyObject *py_r;
1824   int r;
1825   const char *volgroup;
1826   PyObject *py_physvols;
1827   const char **physvols;
1828
1829   if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate",
1830                          &py_g, &volgroup, &py_physvols))
1831     return NULL;
1832   g = get_handle (py_g);
1833   physvols = get_string_list (py_physvols);
1834   if (!physvols) return NULL;
1835
1836   r = guestfs_vgcreate (g, volgroup, physvols);
1837   free (physvols);
1838   if (r == -1) {
1839     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1840     return NULL;
1841   }
1842
1843   Py_INCREF (Py_None);
1844   py_r = Py_None;
1845   return py_r;
1846 }
1847
1848 static PyObject *
1849 py_guestfs_lvcreate (PyObject *self, PyObject *args)
1850 {
1851   PyObject *py_g;
1852   guestfs_h *g;
1853   PyObject *py_r;
1854   int r;
1855   const char *logvol;
1856   const char *volgroup;
1857   int mbytes;
1858
1859   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate",
1860                          &py_g, &logvol, &volgroup, &mbytes))
1861     return NULL;
1862   g = get_handle (py_g);
1863
1864   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
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_mkfs (PyObject *self, PyObject *args)
1877 {
1878   PyObject *py_g;
1879   guestfs_h *g;
1880   PyObject *py_r;
1881   int r;
1882   const char *fstype;
1883   const char *device;
1884
1885   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs",
1886                          &py_g, &fstype, &device))
1887     return NULL;
1888   g = get_handle (py_g);
1889
1890   r = guestfs_mkfs (g, fstype, device);
1891   if (r == -1) {
1892     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1893     return NULL;
1894   }
1895
1896   Py_INCREF (Py_None);
1897   py_r = Py_None;
1898   return py_r;
1899 }
1900
1901 static PyObject *
1902 py_guestfs_sfdisk (PyObject *self, PyObject *args)
1903 {
1904   PyObject *py_g;
1905   guestfs_h *g;
1906   PyObject *py_r;
1907   int r;
1908   const char *device;
1909   int cyls;
1910   int heads;
1911   int sectors;
1912   PyObject *py_lines;
1913   const char **lines;
1914
1915   if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk",
1916                          &py_g, &device, &cyls, &heads, &sectors, &py_lines))
1917     return NULL;
1918   g = get_handle (py_g);
1919   lines = get_string_list (py_lines);
1920   if (!lines) return NULL;
1921
1922   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1923   free (lines);
1924   if (r == -1) {
1925     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1926     return NULL;
1927   }
1928
1929   Py_INCREF (Py_None);
1930   py_r = Py_None;
1931   return py_r;
1932 }
1933
1934 static PyObject *
1935 py_guestfs_write_file (PyObject *self, PyObject *args)
1936 {
1937   PyObject *py_g;
1938   guestfs_h *g;
1939   PyObject *py_r;
1940   int r;
1941   const char *path;
1942   const char *content;
1943   int size;
1944
1945   if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file",
1946                          &py_g, &path, &content, &size))
1947     return NULL;
1948   g = get_handle (py_g);
1949
1950   r = guestfs_write_file (g, path, content, size);
1951   if (r == -1) {
1952     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1953     return NULL;
1954   }
1955
1956   Py_INCREF (Py_None);
1957   py_r = Py_None;
1958   return py_r;
1959 }
1960
1961 static PyObject *
1962 py_guestfs_umount (PyObject *self, PyObject *args)
1963 {
1964   PyObject *py_g;
1965   guestfs_h *g;
1966   PyObject *py_r;
1967   int r;
1968   const char *pathordevice;
1969
1970   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount",
1971                          &py_g, &pathordevice))
1972     return NULL;
1973   g = get_handle (py_g);
1974
1975   r = guestfs_umount (g, pathordevice);
1976   if (r == -1) {
1977     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
1978     return NULL;
1979   }
1980
1981   Py_INCREF (Py_None);
1982   py_r = Py_None;
1983   return py_r;
1984 }
1985
1986 static PyObject *
1987 py_guestfs_mounts (PyObject *self, PyObject *args)
1988 {
1989   PyObject *py_g;
1990   guestfs_h *g;
1991   PyObject *py_r;
1992   char **r;
1993
1994   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts",
1995                          &py_g))
1996     return NULL;
1997   g = get_handle (py_g);
1998
1999   r = guestfs_mounts (g);
2000   if (r == NULL) {
2001     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2002     return NULL;
2003   }
2004
2005   py_r = put_string_list (r);
2006   free_strings (r);
2007   return py_r;
2008 }
2009
2010 static PyObject *
2011 py_guestfs_umount_all (PyObject *self, PyObject *args)
2012 {
2013   PyObject *py_g;
2014   guestfs_h *g;
2015   PyObject *py_r;
2016   int r;
2017
2018   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all",
2019                          &py_g))
2020     return NULL;
2021   g = get_handle (py_g);
2022
2023   r = guestfs_umount_all (g);
2024   if (r == -1) {
2025     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2026     return NULL;
2027   }
2028
2029   Py_INCREF (Py_None);
2030   py_r = Py_None;
2031   return py_r;
2032 }
2033
2034 static PyObject *
2035 py_guestfs_lvm_remove_all (PyObject *self, PyObject *args)
2036 {
2037   PyObject *py_g;
2038   guestfs_h *g;
2039   PyObject *py_r;
2040   int r;
2041
2042   if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all",
2043                          &py_g))
2044     return NULL;
2045   g = get_handle (py_g);
2046
2047   r = guestfs_lvm_remove_all (g);
2048   if (r == -1) {
2049     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2050     return NULL;
2051   }
2052
2053   Py_INCREF (Py_None);
2054   py_r = Py_None;
2055   return py_r;
2056 }
2057
2058 static PyObject *
2059 py_guestfs_file (PyObject *self, PyObject *args)
2060 {
2061   PyObject *py_g;
2062   guestfs_h *g;
2063   PyObject *py_r;
2064   char *r;
2065   const char *path;
2066
2067   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file",
2068                          &py_g, &path))
2069     return NULL;
2070   g = get_handle (py_g);
2071
2072   r = guestfs_file (g, path);
2073   if (r == NULL) {
2074     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2075     return NULL;
2076   }
2077
2078   py_r = PyString_FromString (r);
2079   free (r);
2080   return py_r;
2081 }
2082
2083 static PyObject *
2084 py_guestfs_command (PyObject *self, PyObject *args)
2085 {
2086   PyObject *py_g;
2087   guestfs_h *g;
2088   PyObject *py_r;
2089   char *r;
2090   PyObject *py_arguments;
2091   const char **arguments;
2092
2093   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command",
2094                          &py_g, &py_arguments))
2095     return NULL;
2096   g = get_handle (py_g);
2097   arguments = get_string_list (py_arguments);
2098   if (!arguments) return NULL;
2099
2100   r = guestfs_command (g, arguments);
2101   free (arguments);
2102   if (r == NULL) {
2103     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2104     return NULL;
2105   }
2106
2107   py_r = PyString_FromString (r);
2108   free (r);
2109   return py_r;
2110 }
2111
2112 static PyObject *
2113 py_guestfs_command_lines (PyObject *self, PyObject *args)
2114 {
2115   PyObject *py_g;
2116   guestfs_h *g;
2117   PyObject *py_r;
2118   char **r;
2119   PyObject *py_arguments;
2120   const char **arguments;
2121
2122   if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines",
2123                          &py_g, &py_arguments))
2124     return NULL;
2125   g = get_handle (py_g);
2126   arguments = get_string_list (py_arguments);
2127   if (!arguments) return NULL;
2128
2129   r = guestfs_command_lines (g, arguments);
2130   free (arguments);
2131   if (r == NULL) {
2132     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2133     return NULL;
2134   }
2135
2136   py_r = put_string_list (r);
2137   free_strings (r);
2138   return py_r;
2139 }
2140
2141 static PyObject *
2142 py_guestfs_stat (PyObject *self, PyObject *args)
2143 {
2144   PyObject *py_g;
2145   guestfs_h *g;
2146   PyObject *py_r;
2147   struct guestfs_stat *r;
2148   const char *path;
2149
2150   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat",
2151                          &py_g, &path))
2152     return NULL;
2153   g = get_handle (py_g);
2154
2155   r = guestfs_stat (g, path);
2156   if (r == NULL) {
2157     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2158     return NULL;
2159   }
2160
2161   py_r = put_stat (r);
2162   free (r);
2163   return py_r;
2164 }
2165
2166 static PyObject *
2167 py_guestfs_lstat (PyObject *self, PyObject *args)
2168 {
2169   PyObject *py_g;
2170   guestfs_h *g;
2171   PyObject *py_r;
2172   struct guestfs_stat *r;
2173   const char *path;
2174
2175   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat",
2176                          &py_g, &path))
2177     return NULL;
2178   g = get_handle (py_g);
2179
2180   r = guestfs_lstat (g, path);
2181   if (r == NULL) {
2182     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2183     return NULL;
2184   }
2185
2186   py_r = put_stat (r);
2187   free (r);
2188   return py_r;
2189 }
2190
2191 static PyObject *
2192 py_guestfs_statvfs (PyObject *self, PyObject *args)
2193 {
2194   PyObject *py_g;
2195   guestfs_h *g;
2196   PyObject *py_r;
2197   struct guestfs_statvfs *r;
2198   const char *path;
2199
2200   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs",
2201                          &py_g, &path))
2202     return NULL;
2203   g = get_handle (py_g);
2204
2205   r = guestfs_statvfs (g, path);
2206   if (r == NULL) {
2207     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2208     return NULL;
2209   }
2210
2211   py_r = put_statvfs (r);
2212   free (r);
2213   return py_r;
2214 }
2215
2216 static PyObject *
2217 py_guestfs_tune2fs_l (PyObject *self, PyObject *args)
2218 {
2219   PyObject *py_g;
2220   guestfs_h *g;
2221   PyObject *py_r;
2222   char **r;
2223   const char *device;
2224
2225   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l",
2226                          &py_g, &device))
2227     return NULL;
2228   g = get_handle (py_g);
2229
2230   r = guestfs_tune2fs_l (g, device);
2231   if (r == NULL) {
2232     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2233     return NULL;
2234   }
2235
2236   py_r = put_table (r);
2237   free_strings (r);
2238   return py_r;
2239 }
2240
2241 static PyObject *
2242 py_guestfs_blockdev_setro (PyObject *self, PyObject *args)
2243 {
2244   PyObject *py_g;
2245   guestfs_h *g;
2246   PyObject *py_r;
2247   int r;
2248   const char *device;
2249
2250   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro",
2251                          &py_g, &device))
2252     return NULL;
2253   g = get_handle (py_g);
2254
2255   r = guestfs_blockdev_setro (g, device);
2256   if (r == -1) {
2257     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2258     return NULL;
2259   }
2260
2261   Py_INCREF (Py_None);
2262   py_r = Py_None;
2263   return py_r;
2264 }
2265
2266 static PyObject *
2267 py_guestfs_blockdev_setrw (PyObject *self, PyObject *args)
2268 {
2269   PyObject *py_g;
2270   guestfs_h *g;
2271   PyObject *py_r;
2272   int r;
2273   const char *device;
2274
2275   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw",
2276                          &py_g, &device))
2277     return NULL;
2278   g = get_handle (py_g);
2279
2280   r = guestfs_blockdev_setrw (g, device);
2281   if (r == -1) {
2282     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2283     return NULL;
2284   }
2285
2286   Py_INCREF (Py_None);
2287   py_r = Py_None;
2288   return py_r;
2289 }
2290
2291 static PyObject *
2292 py_guestfs_blockdev_getro (PyObject *self, PyObject *args)
2293 {
2294   PyObject *py_g;
2295   guestfs_h *g;
2296   PyObject *py_r;
2297   int r;
2298   const char *device;
2299
2300   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro",
2301                          &py_g, &device))
2302     return NULL;
2303   g = get_handle (py_g);
2304
2305   r = guestfs_blockdev_getro (g, device);
2306   if (r == -1) {
2307     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2308     return NULL;
2309   }
2310
2311   py_r = PyInt_FromLong ((long) r);
2312   return py_r;
2313 }
2314
2315 static PyObject *
2316 py_guestfs_blockdev_getss (PyObject *self, PyObject *args)
2317 {
2318   PyObject *py_g;
2319   guestfs_h *g;
2320   PyObject *py_r;
2321   int r;
2322   const char *device;
2323
2324   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss",
2325                          &py_g, &device))
2326     return NULL;
2327   g = get_handle (py_g);
2328
2329   r = guestfs_blockdev_getss (g, device);
2330   if (r == -1) {
2331     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2332     return NULL;
2333   }
2334
2335   py_r = PyInt_FromLong ((long) r);
2336   return py_r;
2337 }
2338
2339 static PyObject *
2340 py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args)
2341 {
2342   PyObject *py_g;
2343   guestfs_h *g;
2344   PyObject *py_r;
2345   int r;
2346   const char *device;
2347
2348   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz",
2349                          &py_g, &device))
2350     return NULL;
2351   g = get_handle (py_g);
2352
2353   r = guestfs_blockdev_getbsz (g, device);
2354   if (r == -1) {
2355     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2356     return NULL;
2357   }
2358
2359   py_r = PyInt_FromLong ((long) r);
2360   return py_r;
2361 }
2362
2363 static PyObject *
2364 py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args)
2365 {
2366   PyObject *py_g;
2367   guestfs_h *g;
2368   PyObject *py_r;
2369   int r;
2370   const char *device;
2371   int blocksize;
2372
2373   if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz",
2374                          &py_g, &device, &blocksize))
2375     return NULL;
2376   g = get_handle (py_g);
2377
2378   r = guestfs_blockdev_setbsz (g, device, blocksize);
2379   if (r == -1) {
2380     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2381     return NULL;
2382   }
2383
2384   Py_INCREF (Py_None);
2385   py_r = Py_None;
2386   return py_r;
2387 }
2388
2389 static PyObject *
2390 py_guestfs_blockdev_getsz (PyObject *self, PyObject *args)
2391 {
2392   PyObject *py_g;
2393   guestfs_h *g;
2394   PyObject *py_r;
2395   int64_t r;
2396   const char *device;
2397
2398   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz",
2399                          &py_g, &device))
2400     return NULL;
2401   g = get_handle (py_g);
2402
2403   r = guestfs_blockdev_getsz (g, device);
2404   if (r == -1) {
2405     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2406     return NULL;
2407   }
2408
2409   py_r = PyLong_FromLongLong (r);
2410   return py_r;
2411 }
2412
2413 static PyObject *
2414 py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args)
2415 {
2416   PyObject *py_g;
2417   guestfs_h *g;
2418   PyObject *py_r;
2419   int64_t r;
2420   const char *device;
2421
2422   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64",
2423                          &py_g, &device))
2424     return NULL;
2425   g = get_handle (py_g);
2426
2427   r = guestfs_blockdev_getsize64 (g, device);
2428   if (r == -1) {
2429     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2430     return NULL;
2431   }
2432
2433   py_r = PyLong_FromLongLong (r);
2434   return py_r;
2435 }
2436
2437 static PyObject *
2438 py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args)
2439 {
2440   PyObject *py_g;
2441   guestfs_h *g;
2442   PyObject *py_r;
2443   int r;
2444   const char *device;
2445
2446   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs",
2447                          &py_g, &device))
2448     return NULL;
2449   g = get_handle (py_g);
2450
2451   r = guestfs_blockdev_flushbufs (g, device);
2452   if (r == -1) {
2453     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2454     return NULL;
2455   }
2456
2457   Py_INCREF (Py_None);
2458   py_r = Py_None;
2459   return py_r;
2460 }
2461
2462 static PyObject *
2463 py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args)
2464 {
2465   PyObject *py_g;
2466   guestfs_h *g;
2467   PyObject *py_r;
2468   int r;
2469   const char *device;
2470
2471   if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt",
2472                          &py_g, &device))
2473     return NULL;
2474   g = get_handle (py_g);
2475
2476   r = guestfs_blockdev_rereadpt (g, device);
2477   if (r == -1) {
2478     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2479     return NULL;
2480   }
2481
2482   Py_INCREF (Py_None);
2483   py_r = Py_None;
2484   return py_r;
2485 }
2486
2487 static PyObject *
2488 py_guestfs_upload (PyObject *self, PyObject *args)
2489 {
2490   PyObject *py_g;
2491   guestfs_h *g;
2492   PyObject *py_r;
2493   int r;
2494   const char *filename;
2495   const char *remotefilename;
2496
2497   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload",
2498                          &py_g, &filename, &remotefilename))
2499     return NULL;
2500   g = get_handle (py_g);
2501
2502   r = guestfs_upload (g, filename, remotefilename);
2503   if (r == -1) {
2504     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2505     return NULL;
2506   }
2507
2508   Py_INCREF (Py_None);
2509   py_r = Py_None;
2510   return py_r;
2511 }
2512
2513 static PyObject *
2514 py_guestfs_download (PyObject *self, PyObject *args)
2515 {
2516   PyObject *py_g;
2517   guestfs_h *g;
2518   PyObject *py_r;
2519   int r;
2520   const char *remotefilename;
2521   const char *filename;
2522
2523   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download",
2524                          &py_g, &remotefilename, &filename))
2525     return NULL;
2526   g = get_handle (py_g);
2527
2528   r = guestfs_download (g, remotefilename, filename);
2529   if (r == -1) {
2530     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2531     return NULL;
2532   }
2533
2534   Py_INCREF (Py_None);
2535   py_r = Py_None;
2536   return py_r;
2537 }
2538
2539 static PyObject *
2540 py_guestfs_checksum (PyObject *self, PyObject *args)
2541 {
2542   PyObject *py_g;
2543   guestfs_h *g;
2544   PyObject *py_r;
2545   char *r;
2546   const char *csumtype;
2547   const char *path;
2548
2549   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum",
2550                          &py_g, &csumtype, &path))
2551     return NULL;
2552   g = get_handle (py_g);
2553
2554   r = guestfs_checksum (g, csumtype, path);
2555   if (r == NULL) {
2556     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2557     return NULL;
2558   }
2559
2560   py_r = PyString_FromString (r);
2561   free (r);
2562   return py_r;
2563 }
2564
2565 static PyObject *
2566 py_guestfs_tar_in (PyObject *self, PyObject *args)
2567 {
2568   PyObject *py_g;
2569   guestfs_h *g;
2570   PyObject *py_r;
2571   int r;
2572   const char *tarfile;
2573   const char *directory;
2574
2575   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in",
2576                          &py_g, &tarfile, &directory))
2577     return NULL;
2578   g = get_handle (py_g);
2579
2580   r = guestfs_tar_in (g, tarfile, directory);
2581   if (r == -1) {
2582     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2583     return NULL;
2584   }
2585
2586   Py_INCREF (Py_None);
2587   py_r = Py_None;
2588   return py_r;
2589 }
2590
2591 static PyObject *
2592 py_guestfs_tar_out (PyObject *self, PyObject *args)
2593 {
2594   PyObject *py_g;
2595   guestfs_h *g;
2596   PyObject *py_r;
2597   int r;
2598   const char *directory;
2599   const char *tarfile;
2600
2601   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out",
2602                          &py_g, &directory, &tarfile))
2603     return NULL;
2604   g = get_handle (py_g);
2605
2606   r = guestfs_tar_out (g, directory, tarfile);
2607   if (r == -1) {
2608     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2609     return NULL;
2610   }
2611
2612   Py_INCREF (Py_None);
2613   py_r = Py_None;
2614   return py_r;
2615 }
2616
2617 static PyObject *
2618 py_guestfs_tgz_in (PyObject *self, PyObject *args)
2619 {
2620   PyObject *py_g;
2621   guestfs_h *g;
2622   PyObject *py_r;
2623   int r;
2624   const char *tarball;
2625   const char *directory;
2626
2627   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in",
2628                          &py_g, &tarball, &directory))
2629     return NULL;
2630   g = get_handle (py_g);
2631
2632   r = guestfs_tgz_in (g, tarball, directory);
2633   if (r == -1) {
2634     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2635     return NULL;
2636   }
2637
2638   Py_INCREF (Py_None);
2639   py_r = Py_None;
2640   return py_r;
2641 }
2642
2643 static PyObject *
2644 py_guestfs_tgz_out (PyObject *self, PyObject *args)
2645 {
2646   PyObject *py_g;
2647   guestfs_h *g;
2648   PyObject *py_r;
2649   int r;
2650   const char *directory;
2651   const char *tarball;
2652
2653   if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out",
2654                          &py_g, &directory, &tarball))
2655     return NULL;
2656   g = get_handle (py_g);
2657
2658   r = guestfs_tgz_out (g, directory, tarball);
2659   if (r == -1) {
2660     PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));
2661     return NULL;
2662   }
2663
2664   Py_INCREF (Py_None);
2665   py_r = Py_None;
2666   return py_r;
2667 }
2668
2669 static PyMethodDef methods[] = {
2670   { (char *) "create", py_guestfs_create, METH_VARARGS, NULL },
2671   { (char *) "close", py_guestfs_close, METH_VARARGS, NULL },
2672   { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL },
2673   { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL },
2674   { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL },
2675   { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL },
2676   { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL },
2677   { (char *) "config", py_guestfs_config, METH_VARARGS, NULL },
2678   { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL },
2679   { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL },
2680   { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL },
2681   { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL },
2682   { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL },
2683   { (char *) "get_verbose", py_guestfs_get_verbose, METH_VARARGS, NULL },
2684   { (char *) "is_ready", py_guestfs_is_ready, METH_VARARGS, NULL },
2685   { (char *) "is_config", py_guestfs_is_config, METH_VARARGS, NULL },
2686   { (char *) "is_launching", py_guestfs_is_launching, METH_VARARGS, NULL },
2687   { (char *) "is_busy", py_guestfs_is_busy, METH_VARARGS, NULL },
2688   { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL },
2689   { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL },
2690   { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL },
2691   { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL },
2692   { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL },
2693   { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL },
2694   { (char *) "cat", py_guestfs_cat, METH_VARARGS, NULL },
2695   { (char *) "ll", py_guestfs_ll, METH_VARARGS, NULL },
2696   { (char *) "ls", py_guestfs_ls, METH_VARARGS, NULL },
2697   { (char *) "list_devices", py_guestfs_list_devices, METH_VARARGS, NULL },
2698   { (char *) "list_partitions", py_guestfs_list_partitions, METH_VARARGS, NULL },
2699   { (char *) "pvs", py_guestfs_pvs, METH_VARARGS, NULL },
2700   { (char *) "vgs", py_guestfs_vgs, METH_VARARGS, NULL },
2701   { (char *) "lvs", py_guestfs_lvs, METH_VARARGS, NULL },
2702   { (char *) "pvs_full", py_guestfs_pvs_full, METH_VARARGS, NULL },
2703   { (char *) "vgs_full", py_guestfs_vgs_full, METH_VARARGS, NULL },
2704   { (char *) "lvs_full", py_guestfs_lvs_full, METH_VARARGS, NULL },
2705   { (char *) "read_lines", py_guestfs_read_lines, METH_VARARGS, NULL },
2706   { (char *) "aug_init", py_guestfs_aug_init, METH_VARARGS, NULL },
2707   { (char *) "aug_close", py_guestfs_aug_close, METH_VARARGS, NULL },
2708   { (char *) "aug_defvar", py_guestfs_aug_defvar, METH_VARARGS, NULL },
2709   { (char *) "aug_defnode", py_guestfs_aug_defnode, METH_VARARGS, NULL },
2710   { (char *) "aug_get", py_guestfs_aug_get, METH_VARARGS, NULL },
2711   { (char *) "aug_set", py_guestfs_aug_set, METH_VARARGS, NULL },
2712   { (char *) "aug_insert", py_guestfs_aug_insert, METH_VARARGS, NULL },
2713   { (char *) "aug_rm", py_guestfs_aug_rm, METH_VARARGS, NULL },
2714   { (char *) "aug_mv", py_guestfs_aug_mv, METH_VARARGS, NULL },
2715   { (char *) "aug_match", py_guestfs_aug_match, METH_VARARGS, NULL },
2716   { (char *) "aug_save", py_guestfs_aug_save, METH_VARARGS, NULL },
2717   { (char *) "aug_load", py_guestfs_aug_load, METH_VARARGS, NULL },
2718   { (char *) "aug_ls", py_guestfs_aug_ls, METH_VARARGS, NULL },
2719   { (char *) "rm", py_guestfs_rm, METH_VARARGS, NULL },
2720   { (char *) "rmdir", py_guestfs_rmdir, METH_VARARGS, NULL },
2721   { (char *) "rm_rf", py_guestfs_rm_rf, METH_VARARGS, NULL },
2722   { (char *) "mkdir", py_guestfs_mkdir, METH_VARARGS, NULL },
2723   { (char *) "mkdir_p", py_guestfs_mkdir_p, METH_VARARGS, NULL },
2724   { (char *) "chmod", py_guestfs_chmod, METH_VARARGS, NULL },
2725   { (char *) "chown", py_guestfs_chown, METH_VARARGS, NULL },
2726   { (char *) "exists", py_guestfs_exists, METH_VARARGS, NULL },
2727   { (char *) "is_file", py_guestfs_is_file, METH_VARARGS, NULL },
2728   { (char *) "is_dir", py_guestfs_is_dir, METH_VARARGS, NULL },
2729   { (char *) "pvcreate", py_guestfs_pvcreate, METH_VARARGS, NULL },
2730   { (char *) "vgcreate", py_guestfs_vgcreate, METH_VARARGS, NULL },
2731   { (char *) "lvcreate", py_guestfs_lvcreate, METH_VARARGS, NULL },
2732   { (char *) "mkfs", py_guestfs_mkfs, METH_VARARGS, NULL },
2733   { (char *) "sfdisk", py_guestfs_sfdisk, METH_VARARGS, NULL },
2734   { (char *) "write_file", py_guestfs_write_file, METH_VARARGS, NULL },
2735   { (char *) "umount", py_guestfs_umount, METH_VARARGS, NULL },
2736   { (char *) "mounts", py_guestfs_mounts, METH_VARARGS, NULL },
2737   { (char *) "umount_all", py_guestfs_umount_all, METH_VARARGS, NULL },
2738   { (char *) "lvm_remove_all", py_guestfs_lvm_remove_all, METH_VARARGS, NULL },
2739   { (char *) "file", py_guestfs_file, METH_VARARGS, NULL },
2740   { (char *) "command", py_guestfs_command, METH_VARARGS, NULL },
2741   { (char *) "command_lines", py_guestfs_command_lines, METH_VARARGS, NULL },
2742   { (char *) "stat", py_guestfs_stat, METH_VARARGS, NULL },
2743   { (char *) "lstat", py_guestfs_lstat, METH_VARARGS, NULL },
2744   { (char *) "statvfs", py_guestfs_statvfs, METH_VARARGS, NULL },
2745   { (char *) "tune2fs_l", py_guestfs_tune2fs_l, METH_VARARGS, NULL },
2746   { (char *) "blockdev_setro", py_guestfs_blockdev_setro, METH_VARARGS, NULL },
2747   { (char *) "blockdev_setrw", py_guestfs_blockdev_setrw, METH_VARARGS, NULL },
2748   { (char *) "blockdev_getro", py_guestfs_blockdev_getro, METH_VARARGS, NULL },
2749   { (char *) "blockdev_getss", py_guestfs_blockdev_getss, METH_VARARGS, NULL },
2750   { (char *) "blockdev_getbsz", py_guestfs_blockdev_getbsz, METH_VARARGS, NULL },
2751   { (char *) "blockdev_setbsz", py_guestfs_blockdev_setbsz, METH_VARARGS, NULL },
2752   { (char *) "blockdev_getsz", py_guestfs_blockdev_getsz, METH_VARARGS, NULL },
2753   { (char *) "blockdev_getsize64", py_guestfs_blockdev_getsize64, METH_VARARGS, NULL },
2754   { (char *) "blockdev_flushbufs", py_guestfs_blockdev_flushbufs, METH_VARARGS, NULL },
2755   { (char *) "blockdev_rereadpt", py_guestfs_blockdev_rereadpt, METH_VARARGS, NULL },
2756   { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL },
2757   { (char *) "download", py_guestfs_download, METH_VARARGS, NULL },
2758   { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL },
2759   { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL },
2760   { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL },
2761   { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL },
2762   { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL },
2763   { NULL, NULL, 0, NULL }
2764 };
2765
2766 void
2767 initlibguestfsmod (void)
2768 {
2769   static int initialized = 0;
2770
2771   if (initialized) return;
2772   Py_InitModule ((char *) "libguestfsmod", methods);
2773   initialized = 1;
2774 }