X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=python%2Fguestfs-py.c;h=8e90d762b8602268a7e8330fcea643e9ae22d72c;hp=4d31d9f7f002946bf5c542dbe2c1c65ae1c239ef;hb=460d139e6a52da67a4f1947035b1978610349f78;hpb=24ccbb29ac475187f51a27dcd318db2b4824a0c1 diff --git a/python/guestfs-py.c b/python/guestfs-py.c index 4d31d9f..8e90d76 100644 --- a/python/guestfs-py.c +++ b/python/guestfs-py.c @@ -389,19 +389,30 @@ put_statvfs (struct guestfs_statvfs *statvfs) }; static PyObject * -py_guestfs_launch (PyObject *self, PyObject *args) +py_guestfs_test0 (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch", - &py_g)) + const char *str; + const char *optstr; + PyObject *py_strlist; + const char **strlist; + int b; + int integer; + const char *filein; + const char *fileout; + + if (!PyArg_ParseTuple (args, (char *) "OszOiiss:guestfs_test0", + &py_g, &str, &optstr, &py_strlist, &b, &integer, &filein, &fileout)) return NULL; g = get_handle (py_g); + strlist = get_string_list (py_strlist); + if (!strlist) return NULL; - r = guestfs_launch (g); + r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout); + free (strlist); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -413,168 +424,161 @@ py_guestfs_launch (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_wait_ready (PyObject *self, PyObject *args) +py_guestfs_test0rint (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rint", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_wait_ready (g); + r = guestfs_test0rint (g, val); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyInt_FromLong ((long) r); return py_r; } static PyObject * -py_guestfs_kill_subprocess (PyObject *self, PyObject *args) +py_guestfs_test0rinterr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rinterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_kill_subprocess (g); + r = guestfs_test0rinterr (g); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyInt_FromLong ((long) r); return py_r; } static PyObject * -py_guestfs_add_drive (PyObject *self, PyObject *args) +py_guestfs_test0rint64 (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *filename; + int64_t r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive", - &py_g, &filename)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rint64", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_add_drive (g, filename); + r = guestfs_test0rint64 (g, val); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyLong_FromLongLong (r); return py_r; } static PyObject * -py_guestfs_add_cdrom (PyObject *self, PyObject *args) +py_guestfs_test0rint64err (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *filename; + int64_t r; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom", - &py_g, &filename)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rint64err", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_add_cdrom (g, filename); + r = guestfs_test0rint64err (g); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyLong_FromLongLong (r); return py_r; } static PyObject * -py_guestfs_config (PyObject *self, PyObject *args) +py_guestfs_test0rbool (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *qemuparam; - const char *qemuvalue; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config", - &py_g, &qemuparam, &qemuvalue)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rbool", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_config (g, qemuparam, qemuvalue); + r = guestfs_test0rbool (g, val); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyInt_FromLong ((long) r); return py_r; } static PyObject * -py_guestfs_set_path (PyObject *self, PyObject *args) +py_guestfs_test0rboolerr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rboolerr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_path (g, path); + r = guestfs_test0rboolerr (g); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyInt_FromLong ((long) r); return py_r; } static PyObject * -py_guestfs_get_path (PyObject *self, PyObject *args) +py_guestfs_test0rconststring (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; const char *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rconststring", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_get_path (g); + r = guestfs_test0rconststring (g, val); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -585,404 +589,2227 @@ py_guestfs_get_path (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_set_autosync (PyObject *self, PyObject *args) +py_guestfs_test0rconststringerr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - int autosync; + const char *r; - if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync", - &py_g, &autosync)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rconststringerr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_autosync (g, autosync); - if (r == -1) { + r = guestfs_test0rconststringerr (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyString_FromString (r); return py_r; } static PyObject * -py_guestfs_get_autosync (PyObject *self, PyObject *args) +py_guestfs_test0rstring (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + char *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstring", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_get_autosync (g); - if (r == -1) { + r = guestfs_test0rstring (g, val); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_set_verbose (PyObject *self, PyObject *args) +py_guestfs_test0rstringerr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - int verbose; + char *r; - if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose", - &py_g, &verbose)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstringerr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_verbose (g, verbose); - if (r == -1) { + r = guestfs_test0rstringerr (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_get_verbose (PyObject *self, PyObject *args) +py_guestfs_test0rstringlist (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + char **r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstringlist", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_get_verbose (g); - if (r == -1) { + r = guestfs_test0rstringlist (g, val); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = put_string_list (r); + free_strings (r); return py_r; } static PyObject * -py_guestfs_is_ready (PyObject *self, PyObject *args) +py_guestfs_test0rstringlisterr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + char **r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstringlisterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_is_ready (g); - if (r == -1) { + r = guestfs_test0rstringlisterr (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = put_string_list (r); + free_strings (r); return py_r; } static PyObject * -py_guestfs_is_config (PyObject *self, PyObject *args) +py_guestfs_test0rintbool (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_int_bool *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rintbool", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_is_config (g); - if (r == -1) { + r = guestfs_test0rintbool (g, val); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = PyTuple_New (2); + PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i)); + PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b)); + guestfs_free_int_bool (r); return py_r; } static PyObject * -py_guestfs_is_launching (PyObject *self, PyObject *args) +py_guestfs_test0rintboolerr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_int_bool *r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rintboolerr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_is_launching (g); - if (r == -1) { + r = guestfs_test0rintboolerr (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = PyTuple_New (2); + PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i)); + PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b)); + guestfs_free_int_bool (r); return py_r; } static PyObject * -py_guestfs_is_busy (PyObject *self, PyObject *args) +py_guestfs_test0rpvlist (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_lvm_pv_list *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rpvlist", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_is_busy (g); - if (r == -1) { + r = guestfs_test0rpvlist (g, val); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = put_lvm_pv_list (r); + guestfs_free_lvm_pv_list (r); return py_r; } static PyObject * -py_guestfs_get_state (PyObject *self, PyObject *args) +py_guestfs_test0rpvlisterr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_lvm_pv_list *r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rpvlisterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_get_state (g); - if (r == -1) { + r = guestfs_test0rpvlisterr (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = put_lvm_pv_list (r); + guestfs_free_lvm_pv_list (r); return py_r; } static PyObject * -py_guestfs_set_busy (PyObject *self, PyObject *args) +py_guestfs_test0rvglist (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_lvm_vg_list *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rvglist", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_set_busy (g); - if (r == -1) { + r = guestfs_test0rvglist (g, val); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = put_lvm_vg_list (r); + guestfs_free_lvm_vg_list (r); return py_r; } static PyObject * -py_guestfs_set_ready (PyObject *self, PyObject *args) +py_guestfs_test0rvglisterr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_lvm_vg_list *r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_ready", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rvglisterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_ready (g); - if (r == -1) { + r = guestfs_test0rvglisterr (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = put_lvm_vg_list (r); + guestfs_free_lvm_vg_list (r); return py_r; } static PyObject * -py_guestfs_mount (PyObject *self, PyObject *args) +py_guestfs_test0rlvlist (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *device; - const char *mountpoint; + struct guestfs_lvm_lv_list *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount", - &py_g, &device, &mountpoint)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rlvlist", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_mount (g, device, mountpoint); - if (r == -1) { + r = guestfs_test0rlvlist (g, val); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = put_lvm_lv_list (r); + guestfs_free_lvm_lv_list (r); return py_r; } static PyObject * -py_guestfs_sync (PyObject *self, PyObject *args) +py_guestfs_test0rlvlisterr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_lvm_lv_list *r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rlvlisterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_sync (g); - if (r == -1) { + r = guestfs_test0rlvlisterr (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = put_lvm_lv_list (r); + guestfs_free_lvm_lv_list (r); return py_r; } static PyObject * -py_guestfs_touch (PyObject *self, PyObject *args) +py_guestfs_test0rstat (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *path; + struct guestfs_stat *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstat", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_touch (g, path); - if (r == -1) { + r = guestfs_test0rstat (g, val); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = put_stat (r); + free (r); return py_r; } static PyObject * -py_guestfs_cat (PyObject *self, PyObject *args) +py_guestfs_test0rstaterr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *path; + struct guestfs_stat *r; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstaterr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_cat (g, path); + r = guestfs_test0rstaterr (g); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyString_FromString (r); + py_r = put_stat (r); free (r); return py_r; } static PyObject * -py_guestfs_ll (PyObject *self, PyObject *args) +py_guestfs_test0rstatvfs (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *directory; + struct guestfs_statvfs *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll", - &py_g, &directory)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstatvfs", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_ll (g, directory); + r = guestfs_test0rstatvfs (g, val); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyString_FromString (r); + py_r = put_statvfs (r); + free (r); + return py_r; +} + +static PyObject * +py_guestfs_test0rstatvfserr (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + struct guestfs_statvfs *r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstatvfserr", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_test0rstatvfserr (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_statvfs (r); free (r); return py_r; } static PyObject * -py_guestfs_ls (PyObject *self, PyObject *args) +py_guestfs_test0rhashtable (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + const char *val; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rhashtable", + &py_g, &val)) + return NULL; + g = get_handle (py_g); + + r = guestfs_test0rhashtable (g, val); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_table (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_test0rhashtableerr (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rhashtableerr", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_test0rhashtableerr (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_table (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_launch (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_launch", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_launch (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_wait_ready (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_wait_ready", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_wait_ready (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_kill_subprocess (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_kill_subprocess (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_add_drive (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *filename; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive", + &py_g, &filename)) + return NULL; + g = get_handle (py_g); + + r = guestfs_add_drive (g, filename); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_add_cdrom (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *filename; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom", + &py_g, &filename)) + return NULL; + g = get_handle (py_g); + + r = guestfs_add_cdrom (g, filename); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_add_drive_ro (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *filename; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive_ro", + &py_g, &filename)) + return NULL; + g = get_handle (py_g); + + r = guestfs_add_drive_ro (g, filename); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_config (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *qemuparam; + const char *qemuvalue; + + if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config", + &py_g, &qemuparam, &qemuvalue)) + return NULL; + g = get_handle (py_g); + + r = guestfs_config (g, qemuparam, qemuvalue); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_set_qemu (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *qemu; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_qemu", + &py_g, &qemu)) + return NULL; + g = get_handle (py_g); + + r = guestfs_set_qemu (g, qemu); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_get_qemu (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + const char *r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_qemu", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_get_qemu (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyString_FromString (r); + return py_r; +} + +static PyObject * +py_guestfs_set_path (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_set_path (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_get_path (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + const char *r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_get_path (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyString_FromString (r); + return py_r; +} + +static PyObject * +py_guestfs_set_append (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *append; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_append", + &py_g, &append)) + return NULL; + g = get_handle (py_g); + + r = guestfs_set_append (g, append); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_get_append (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + const char *r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_append", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_get_append (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyString_FromString (r); + return py_r; +} + +static PyObject * +py_guestfs_set_autosync (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + int autosync; + + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync", + &py_g, &autosync)) + return NULL; + g = get_handle (py_g); + + r = guestfs_set_autosync (g, autosync); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_get_autosync (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_get_autosync (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_set_verbose (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + int verbose; + + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_verbose", + &py_g, &verbose)) + return NULL; + g = get_handle (py_g); + + r = guestfs_set_verbose (g, verbose); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_get_verbose (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_verbose", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_get_verbose (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_is_ready (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_ready", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_is_ready (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_is_config (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_config", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_is_config (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_is_launching (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_launching", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_is_launching (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_is_busy (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_is_busy", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_is_busy (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_get_state (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_state", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_get_state (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_set_busy (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_set_busy (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_set_ready (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_ready", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_set_ready (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_end_busy (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_end_busy", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_end_busy (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_mount (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *device; + const char *mountpoint; + + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount", + &py_g, &device, &mountpoint)) + return NULL; + g = get_handle (py_g); + + r = guestfs_mount (g, device, mountpoint); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_sync (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_sync (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_touch (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_touch (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_cat (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char *r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_cat (g, path); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyString_FromString (r); + free (r); + return py_r; +} + +static PyObject * +py_guestfs_ll (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char *r; + const char *directory; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll", + &py_g, &directory)) + return NULL; + g = get_handle (py_g); + + r = guestfs_ll (g, directory); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyString_FromString (r); + free (r); + return py_r; +} + +static PyObject * +py_guestfs_ls (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + const char *directory; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls", + &py_g, &directory)) + return NULL; + g = get_handle (py_g); + + r = guestfs_ls (g, directory); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_list_devices (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_list_devices (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_list_partitions (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_list_partitions (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_pvs (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_pvs (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_vgs (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_vgs (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_lvs (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_lvs (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_pvs_full (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + struct guestfs_lvm_pv_list *r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_pvs_full (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_lvm_pv_list (r); + guestfs_free_lvm_pv_list (r); + return py_r; +} + +static PyObject * +py_guestfs_vgs_full (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + struct guestfs_lvm_vg_list *r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_vgs_full (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_lvm_vg_list (r); + guestfs_free_lvm_vg_list (r); + return py_r; +} + +static PyObject * +py_guestfs_lvs_full (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + struct guestfs_lvm_lv_list *r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_lvs_full (g); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_lvm_lv_list (r); + guestfs_free_lvm_lv_list (r); + return py_r; +} + +static PyObject * +py_guestfs_read_lines (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_read_lines (g, path); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_aug_init (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *root; + int flags; + + if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init", + &py_g, &root, &flags)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_init (g, root, flags); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_aug_close (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_close (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_aug_defvar (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *name; + const char *expr; + + if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar", + &py_g, &name, &expr)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_defvar (g, name, expr); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_aug_defnode (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + struct guestfs_int_bool *r; + const char *name; + const char *expr; + const char *val; + + if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode", + &py_g, &name, &expr, &val)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_defnode (g, name, expr, val); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyTuple_New (2); + PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i)); + PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b)); + guestfs_free_int_bool (r); + return py_r; +} + +static PyObject * +py_guestfs_aug_get (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char *r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_get (g, path); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyString_FromString (r); + free (r); + return py_r; +} + +static PyObject * +py_guestfs_aug_set (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + const char *val; + + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set", + &py_g, &path, &val)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_set (g, path, val); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_aug_insert (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + const char *label; + int before; + + if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert", + &py_g, &path, &label, &before)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_insert (g, path, label, before); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_aug_rm (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_rm (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_aug_mv (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *src; + const char *dest; + + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv", + &py_g, &src, &dest)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_mv (g, src, dest); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_aug_match (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_match (g, path); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_aug_save (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_save (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_aug_load (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load", + &py_g)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_load (g); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_aug_ls (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_aug_ls (g, path); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_string_list (r); + free_strings (r); + return py_r; +} + +static PyObject * +py_guestfs_rm (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_rm (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_rmdir (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_rmdir (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_rm_rf (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_rm_rf (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_mkdir (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_mkdir (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_mkdir_p (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_mkdir_p (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_chmod (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + int mode; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod", + &py_g, &mode, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_chmod (g, mode, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_chown (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + int owner; + int group; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown", + &py_g, &owner, &group, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_chown (g, owner, group, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_exists (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_exists (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_is_file (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_is_file (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_is_dir (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_is_dir (g, path); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_pvcreate (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *device; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate", + &py_g, &device)) + return NULL; + g = get_handle (py_g); + + r = guestfs_pvcreate (g, device); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_vgcreate (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *volgroup; + PyObject *py_physvols; + const char **physvols; + + if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate", + &py_g, &volgroup, &py_physvols)) + return NULL; + g = get_handle (py_g); + physvols = get_string_list (py_physvols); + if (!physvols) return NULL; + + r = guestfs_vgcreate (g, volgroup, physvols); + free (physvols); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_lvcreate (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *logvol; + const char *volgroup; + int mbytes; + + if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate", + &py_g, &logvol, &volgroup, &mbytes)) + return NULL; + g = get_handle (py_g); + + r = guestfs_lvcreate (g, logvol, volgroup, mbytes); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_mkfs (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *fstype; + const char *device; + + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs", + &py_g, &fstype, &device)) + return NULL; + g = get_handle (py_g); + + r = guestfs_mkfs (g, fstype, device); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_sfdisk (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *device; + int cyls; + int heads; + int sectors; + PyObject *py_lines; + const char **lines; + + if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk", + &py_g, &device, &cyls, &heads, §ors, &py_lines)) + return NULL; + g = get_handle (py_g); + lines = get_string_list (py_lines); + if (!lines) return NULL; + + r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines); + free (lines); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_write_file (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *path; + const char *content; + int size; + + if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file", + &py_g, &path, &content, &size)) + return NULL; + g = get_handle (py_g); + + r = guestfs_write_file (g, path, content, size); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_umount (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *pathordevice; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount", + &py_g, &pathordevice)) + return NULL; + g = get_handle (py_g); + + r = guestfs_umount (g, pathordevice); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_mounts (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; char **r; - const char *directory; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ls", - &py_g, &directory)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_ls (g, directory); + r = guestfs_mounts (g); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -994,115 +2821,126 @@ py_guestfs_ls (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_list_devices (PyObject *self, PyObject *args) +py_guestfs_umount_all (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + int r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_devices", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_list_devices (g); - if (r == NULL) { + r = guestfs_umount_all (g); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_string_list (r); - free_strings (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_list_partitions (PyObject *self, PyObject *args) +py_guestfs_lvm_remove_all (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + int r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_list_partitions", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_list_partitions (g); - if (r == NULL) { + r = guestfs_lvm_remove_all (g); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_string_list (r); - free_strings (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_pvs (PyObject *self, PyObject *args) +py_guestfs_file (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + char *r; + const char *path; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file", + &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_pvs (g); + r = guestfs_file (g, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_string_list (r); - free_strings (r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_vgs (PyObject *self, PyObject *args) +py_guestfs_command (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + char *r; + PyObject *py_arguments; + const char **arguments; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command", + &py_g, &py_arguments)) return NULL; g = get_handle (py_g); + arguments = get_string_list (py_arguments); + if (!arguments) return NULL; - r = guestfs_vgs (g); + r = guestfs_command (g, arguments); + free (arguments); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_string_list (r); - free_strings (r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_lvs (PyObject *self, PyObject *args) +py_guestfs_command_lines (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; char **r; + PyObject *py_arguments; + const char **arguments; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines", + &py_g, &py_arguments)) return NULL; g = get_handle (py_g); + arguments = get_string_list (py_arguments); + if (!arguments) return NULL; - r = guestfs_lvs (g); + r = guestfs_command_lines (g, arguments); + free (arguments); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1114,118 +2952,120 @@ py_guestfs_lvs (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_pvs_full (PyObject *self, PyObject *args) +py_guestfs_stat (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_lvm_pv_list *r; + struct guestfs_stat *r; + const char *path; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat", + &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_pvs_full (g); + r = guestfs_stat (g, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_lvm_pv_list (r); - guestfs_free_lvm_pv_list (r); + py_r = put_stat (r); + free (r); return py_r; } static PyObject * -py_guestfs_vgs_full (PyObject *self, PyObject *args) +py_guestfs_lstat (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_lvm_vg_list *r; + struct guestfs_stat *r; + const char *path; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat", + &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_vgs_full (g); + r = guestfs_lstat (g, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_lvm_vg_list (r); - guestfs_free_lvm_vg_list (r); + py_r = put_stat (r); + free (r); return py_r; } static PyObject * -py_guestfs_lvs_full (PyObject *self, PyObject *args) +py_guestfs_statvfs (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_lvm_lv_list *r; + struct guestfs_statvfs *r; + const char *path; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs", + &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_lvs_full (g); + r = guestfs_statvfs (g, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_lvm_lv_list (r); - guestfs_free_lvm_lv_list (r); + py_r = put_statvfs (r); + free (r); return py_r; } static PyObject * -py_guestfs_read_lines (PyObject *self, PyObject *args) +py_guestfs_tune2fs_l (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; char **r; - const char *path; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_read_lines (g, path); + r = guestfs_tune2fs_l (g, device); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_string_list (r); + py_r = put_table (r); free_strings (r); return py_r; } static PyObject * -py_guestfs_aug_init (PyObject *self, PyObject *args) +py_guestfs_blockdev_setro (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *root; - int flags; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init", - &py_g, &root, &flags)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_aug_init (g, root, flags); + r = guestfs_blockdev_setro (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1237,19 +3077,20 @@ py_guestfs_aug_init (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_close (PyObject *self, PyObject *args) +py_guestfs_blockdev_setrw (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_aug_close (g); + r = guestfs_blockdev_setrw (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1261,21 +3102,68 @@ py_guestfs_aug_close (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_defvar (PyObject *self, PyObject *args) +py_guestfs_blockdev_getro (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *name; - const char *expr; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar", - &py_g, &name, &expr)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_aug_defvar (g, name, expr); + r = guestfs_blockdev_getro (g, device); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_blockdev_getss (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *device; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss", + &py_g, &device)) + return NULL; + g = get_handle (py_g); + + r = guestfs_blockdev_getss (g, device); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = PyInt_FromLong ((long) r); + return py_r; +} + +static PyObject * +py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *device; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz", + &py_g, &device)) + return NULL; + g = get_handle (py_g); + + r = guestfs_blockdev_getbsz (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1286,75 +3174,94 @@ py_guestfs_aug_defvar (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_defnode (PyObject *self, PyObject *args) +py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + int r; + const char *device; + int blocksize; + + if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz", + &py_g, &device, &blocksize)) + return NULL; + g = get_handle (py_g); + + r = guestfs_blockdev_setbsz (g, device, blocksize); + if (r == -1) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + Py_INCREF (Py_None); + py_r = Py_None; + return py_r; +} + +static PyObject * +py_guestfs_blockdev_getsz (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_int_bool *r; - const char *name; - const char *expr; - const char *val; + int64_t r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode", - &py_g, &name, &expr, &val)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_aug_defnode (g, name, expr, val); - if (r == NULL) { + r = guestfs_blockdev_getsz (g, device); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyTuple_New (2); - PyTuple_SetItem (py_r, 0, PyInt_FromLong ((long) r->i)); - PyTuple_SetItem (py_r, 1, PyInt_FromLong ((long) r->b)); - guestfs_free_int_bool (r); + py_r = PyLong_FromLongLong (r); return py_r; } static PyObject * -py_guestfs_aug_get (PyObject *self, PyObject *args) +py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *path; + int64_t r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_aug_get (g, path); - if (r == NULL) { + r = guestfs_blockdev_getsize64 (g, device); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyString_FromString (r); - free (r); + py_r = PyLong_FromLongLong (r); return py_r; } static PyObject * -py_guestfs_aug_set (PyObject *self, PyObject *args) +py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; - const char *val; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_set", - &py_g, &path, &val)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_aug_set (g, path, val); + r = guestfs_blockdev_flushbufs (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1366,22 +3273,20 @@ py_guestfs_aug_set (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_insert (PyObject *self, PyObject *args) +py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; - const char *label; - int before; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_aug_insert", - &py_g, &path, &label, &before)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_aug_insert (g, path, label, before); + r = guestfs_blockdev_rereadpt (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1393,45 +3298,47 @@ py_guestfs_aug_insert (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_rm (PyObject *self, PyObject *args) +py_guestfs_upload (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *filename; + const char *remotefilename; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_rm", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload", + &py_g, &filename, &remotefilename)) return NULL; g = get_handle (py_g); - r = guestfs_aug_rm (g, path); + r = guestfs_upload (g, filename, remotefilename); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_aug_mv (PyObject *self, PyObject *args) +py_guestfs_download (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *src; - const char *dest; + const char *remotefilename; + const char *filename; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv", - &py_g, &src, &dest)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download", + &py_g, &remotefilename, &filename)) return NULL; g = get_handle (py_g); - r = guestfs_aug_mv (g, src, dest); + r = guestfs_download (g, remotefilename, filename); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1443,44 +3350,47 @@ py_guestfs_aug_mv (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_match (PyObject *self, PyObject *args) +py_guestfs_checksum (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + char *r; + const char *csumtype; const char *path; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_match", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum", + &py_g, &csumtype, &path)) return NULL; g = get_handle (py_g); - r = guestfs_aug_match (g, path); + r = guestfs_checksum (g, csumtype, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_string_list (r); - free_strings (r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_aug_save (PyObject *self, PyObject *args) +py_guestfs_tar_in (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; + const char *tarfile; + const char *directory; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in", + &py_g, &tarfile, &directory)) return NULL; g = get_handle (py_g); - r = guestfs_aug_save (g); + r = guestfs_tar_in (g, tarfile, directory); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1492,19 +3402,21 @@ py_guestfs_aug_save (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_load (PyObject *self, PyObject *args) +py_guestfs_tar_out (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; + const char *directory; + const char *tarfile; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out", + &py_g, &directory, &tarfile)) return NULL; g = get_handle (py_g); - r = guestfs_aug_load (g); + r = guestfs_tar_out (g, directory, tarfile); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1516,45 +3428,21 @@ py_guestfs_aug_load (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_ls (PyObject *self, PyObject *args) -{ - PyObject *py_g; - guestfs_h *g; - PyObject *py_r; - char **r; - const char *path; - - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_ls", - &py_g, &path)) - return NULL; - g = get_handle (py_g); - - r = guestfs_aug_ls (g, path); - if (r == NULL) { - PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); - return NULL; - } - - py_r = put_string_list (r); - free_strings (r); - return py_r; -} - -static PyObject * -py_guestfs_rm (PyObject *self, PyObject *args) +py_guestfs_tgz_in (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *tarball; + const char *directory; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in", + &py_g, &tarball, &directory)) return NULL; g = get_handle (py_g); - r = guestfs_rm (g, path); + r = guestfs_tgz_in (g, tarball, directory); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1566,20 +3454,21 @@ py_guestfs_rm (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_rmdir (PyObject *self, PyObject *args) +py_guestfs_tgz_out (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *directory; + const char *tarball; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out", + &py_g, &directory, &tarball)) return NULL; g = get_handle (py_g); - r = guestfs_rmdir (g, path); + r = guestfs_tgz_out (g, directory, tarball); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1591,20 +3480,21 @@ py_guestfs_rmdir (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_rm_rf (PyObject *self, PyObject *args) +py_guestfs_mount_ro (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *device; + const char *mountpoint; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm_rf", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro", + &py_g, &device, &mountpoint)) return NULL; g = get_handle (py_g); - r = guestfs_rm_rf (g, path); + r = guestfs_mount_ro (g, device, mountpoint); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1616,20 +3506,22 @@ py_guestfs_rm_rf (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_mkdir (PyObject *self, PyObject *args) +py_guestfs_mount_options (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *options; + const char *device; + const char *mountpoint; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options", + &py_g, &options, &device, &mountpoint)) return NULL; g = get_handle (py_g); - r = guestfs_mkdir (g, path); + r = guestfs_mount_options (g, options, device, mountpoint); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1641,20 +3533,23 @@ py_guestfs_mkdir (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_mkdir_p (PyObject *self, PyObject *args) +py_guestfs_mount_vfs (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *options; + const char *vfstype; + const char *device; + const char *mountpoint; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs", + &py_g, &options, &vfstype, &device, &mountpoint)) return NULL; g = get_handle (py_g); - r = guestfs_mkdir_p (g, path); + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1666,48 +3561,50 @@ py_guestfs_mkdir_p (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_chmod (PyObject *self, PyObject *args) +py_guestfs_debug (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - int mode; - const char *path; + char *r; + const char *subcmd; + PyObject *py_extraargs; + const char **extraargs; - if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod", - &py_g, &mode, &path)) + if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug", + &py_g, &subcmd, &py_extraargs)) return NULL; g = get_handle (py_g); + extraargs = get_string_list (py_extraargs); + if (!extraargs) return NULL; - r = guestfs_chmod (g, mode, path); - if (r == -1) { + r = guestfs_debug (g, subcmd, extraargs); + free (extraargs); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_chown (PyObject *self, PyObject *args) +py_guestfs_lvremove (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - int owner; - int group; - const char *path; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown", - &py_g, &owner, &group, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_chown (g, owner, group, path); + r = guestfs_lvremove (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1719,122 +3616,122 @@ py_guestfs_chown (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_exists (PyObject *self, PyObject *args) +py_guestfs_vgremove (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *vgname; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove", + &py_g, &vgname)) return NULL; g = get_handle (py_g); - r = guestfs_exists (g, path); + r = guestfs_vgremove (g, vgname); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_is_file (PyObject *self, PyObject *args) +py_guestfs_pvremove (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_is_file (g, path); + r = guestfs_pvremove (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_is_dir (PyObject *self, PyObject *args) +py_guestfs_set_e2label (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; + const char *device; + const char *label; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_dir", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label", + &py_g, &device, &label)) return NULL; g = get_handle (py_g); - r = guestfs_is_dir (g, path); + r = guestfs_set_e2label (g, device, label); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_pvcreate (PyObject *self, PyObject *args) +py_guestfs_get_e2label (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + char *r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_pvcreate (g, device); - if (r == -1) { + r = guestfs_get_e2label (g, device); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_vgcreate (PyObject *self, PyObject *args) +py_guestfs_set_e2uuid (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *volgroup; - PyObject *py_physvols; - const char **physvols; + const char *device; + const char *uuid; - if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate", - &py_g, &volgroup, &py_physvols)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid", + &py_g, &device, &uuid)) return NULL; g = get_handle (py_g); - physvols = get_string_list (py_physvols); - if (!physvols) return NULL; - r = guestfs_vgcreate (g, volgroup, physvols); - free (physvols); + r = guestfs_set_e2uuid (g, device, uuid); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1846,34 +3743,32 @@ py_guestfs_vgcreate (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_lvcreate (PyObject *self, PyObject *args) +py_guestfs_get_e2uuid (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *logvol; - const char *volgroup; - int mbytes; + char *r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate", - &py_g, &logvol, &volgroup, &mbytes)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_lvcreate (g, logvol, volgroup, mbytes); - if (r == -1) { + r = guestfs_get_e2uuid (g, device); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_mkfs (PyObject *self, PyObject *args) +py_guestfs_fsck (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; @@ -1882,45 +3777,36 @@ py_guestfs_mkfs (PyObject *self, PyObject *args) const char *fstype; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs", + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck", &py_g, &fstype, &device)) return NULL; g = get_handle (py_g); - r = guestfs_mkfs (g, fstype, device); + r = guestfs_fsck (g, fstype, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = PyInt_FromLong ((long) r); return py_r; } static PyObject * -py_guestfs_sfdisk (PyObject *self, PyObject *args) +py_guestfs_zero (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; const char *device; - int cyls; - int heads; - int sectors; - PyObject *py_lines; - const char **lines; - if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk", - &py_g, &device, &cyls, &heads, §ors, &py_lines)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero", + &py_g, &device)) return NULL; g = get_handle (py_g); - lines = get_string_list (py_lines); - if (!lines) return NULL; - r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines); - free (lines); + r = guestfs_zero (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1932,22 +3818,21 @@ py_guestfs_sfdisk (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_write_file (PyObject *self, PyObject *args) +py_guestfs_grub_install (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; - const char *content; - int size; + const char *root; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file", - &py_g, &path, &content, &size)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install", + &py_g, &root, &device)) return NULL; g = get_handle (py_g); - r = guestfs_write_file (g, path, content, size); + r = guestfs_grub_install (g, root, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1959,20 +3844,21 @@ py_guestfs_write_file (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_umount (PyObject *self, PyObject *args) +py_guestfs_cp (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *pathordevice; + const char *src; + const char *dest; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount", - &py_g, &pathordevice)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp", + &py_g, &src, &dest)) return NULL; g = get_handle (py_g); - r = guestfs_umount (g, pathordevice); + r = guestfs_cp (g, src, dest); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1984,43 +3870,47 @@ py_guestfs_umount (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_mounts (PyObject *self, PyObject *args) +py_guestfs_cp_a (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + int r; + const char *src; + const char *dest; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a", + &py_g, &src, &dest)) return NULL; g = get_handle (py_g); - r = guestfs_mounts (g); - if (r == NULL) { + r = guestfs_cp_a (g, src, dest); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_string_list (r); - free_strings (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_umount_all (PyObject *self, PyObject *args) +py_guestfs_mv (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; + const char *src; + const char *dest; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv", + &py_g, &src, &dest)) return NULL; g = get_handle (py_g); - r = guestfs_umount_all (g); + r = guestfs_mv (g, src, dest); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2032,19 +3922,20 @@ py_guestfs_umount_all (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_lvm_remove_all (PyObject *self, PyObject *args) +py_guestfs_drop_caches (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; + int whattodrop; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches", + &py_g, &whattodrop)) return NULL; g = get_handle (py_g); - r = guestfs_lvm_remove_all (g); + r = guestfs_drop_caches (g, whattodrop); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2056,20 +3947,19 @@ py_guestfs_lvm_remove_all (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_file (PyObject *self, PyObject *args) +py_guestfs_dmesg (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; char *r; - const char *path; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_dmesg", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_file (g, path); + r = guestfs_dmesg (g); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2081,165 +3971,157 @@ py_guestfs_file (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_command (PyObject *self, PyObject *args) +py_guestfs_ping_daemon (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - PyObject *py_arguments; - const char **arguments; + int r; - if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command", - &py_g, &py_arguments)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_ping_daemon", + &py_g)) return NULL; g = get_handle (py_g); - arguments = get_string_list (py_arguments); - if (!arguments) return NULL; - r = guestfs_command (g, arguments); - free (arguments); - if (r == NULL) { + r = guestfs_ping_daemon (g); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyString_FromString (r); - free (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_command_lines (PyObject *self, PyObject *args) +py_guestfs_equal (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; - PyObject *py_arguments; - const char **arguments; + int r; + const char *file1; + const char *file2; - if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines", - &py_g, &py_arguments)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_equal", + &py_g, &file1, &file2)) return NULL; g = get_handle (py_g); - arguments = get_string_list (py_arguments); - if (!arguments) return NULL; - r = guestfs_command_lines (g, arguments); - free (arguments); - if (r == NULL) { + r = guestfs_equal (g, file1, file2); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_string_list (r); - free_strings (r); + py_r = PyInt_FromLong ((long) r); return py_r; } static PyObject * -py_guestfs_stat (PyObject *self, PyObject *args) +py_guestfs_strings (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_stat *r; + char **r; const char *path; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_strings", &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_stat (g, path); + r = guestfs_strings (g, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_stat (r); - free (r); + py_r = put_string_list (r); + free_strings (r); return py_r; } static PyObject * -py_guestfs_lstat (PyObject *self, PyObject *args) +py_guestfs_strings_e (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_stat *r; + char **r; + const char *encoding; const char *path; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_strings_e", + &py_g, &encoding, &path)) return NULL; g = get_handle (py_g); - r = guestfs_lstat (g, path); + r = guestfs_strings_e (g, encoding, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_stat (r); - free (r); + py_r = put_string_list (r); + free_strings (r); return py_r; } static PyObject * -py_guestfs_statvfs (PyObject *self, PyObject *args) +py_guestfs_hexdump (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_statvfs *r; + char *r; const char *path; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_hexdump", &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_statvfs (g, path); + r = guestfs_hexdump (g, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_statvfs (r); + py_r = PyString_FromString (r); free (r); return py_r; } static PyObject * -py_guestfs_tune2fs_l (PyObject *self, PyObject *args) +py_guestfs_zerofree (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + int r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zerofree", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_tune2fs_l (g, device); - if (r == NULL) { + r = guestfs_zerofree (g, device); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_table (r); - free_strings (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_blockdev_setro (PyObject *self, PyObject *args) +py_guestfs_pvresize (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; @@ -2247,12 +4129,12 @@ py_guestfs_blockdev_setro (PyObject *self, PyObject *args) int r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setro", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvresize", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_setro (g, device); + r = guestfs_pvresize (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2264,20 +4146,25 @@ py_guestfs_blockdev_setro (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_blockdev_setrw (PyObject *self, PyObject *args) +py_guestfs_sfdisk_N (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; const char *device; + int n; + int cyls; + int heads; + int sectors; + const char *line; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Osiiiis:guestfs_sfdisk_N", + &py_g, &device, &n, &cyls, &heads, §ors, &line)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_setrw (g, device); + r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2289,93 +4176,95 @@ py_guestfs_blockdev_setrw (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_blockdev_getro (PyObject *self, PyObject *args) +py_guestfs_sfdisk_l (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + char *r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_l", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getro (g, device); - if (r == -1) { + r = guestfs_sfdisk_l (g, device); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_blockdev_getss (PyObject *self, PyObject *args) +py_guestfs_sfdisk_kernel_geometry (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + char *r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_kernel_geometry", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getss (g, device); - if (r == -1) { + r = guestfs_sfdisk_kernel_geometry (g, device); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_blockdev_getbsz (PyObject *self, PyObject *args) +py_guestfs_sfdisk_disk_geometry (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + char *r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_disk_geometry", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getbsz (g, device); - if (r == -1) { + r = guestfs_sfdisk_disk_geometry (g, device); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args) +py_guestfs_vg_activate_all (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *device; - int blocksize; + int activate; - if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz", - &py_g, &device, &blocksize)) + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_vg_activate_all", + &py_g, &activate)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_setbsz (g, device, blocksize); + r = guestfs_vg_activate_all (g, activate); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2387,55 +4276,63 @@ py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_blockdev_getsz (PyObject *self, PyObject *args) +py_guestfs_vg_activate (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int64_t r; - const char *device; + int r; + int activate; + PyObject *py_volgroups; + const char **volgroups; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "OiO:guestfs_vg_activate", + &py_g, &activate, &py_volgroups)) return NULL; g = get_handle (py_g); + volgroups = get_string_list (py_volgroups); + if (!volgroups) return NULL; - r = guestfs_blockdev_getsz (g, device); + r = guestfs_vg_activate (g, activate, volgroups); + free (volgroups); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyLong_FromLongLong (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args) +py_guestfs_lvresize (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int64_t r; + int r; const char *device; + int mbytes; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_lvresize", + &py_g, &device, &mbytes)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getsize64 (g, device); + r = guestfs_lvresize (g, device, mbytes); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyLong_FromLongLong (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args) +py_guestfs_resize2fs (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; @@ -2443,12 +4340,12 @@ py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args) int r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_resize2fs", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_flushbufs (g, device); + r = guestfs_resize2fs (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2460,46 +4357,45 @@ py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args) +py_guestfs_find (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *device; + char **r; + const char *directory; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_find", + &py_g, &directory)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_rereadpt (g, device); - if (r == -1) { + r = guestfs_find (g, directory); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - Py_INCREF (Py_None); - py_r = Py_None; + py_r = put_string_list (r); + free_strings (r); return py_r; } static PyObject * -py_guestfs_upload (PyObject *self, PyObject *args) +py_guestfs_e2fsck_f (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *filename; - const char *remotefilename; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload", - &py_g, &filename, &remotefilename)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_e2fsck_f", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_upload (g, filename, remotefilename); + r = guestfs_e2fsck_f (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2511,21 +4407,20 @@ py_guestfs_upload (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_download (PyObject *self, PyObject *args) +py_guestfs_sleep (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *remotefilename; - const char *filename; + int secs; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download", - &py_g, &remotefilename, &filename)) + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_sleep", + &py_g, &secs)) return NULL; g = get_handle (py_g); - r = guestfs_download (g, remotefilename, filename); + r = guestfs_sleep (g, secs); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2537,42 +4432,73 @@ py_guestfs_download (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_checksum (PyObject *self, PyObject *args) +py_guestfs_ntfs_3g_probe (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *csumtype; - const char *path; + int r; + int rw; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum", - &py_g, &csumtype, &path)) + if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_ntfs_3g_probe", + &py_g, &rw, &device)) return NULL; g = get_handle (py_g); - r = guestfs_checksum (g, csumtype, path); - if (r == NULL) { + r = guestfs_ntfs_3g_probe (g, rw, device); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyString_FromString (r); - free (r); + py_r = PyInt_FromLong ((long) r); return py_r; } static PyMethodDef methods[] = { { (char *) "create", py_guestfs_create, METH_VARARGS, NULL }, { (char *) "close", py_guestfs_close, METH_VARARGS, NULL }, + { (char *) "test0", py_guestfs_test0, METH_VARARGS, NULL }, + { (char *) "test0rint", py_guestfs_test0rint, METH_VARARGS, NULL }, + { (char *) "test0rinterr", py_guestfs_test0rinterr, METH_VARARGS, NULL }, + { (char *) "test0rint64", py_guestfs_test0rint64, METH_VARARGS, NULL }, + { (char *) "test0rint64err", py_guestfs_test0rint64err, METH_VARARGS, NULL }, + { (char *) "test0rbool", py_guestfs_test0rbool, METH_VARARGS, NULL }, + { (char *) "test0rboolerr", py_guestfs_test0rboolerr, METH_VARARGS, NULL }, + { (char *) "test0rconststring", py_guestfs_test0rconststring, METH_VARARGS, NULL }, + { (char *) "test0rconststringerr", py_guestfs_test0rconststringerr, METH_VARARGS, NULL }, + { (char *) "test0rstring", py_guestfs_test0rstring, METH_VARARGS, NULL }, + { (char *) "test0rstringerr", py_guestfs_test0rstringerr, METH_VARARGS, NULL }, + { (char *) "test0rstringlist", py_guestfs_test0rstringlist, METH_VARARGS, NULL }, + { (char *) "test0rstringlisterr", py_guestfs_test0rstringlisterr, METH_VARARGS, NULL }, + { (char *) "test0rintbool", py_guestfs_test0rintbool, METH_VARARGS, NULL }, + { (char *) "test0rintboolerr", py_guestfs_test0rintboolerr, METH_VARARGS, NULL }, + { (char *) "test0rpvlist", py_guestfs_test0rpvlist, METH_VARARGS, NULL }, + { (char *) "test0rpvlisterr", py_guestfs_test0rpvlisterr, METH_VARARGS, NULL }, + { (char *) "test0rvglist", py_guestfs_test0rvglist, METH_VARARGS, NULL }, + { (char *) "test0rvglisterr", py_guestfs_test0rvglisterr, METH_VARARGS, NULL }, + { (char *) "test0rlvlist", py_guestfs_test0rlvlist, METH_VARARGS, NULL }, + { (char *) "test0rlvlisterr", py_guestfs_test0rlvlisterr, METH_VARARGS, NULL }, + { (char *) "test0rstat", py_guestfs_test0rstat, METH_VARARGS, NULL }, + { (char *) "test0rstaterr", py_guestfs_test0rstaterr, METH_VARARGS, NULL }, + { (char *) "test0rstatvfs", py_guestfs_test0rstatvfs, METH_VARARGS, NULL }, + { (char *) "test0rstatvfserr", py_guestfs_test0rstatvfserr, METH_VARARGS, NULL }, + { (char *) "test0rhashtable", py_guestfs_test0rhashtable, METH_VARARGS, NULL }, + { (char *) "test0rhashtableerr", py_guestfs_test0rhashtableerr, METH_VARARGS, NULL }, { (char *) "launch", py_guestfs_launch, METH_VARARGS, NULL }, { (char *) "wait_ready", py_guestfs_wait_ready, METH_VARARGS, NULL }, { (char *) "kill_subprocess", py_guestfs_kill_subprocess, METH_VARARGS, NULL }, { (char *) "add_drive", py_guestfs_add_drive, METH_VARARGS, NULL }, { (char *) "add_cdrom", py_guestfs_add_cdrom, METH_VARARGS, NULL }, + { (char *) "add_drive_ro", py_guestfs_add_drive_ro, METH_VARARGS, NULL }, { (char *) "config", py_guestfs_config, METH_VARARGS, NULL }, + { (char *) "set_qemu", py_guestfs_set_qemu, METH_VARARGS, NULL }, + { (char *) "get_qemu", py_guestfs_get_qemu, METH_VARARGS, NULL }, { (char *) "set_path", py_guestfs_set_path, METH_VARARGS, NULL }, { (char *) "get_path", py_guestfs_get_path, METH_VARARGS, NULL }, + { (char *) "set_append", py_guestfs_set_append, METH_VARARGS, NULL }, + { (char *) "get_append", py_guestfs_get_append, METH_VARARGS, NULL }, { (char *) "set_autosync", py_guestfs_set_autosync, METH_VARARGS, NULL }, { (char *) "get_autosync", py_guestfs_get_autosync, METH_VARARGS, NULL }, { (char *) "set_verbose", py_guestfs_set_verbose, METH_VARARGS, NULL }, @@ -2584,6 +4510,7 @@ static PyMethodDef methods[] = { { (char *) "get_state", py_guestfs_get_state, METH_VARARGS, NULL }, { (char *) "set_busy", py_guestfs_set_busy, METH_VARARGS, NULL }, { (char *) "set_ready", py_guestfs_set_ready, METH_VARARGS, NULL }, + { (char *) "end_busy", py_guestfs_end_busy, METH_VARARGS, NULL }, { (char *) "mount", py_guestfs_mount, METH_VARARGS, NULL }, { (char *) "sync", py_guestfs_sync, METH_VARARGS, NULL }, { (char *) "touch", py_guestfs_touch, METH_VARARGS, NULL }, @@ -2652,6 +4579,48 @@ static PyMethodDef methods[] = { { (char *) "upload", py_guestfs_upload, METH_VARARGS, NULL }, { (char *) "download", py_guestfs_download, METH_VARARGS, NULL }, { (char *) "checksum", py_guestfs_checksum, METH_VARARGS, NULL }, + { (char *) "tar_in", py_guestfs_tar_in, METH_VARARGS, NULL }, + { (char *) "tar_out", py_guestfs_tar_out, METH_VARARGS, NULL }, + { (char *) "tgz_in", py_guestfs_tgz_in, METH_VARARGS, NULL }, + { (char *) "tgz_out", py_guestfs_tgz_out, METH_VARARGS, NULL }, + { (char *) "mount_ro", py_guestfs_mount_ro, METH_VARARGS, NULL }, + { (char *) "mount_options", py_guestfs_mount_options, METH_VARARGS, NULL }, + { (char *) "mount_vfs", py_guestfs_mount_vfs, METH_VARARGS, NULL }, + { (char *) "debug", py_guestfs_debug, METH_VARARGS, NULL }, + { (char *) "lvremove", py_guestfs_lvremove, METH_VARARGS, NULL }, + { (char *) "vgremove", py_guestfs_vgremove, METH_VARARGS, NULL }, + { (char *) "pvremove", py_guestfs_pvremove, METH_VARARGS, NULL }, + { (char *) "set_e2label", py_guestfs_set_e2label, METH_VARARGS, NULL }, + { (char *) "get_e2label", py_guestfs_get_e2label, METH_VARARGS, NULL }, + { (char *) "set_e2uuid", py_guestfs_set_e2uuid, METH_VARARGS, NULL }, + { (char *) "get_e2uuid", py_guestfs_get_e2uuid, METH_VARARGS, NULL }, + { (char *) "fsck", py_guestfs_fsck, METH_VARARGS, NULL }, + { (char *) "zero", py_guestfs_zero, METH_VARARGS, NULL }, + { (char *) "grub_install", py_guestfs_grub_install, METH_VARARGS, NULL }, + { (char *) "cp", py_guestfs_cp, METH_VARARGS, NULL }, + { (char *) "cp_a", py_guestfs_cp_a, METH_VARARGS, NULL }, + { (char *) "mv", py_guestfs_mv, METH_VARARGS, NULL }, + { (char *) "drop_caches", py_guestfs_drop_caches, METH_VARARGS, NULL }, + { (char *) "dmesg", py_guestfs_dmesg, METH_VARARGS, NULL }, + { (char *) "ping_daemon", py_guestfs_ping_daemon, METH_VARARGS, NULL }, + { (char *) "equal", py_guestfs_equal, METH_VARARGS, NULL }, + { (char *) "strings", py_guestfs_strings, METH_VARARGS, NULL }, + { (char *) "strings_e", py_guestfs_strings_e, METH_VARARGS, NULL }, + { (char *) "hexdump", py_guestfs_hexdump, METH_VARARGS, NULL }, + { (char *) "zerofree", py_guestfs_zerofree, METH_VARARGS, NULL }, + { (char *) "pvresize", py_guestfs_pvresize, METH_VARARGS, NULL }, + { (char *) "sfdisk_N", py_guestfs_sfdisk_N, METH_VARARGS, NULL }, + { (char *) "sfdisk_l", py_guestfs_sfdisk_l, METH_VARARGS, NULL }, + { (char *) "sfdisk_kernel_geometry", py_guestfs_sfdisk_kernel_geometry, METH_VARARGS, NULL }, + { (char *) "sfdisk_disk_geometry", py_guestfs_sfdisk_disk_geometry, METH_VARARGS, NULL }, + { (char *) "vg_activate_all", py_guestfs_vg_activate_all, METH_VARARGS, NULL }, + { (char *) "vg_activate", py_guestfs_vg_activate, METH_VARARGS, NULL }, + { (char *) "lvresize", py_guestfs_lvresize, METH_VARARGS, NULL }, + { (char *) "resize2fs", py_guestfs_resize2fs, METH_VARARGS, NULL }, + { (char *) "find", py_guestfs_find, METH_VARARGS, NULL }, + { (char *) "e2fsck_f", py_guestfs_e2fsck_f, METH_VARARGS, NULL }, + { (char *) "sleep", py_guestfs_sleep, METH_VARARGS, NULL }, + { (char *) "ntfs_3g_probe", py_guestfs_ntfs_3g_probe, METH_VARARGS, NULL }, { NULL, NULL, 0, NULL } };