X-Git-Url: http://git.annexia.org/?p=libguestfs.git;a=blobdiff_plain;f=python%2Fguestfs-py.c;h=263d3d9f780fed099f4da2b9dba8234de5368802;hp=b85ba1aae0c448a9f3af46ef1afa6e5578280456;hb=215041c7178922341ecbfdb23eb203f2bb8c29c4;hpb=ac286b26df1aabceca26dac66c325a3676ace4cc diff --git a/python/guestfs-py.c b/python/guestfs-py.c index b85ba1a..263d3d9 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_qemu (PyObject *self, PyObject *args) +py_guestfs_test0rboolerr (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)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rboolerr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_qemu (g, qemu); + 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_qemu (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_qemu", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rconststring", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_get_qemu (g); + r = guestfs_test0rconststring (g, val); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -585,695 +589,709 @@ py_guestfs_get_qemu (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_set_path (PyObject *self, PyObject *args) +py_guestfs_test0rconststringerr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *path; + const char *r; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rconststringerr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_path (g, path); - 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_path (PyObject *self, PyObject *args) +py_guestfs_test0rstring (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - const char *r; + char *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstring", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_get_path (g); + r = guestfs_test0rstring (g, val); 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_set_autosync (PyObject *self, PyObject *args) +py_guestfs_test0rstringerr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - int autosync; + char *r; - if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync", - &py_g, &autosync)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstringerr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_autosync (g, autosync); - 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_autosync (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_autosync", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstringlist", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_get_autosync (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_set_verbose (PyObject *self, PyObject *args) +py_guestfs_test0rstringlisterr (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_test0rstringlisterr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_verbose (g, verbose); - if (r == -1) { + r = guestfs_test0rstringlisterr (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_string_list (r); + free_strings (r); return py_r; } static PyObject * -py_guestfs_get_verbose (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_get_verbose", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rintbool", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_get_verbose (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_ready (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_ready", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rintboolerr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_is_ready (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_config (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_config", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rpvlist", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_is_config (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_is_launching (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_is_launching", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rpvlisterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_is_launching (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_is_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_is_busy", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rvglist", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_is_busy (g); - if (r == -1) { + r = guestfs_test0rvglist (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_vg_list (r); + guestfs_free_lvm_vg_list (r); return py_r; } static PyObject * -py_guestfs_get_state (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_get_state", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rvglisterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_get_state (g); - if (r == -1) { + r = guestfs_test0rvglisterr (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyInt_FromLong ((long) r); + py_r = put_lvm_vg_list (r); + guestfs_free_lvm_vg_list (r); return py_r; } static PyObject * -py_guestfs_set_busy (PyObject *self, PyObject *args) +py_guestfs_test0rlvlist (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_lvm_lv_list *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_set_busy", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rlvlist", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_set_busy (g); - 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_set_ready (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_set_ready", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rlvlisterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_set_ready (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_mount (PyObject *self, PyObject *args) +py_guestfs_test0rstat (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *device; - const char *mountpoint; + struct guestfs_stat *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount", - &py_g, &device, &mountpoint)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstat", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_mount (g, device, mountpoint); - 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_sync (PyObject *self, PyObject *args) +py_guestfs_test0rstaterr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_stat *r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_sync", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstaterr", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_sync (g); - if (r == -1) { + r = guestfs_test0rstaterr (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_stat (r); + free (r); return py_r; } static PyObject * -py_guestfs_touch (PyObject *self, PyObject *args) +py_guestfs_test0rstatvfs (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *path; + struct guestfs_statvfs *r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_touch", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rstatvfs", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_touch (g, path); - if (r == -1) { + r = guestfs_test0rstatvfs (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_statvfs (r); + free (r); return py_r; } static PyObject * -py_guestfs_cat (PyObject *self, PyObject *args) +py_guestfs_test0rstatvfserr (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *path; + struct guestfs_statvfs *r; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_cat", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_test0rstatvfserr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_cat (g, path); + r = guestfs_test0rstatvfserr (g); 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_ll (PyObject *self, PyObject *args) +py_guestfs_test0rhashtable (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *directory; + char **r; + const char *val; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_ll", - &py_g, &directory)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_test0rhashtable", + &py_g, &val)) return NULL; g = get_handle (py_g); - r = guestfs_ll (g, directory); + r = guestfs_test0rhashtable (g, val); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyString_FromString (r); - free (r); + py_r = put_table (r); + free_strings (r); return py_r; } static PyObject * -py_guestfs_ls (PyObject *self, PyObject *args) +py_guestfs_test0rhashtableerr (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_test0rhashtableerr", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_ls (g, directory); + r = guestfs_test0rhashtableerr (g); 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_list_devices (PyObject *self, PyObject *args) +py_guestfs_launch (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_launch", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_list_devices (g); - if (r == NULL) { + r = guestfs_launch (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_wait_ready (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_wait_ready", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_list_partitions (g); - if (r == NULL) { + r = guestfs_wait_ready (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_kill_subprocess (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + int r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_kill_subprocess", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_pvs (g); - if (r == NULL) { + r = guestfs_kill_subprocess (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_vgs (PyObject *self, PyObject *args) +py_guestfs_add_drive (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + int r; + const char *filename; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive", + &py_g, &filename)) return NULL; g = get_handle (py_g); - r = guestfs_vgs (g); - if (r == NULL) { + r = guestfs_add_drive (g, filename); + 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_lvs (PyObject *self, PyObject *args) +py_guestfs_add_cdrom (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + int r; + const char *filename; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_cdrom", + &py_g, &filename)) return NULL; g = get_handle (py_g); - r = guestfs_lvs (g); - if (r == NULL) { + r = guestfs_add_cdrom (g, filename); + 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_full (PyObject *self, PyObject *args) +py_guestfs_add_drive_ro (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_lvm_pv_list *r; + int r; + const char *filename; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_pvs_full", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_add_drive_ro", + &py_g, &filename)) return NULL; g = get_handle (py_g); - r = guestfs_pvs_full (g); - if (r == NULL) { + r = guestfs_add_drive_ro (g, filename); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_lvm_pv_list (r); - guestfs_free_lvm_pv_list (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_vgs_full (PyObject *self, PyObject *args) +py_guestfs_config (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_lvm_vg_list *r; + int r; + const char *qemuparam; + const char *qemuvalue; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_vgs_full", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_config", + &py_g, &qemuparam, &qemuvalue)) return NULL; g = get_handle (py_g); - r = guestfs_vgs_full (g); - if (r == NULL) { + r = guestfs_config (g, qemuparam, qemuvalue); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_lvm_vg_list (r); - guestfs_free_lvm_vg_list (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_lvs_full (PyObject *self, PyObject *args) +py_guestfs_set_qemu (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_lvm_lv_list *r; + int r; + const char *qemu; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvs_full", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_qemu", + &py_g, &qemu)) return NULL; g = get_handle (py_g); - r = guestfs_lvs_full (g); - if (r == NULL) { + r = guestfs_set_qemu (g, qemu); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_lvm_lv_list (r); - guestfs_free_lvm_lv_list (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_read_lines (PyObject *self, PyObject *args) +py_guestfs_get_qemu (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; - const char *path; + const char *r; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_read_lines", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_qemu", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_read_lines (g, path); + r = guestfs_get_qemu (g); 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); return py_r; } static PyObject * -py_guestfs_aug_init (PyObject *self, PyObject *args) +py_guestfs_set_path (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *root; - int flags; + const char *path; - if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_aug_init", - &py_g, &root, &flags)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_path", + &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_aug_init (g, root, flags); + r = guestfs_set_path (g, path); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1285,151 +1303,1437 @@ py_guestfs_aug_init (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_close (PyObject *self, PyObject *args) +py_guestfs_get_path (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + const char *r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_close", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_path", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_aug_close (g); - if (r == -1) { + r = guestfs_get_path (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_aug_defvar (PyObject *self, PyObject *args) +py_guestfs_set_append (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *name; - const char *expr; + const char *append; - if (!PyArg_ParseTuple (args, (char *) "Osz:guestfs_aug_defvar", - &py_g, &name, &expr)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_set_append", + &py_g, &append)) return NULL; g = get_handle (py_g); - r = guestfs_aug_defvar (g, name, expr); + r = guestfs_set_append (g, append); 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_defnode (PyObject *self, PyObject *args) +py_guestfs_get_append (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; + const char *r; - if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_aug_defnode", - &py_g, &name, &expr, &val)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_append", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_aug_defnode (g, name, expr, val); + r = guestfs_get_append (g); 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); + py_r = PyString_FromString (r); return py_r; } static PyObject * -py_guestfs_aug_get (PyObject *self, PyObject *args) +py_guestfs_set_autosync (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *path; + int r; + int autosync; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_aug_get", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_set_autosync", + &py_g, &autosync)) return NULL; g = get_handle (py_g); - r = guestfs_aug_get (g, path); - if (r == NULL) { + r = guestfs_set_autosync (g, autosync); + 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_aug_set (PyObject *self, PyObject *args) +py_guestfs_get_autosync (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)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_get_autosync", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_aug_set (g, path, val); + r = guestfs_get_autosync (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_aug_insert (PyObject *self, PyObject *args) +py_guestfs_set_verbose (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *path; - const char *label; + 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)) + 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_aug_insert (g, path, label, before); + r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines); + free (lines); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1441,45 +2745,47 @@ py_guestfs_aug_insert (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_rm (PyObject *self, PyObject *args) +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 *) "Os:guestfs_aug_rm", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file", + &py_g, &path, &content, &size)) return NULL; g = get_handle (py_g); - r = guestfs_aug_rm (g, path); + r = guestfs_write_file (g, path, content, size); 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_umount (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *src; - const char *dest; + const char *pathordevice; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_aug_mv", - &py_g, &src, &dest)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount", + &py_g, &pathordevice)) return NULL; g = get_handle (py_g); - r = guestfs_aug_mv (g, src, dest); + r = guestfs_umount (g, pathordevice); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1491,20 +2797,19 @@ py_guestfs_aug_mv (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_match (PyObject *self, PyObject *args) +py_guestfs_mounts (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)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_aug_match (g, path); + r = guestfs_mounts (g); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1516,19 +2821,19 @@ py_guestfs_aug_match (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_save (PyObject *self, PyObject *args) +py_guestfs_umount_all (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_save", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_aug_save (g); + r = guestfs_umount_all (g); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1540,19 +2845,19 @@ py_guestfs_aug_save (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_load (PyObject *self, PyObject *args) +py_guestfs_lvm_remove_all (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_aug_load", + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all", &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_aug_load (g); + r = guestfs_lvm_remove_all (g); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1564,20 +2869,78 @@ py_guestfs_aug_load (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_aug_ls (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 *) "Os:guestfs_aug_ls", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file", &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_aug_ls (g, path); + r = guestfs_file (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_command (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 *) "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_command (g, arguments); + free (arguments); + 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_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 *) "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_command_lines (g, arguments); + free (arguments); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1589,20 +2952,145 @@ py_guestfs_aug_ls (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_rm (PyObject *self, PyObject *args) +py_guestfs_stat (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + struct guestfs_stat *r; const char *path; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rm", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_stat (g, path); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_stat (r); + free (r); + return py_r; +} + +static PyObject * +py_guestfs_lstat (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + struct guestfs_stat *r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat", + &py_g, &path)) + return NULL; + g = get_handle (py_g); + + r = guestfs_lstat (g, path); + if (r == NULL) { + PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); + return NULL; + } + + py_r = put_stat (r); + free (r); + return py_r; +} + +static PyObject * +py_guestfs_statvfs (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + struct guestfs_statvfs *r; + const char *path; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs", &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_rm (g, path); + r = guestfs_statvfs (g, path); + 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_tune2fs_l (PyObject *self, PyObject *args) +{ + PyObject *py_g; + guestfs_h *g; + PyObject *py_r; + char **r; + const char *device; + + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l", + &py_g, &device)) + return NULL; + g = get_handle (py_g); + + r = guestfs_tune2fs_l (g, device); + 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_blockdev_setro (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_setro", + &py_g, &device)) + return NULL; + g = get_handle (py_g); + + r = guestfs_blockdev_setro (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_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 *) "Os:guestfs_blockdev_setrw", + &py_g, &device)) + return NULL; + g = get_handle (py_g); + + r = guestfs_blockdev_setrw (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1614,95 +3102,93 @@ py_guestfs_rm (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_rmdir (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 *path; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_rmdir", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_rmdir (g, path); + r = guestfs_blockdev_getro (g, 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_rm_rf (PyObject *self, PyObject *args) +py_guestfs_blockdev_getss (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_rm_rf", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_rm_rf (g, path); + r = guestfs_blockdev_getss (g, 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_mkdir (PyObject *self, PyObject *args) +py_guestfs_blockdev_getbsz (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_mkdir", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_mkdir (g, path); + r = guestfs_blockdev_getbsz (g, 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_mkdir_p (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 *path; + const char *device; + int blocksize; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdir_p", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz", + &py_g, &device, &blocksize)) return NULL; g = get_handle (py_g); - r = guestfs_mkdir_p (g, path); + r = guestfs_blockdev_setbsz (g, device, blocksize); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1714,145 +3200,145 @@ py_guestfs_mkdir_p (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_chmod (PyObject *self, PyObject *args) +py_guestfs_blockdev_getsz (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - int mode; - const char *path; + int64_t r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_chmod", - &py_g, &mode, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_chmod (g, mode, path); + r = guestfs_blockdev_getsz (g, device); 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_chown (PyObject *self, PyObject *args) +py_guestfs_blockdev_getsize64 (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - int owner; - int group; - const char *path; + int64_t r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oiis:guestfs_chown", - &py_g, &owner, &group, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_chown (g, owner, group, path); + r = guestfs_blockdev_getsize64 (g, device); 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_exists (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 *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_exists", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_flushbufs", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_exists (g, path); + r = guestfs_blockdev_flushbufs (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_file (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 *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_is_file", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_rereadpt", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_is_file (g, path); + r = guestfs_blockdev_rereadpt (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_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_is_dir", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload", + &py_g, &filename, &remotefilename)) return NULL; g = get_handle (py_g); - r = guestfs_is_dir (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_pvcreate (PyObject *self, PyObject *args) +py_guestfs_download (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *device; + const char *remotefilename; + const char *filename; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvcreate", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download", + &py_g, &remotefilename, &filename)) return NULL; g = get_handle (py_g); - r = guestfs_pvcreate (g, device); + r = guestfs_download (g, remotefilename, filename); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1864,52 +3350,47 @@ py_guestfs_pvcreate (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_vgcreate (PyObject *self, PyObject *args) +py_guestfs_checksum (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *volgroup; - PyObject *py_physvols; - const char **physvols; + char *r; + const char *csumtype; + const char *path; - if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_vgcreate", - &py_g, &volgroup, &py_physvols)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum", + &py_g, &csumtype, &path)) 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) { + r = guestfs_checksum (g, csumtype, path); + 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_lvcreate (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 *logvol; - const char *volgroup; - int mbytes; + const char *tarfile; + const char *directory; - if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_lvcreate", - &py_g, &logvol, &volgroup, &mbytes)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in", + &py_g, &tarfile, &directory)) return NULL; g = get_handle (py_g); - r = guestfs_lvcreate (g, logvol, volgroup, mbytes); + r = guestfs_tar_in (g, tarfile, directory); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1921,21 +3402,21 @@ py_guestfs_lvcreate (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_mkfs (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 *fstype; - const char *device; + const char *directory; + const char *tarfile; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mkfs", - &py_g, &fstype, &device)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out", + &py_g, &directory, &tarfile)) return NULL; g = get_handle (py_g); - r = guestfs_mkfs (g, fstype, device); + r = guestfs_tar_out (g, directory, tarfile); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1947,28 +3428,21 @@ py_guestfs_mkfs (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_sfdisk (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 *device; - int cyls; - int heads; - int sectors; - PyObject *py_lines; - const char **lines; + const char *tarball; + const char *directory; - if (!PyArg_ParseTuple (args, (char *) "OsiiiO:guestfs_sfdisk", - &py_g, &device, &cyls, &heads, §ors, &py_lines)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in", + &py_g, &tarball, &directory)) 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_tgz_in (g, tarball, directory); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -1980,22 +3454,21 @@ py_guestfs_sfdisk (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_write_file (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 *content; - int size; + const char *directory; + const char *tarball; - if (!PyArg_ParseTuple (args, (char *) "Ossi:guestfs_write_file", - &py_g, &path, &content, &size)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out", + &py_g, &directory, &tarball)) return NULL; g = get_handle (py_g); - r = guestfs_write_file (g, path, content, size); + r = guestfs_tgz_out (g, directory, tarball); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2007,20 +3480,21 @@ py_guestfs_write_file (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_umount (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 *pathordevice; + const char *device; + const char *mountpoint; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_umount", - &py_g, &pathordevice)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro", + &py_g, &device, &mountpoint)) return NULL; g = get_handle (py_g); - r = guestfs_umount (g, pathordevice); + r = guestfs_mount_ro (g, device, mountpoint); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2032,43 +3506,50 @@ py_guestfs_umount (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_mounts (PyObject *self, PyObject *args) +py_guestfs_mount_options (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + int r; + const char *options; + const char *device; + const char *mountpoint; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_mounts", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options", + &py_g, &options, &device, &mountpoint)) return NULL; g = get_handle (py_g); - r = guestfs_mounts (g); - if (r == NULL) { + r = guestfs_mount_options (g, options, device, mountpoint); + 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_mount_vfs (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; + const char *options; + const char *vfstype; + const char *device; + const char *mountpoint; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_umount_all", - &py_g)) + if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs", + &py_g, &options, &vfstype, &device, &mountpoint)) return NULL; g = get_handle (py_g); - r = guestfs_umount_all (g); + r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2080,239 +3561,239 @@ py_guestfs_umount_all (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_lvm_remove_all (PyObject *self, PyObject *args) +py_guestfs_debug (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; + char *r; + const char *subcmd; + PyObject *py_extraargs; + const char **extraargs; - if (!PyArg_ParseTuple (args, (char *) "O:guestfs_lvm_remove_all", - &py_g)) + 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_lvm_remove_all (g); - 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_file (PyObject *self, PyObject *args) +py_guestfs_lvremove (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *path; + int r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_file", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_file (g, path); - if (r == NULL) { + r = guestfs_lvremove (g, device); + 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 (PyObject *self, PyObject *args) +py_guestfs_vgremove (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 *vgname; - if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command", - &py_g, &py_arguments)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove", + &py_g, &vgname)) 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_vgremove (g, vgname); + 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_pvremove (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 *device; - if (!PyArg_ParseTuple (args, (char *) "OO:guestfs_command_lines", - &py_g, &py_arguments)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvremove", + &py_g, &device)) 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_pvremove (g, device); + 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_stat (PyObject *self, PyObject *args) +py_guestfs_set_e2label (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_stat *r; - const char *path; + int r; + const char *device; + const char *label; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_stat", - &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_stat (g, path); - if (r == NULL) { + r = guestfs_set_e2label (g, device, label); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_stat (r); - free (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_lstat (PyObject *self, PyObject *args) +py_guestfs_get_e2label (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_stat *r; - const char *path; + char *r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lstat", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_lstat (g, path); + r = guestfs_get_e2label (g, device); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_stat (r); + py_r = PyString_FromString (r); free (r); return py_r; } static PyObject * -py_guestfs_statvfs (PyObject *self, PyObject *args) +py_guestfs_set_e2uuid (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - struct guestfs_statvfs *r; - const char *path; + int r; + const char *device; + const char *uuid; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_statvfs", - &py_g, &path)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid", + &py_g, &device, &uuid)) return NULL; g = get_handle (py_g); - r = guestfs_statvfs (g, path); - if (r == NULL) { + r = guestfs_set_e2uuid (g, device, uuid); + if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_statvfs (r); - free (r); + Py_INCREF (Py_None); + py_r = Py_None; return py_r; } static PyObject * -py_guestfs_tune2fs_l (PyObject *self, PyObject *args) +py_guestfs_get_e2uuid (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char **r; + char *r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_tune2fs_l", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_tune2fs_l (g, device); + r = guestfs_get_e2uuid (g, device); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = put_table (r); - free_strings (r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_blockdev_setro (PyObject *self, PyObject *args) +py_guestfs_fsck (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 *) "Os:guestfs_blockdev_setro", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck", + &py_g, &fstype, &device)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_setro (g, 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_blockdev_setrw (PyObject *self, PyObject *args) +py_guestfs_zero (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; @@ -2320,12 +3801,12 @@ py_guestfs_blockdev_setrw (PyObject *self, PyObject *args) int r; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_setrw", + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero", &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_setrw (g, device); + r = guestfs_zero (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2337,93 +3818,99 @@ py_guestfs_blockdev_setrw (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_blockdev_getro (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 *root; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getro", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install", + &py_g, &root, &device)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getro (g, device); + r = guestfs_grub_install (g, root, 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_blockdev_getss (PyObject *self, PyObject *args) +py_guestfs_cp (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *device; + const char *src; + const char *dest; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getss", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp", + &py_g, &src, &dest)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getss (g, device); + r = guestfs_cp (g, src, dest); 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_blockdev_getbsz (PyObject *self, PyObject *args) +py_guestfs_cp_a (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *device; + const char *src; + const char *dest; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getbsz", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a", + &py_g, &src, &dest)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getbsz (g, device); + r = guestfs_cp_a (g, src, dest); 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_blockdev_setbsz (PyObject *self, PyObject *args) +py_guestfs_mv (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *device; - int blocksize; + const char *src; + const char *dest; - if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_blockdev_setbsz", - &py_g, &device, &blocksize)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv", + &py_g, &src, &dest)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_setbsz (g, device, blocksize); + r = guestfs_mv (g, src, dest); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2435,68 +3922,68 @@ py_guestfs_blockdev_setbsz (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_blockdev_getsz (PyObject *self, PyObject *args) +py_guestfs_drop_caches (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int64_t r; - const char *device; + int r; + int whattodrop; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsz", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_drop_caches", + &py_g, &whattodrop)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getsz (g, device); + r = guestfs_drop_caches (g, whattodrop); 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_dmesg (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int64_t r; - const char *device; + char *r; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_blockdev_getsize64", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_dmesg", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_getsize64 (g, device); - if (r == -1) { + r = guestfs_dmesg (g); + if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; } - py_r = PyLong_FromLongLong (r); + py_r = PyString_FromString (r); + free (r); return py_r; } static PyObject * -py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args) +py_guestfs_ping_daemon (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_flushbufs", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "O:guestfs_ping_daemon", + &py_g)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_flushbufs (g, device); + r = guestfs_ping_daemon (g); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2508,98 +3995,96 @@ py_guestfs_blockdev_flushbufs (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_blockdev_rereadpt (PyObject *self, PyObject *args) +py_guestfs_equal (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_rereadpt", - &py_g, &device)) + const char *file1; + const char *file2; + + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_equal", + &py_g, &file1, &file2)) return NULL; g = get_handle (py_g); - r = guestfs_blockdev_rereadpt (g, device); + r = guestfs_equal (g, file1, file2); 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_upload (PyObject *self, PyObject *args) +py_guestfs_strings (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *filename; - const char *remotefilename; + char **r; + const char *path; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_upload", - &py_g, &filename, &remotefilename)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_strings", + &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_upload (g, filename, remotefilename); - if (r == -1) { + r = guestfs_strings (g, path); + 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_download (PyObject *self, PyObject *args) +py_guestfs_strings_e (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *remotefilename; - const char *filename; + char **r; + const char *encoding; + const char *path; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_download", - &py_g, &remotefilename, &filename)) + if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_strings_e", + &py_g, &encoding, &path)) return NULL; g = get_handle (py_g); - r = guestfs_download (g, remotefilename, filename); - if (r == -1) { + r = guestfs_strings_e (g, encoding, path); + 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_checksum (PyObject *self, PyObject *args) +py_guestfs_hexdump (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; char *r; - const char *csumtype; const char *path; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_checksum", - &py_g, &csumtype, &path)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_hexdump", + &py_g, &path)) return NULL; g = get_handle (py_g); - r = guestfs_checksum (g, csumtype, path); + r = guestfs_hexdump (g, path); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2611,21 +4096,20 @@ py_guestfs_checksum (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_tar_in (PyObject *self, PyObject *args) +py_guestfs_zerofree (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *tarfile; - const char *directory; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_in", - &py_g, &tarfile, &directory)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zerofree", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_tar_in (g, tarfile, directory); + r = guestfs_zerofree (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2637,21 +4121,20 @@ py_guestfs_tar_in (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_tar_out (PyObject *self, PyObject *args) +py_guestfs_pvresize (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *directory; - const char *tarfile; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tar_out", - &py_g, &directory, &tarfile)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_pvresize", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_tar_out (g, directory, tarfile); + r = guestfs_pvresize (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2663,21 +4146,25 @@ py_guestfs_tar_out (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_tgz_in (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 *tarball; - const char *directory; + const char *device; + int n; + int cyls; + int heads; + int sectors; + const char *line; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_in", - &py_g, &tarball, &directory)) + 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_tgz_in (g, tarball, directory); + r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2689,102 +4176,95 @@ py_guestfs_tgz_in (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_tgz_out (PyObject *self, PyObject *args) +py_guestfs_sfdisk_l (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *directory; - const char *tarball; + char *r; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_tgz_out", - &py_g, &directory, &tarball)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_l", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_tgz_out (g, directory, tarball); - if (r == -1) { + r = guestfs_sfdisk_l (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_mount_ro (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; - const char *mountpoint; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mount_ro", - &py_g, &device, &mountpoint)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_kernel_geometry", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_mount_ro (g, device, mountpoint); - if (r == -1) { + r = guestfs_sfdisk_kernel_geometry (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_mount_options (PyObject *self, PyObject *args) +py_guestfs_sfdisk_disk_geometry (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *options; + char *r; const char *device; - const char *mountpoint; - if (!PyArg_ParseTuple (args, (char *) "Osss:guestfs_mount_options", - &py_g, &options, &device, &mountpoint)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sfdisk_disk_geometry", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_mount_options (g, options, device, mountpoint); - if (r == -1) { + r = guestfs_sfdisk_disk_geometry (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_mount_vfs (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 *options; - const char *vfstype; - const char *device; - const char *mountpoint; + int activate; - if (!PyArg_ParseTuple (args, (char *) "Ossss:guestfs_mount_vfs", - &py_g, &options, &vfstype, &device, &mountpoint)) + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_vg_activate_all", + &py_g, &activate)) return NULL; g = get_handle (py_g); - r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint); + r = guestfs_vg_activate_all (g, activate); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2796,50 +4276,51 @@ py_guestfs_mount_vfs (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_debug (PyObject *self, PyObject *args) +py_guestfs_vg_activate (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *subcmd; - PyObject *py_extraargs; - const char **extraargs; + int r; + int activate; + PyObject *py_volgroups; + const char **volgroups; - if (!PyArg_ParseTuple (args, (char *) "OsO:guestfs_debug", - &py_g, &subcmd, &py_extraargs)) + if (!PyArg_ParseTuple (args, (char *) "OiO:guestfs_vg_activate", + &py_g, &activate, &py_volgroups)) return NULL; g = get_handle (py_g); - extraargs = get_string_list (py_extraargs); - if (!extraargs) return NULL; + volgroups = get_string_list (py_volgroups); + if (!volgroups) return NULL; - r = guestfs_debug (g, subcmd, extraargs); - free (extraargs); - if (r == NULL) { + r = guestfs_vg_activate (g, activate, volgroups); + free (volgroups); + 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_lvremove (PyObject *self, PyObject *args) +py_guestfs_lvresize (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; const char *device; + int mbytes; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_lvremove", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Osi:guestfs_lvresize", + &py_g, &device, &mbytes)) return NULL; g = get_handle (py_g); - r = guestfs_lvremove (g, device); + r = guestfs_lvresize (g, device, mbytes); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2851,20 +4332,20 @@ py_guestfs_lvremove (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_vgremove (PyObject *self, PyObject *args) +py_guestfs_resize2fs (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *vgname; + const char *device; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_vgremove", - &py_g, &vgname)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_resize2fs", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_vgremove (g, vgname); + r = guestfs_resize2fs (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2876,46 +4357,45 @@ py_guestfs_vgremove (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_pvremove (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_pvremove", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_find", + &py_g, &directory)) return NULL; g = get_handle (py_g); - r = guestfs_pvremove (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_set_e2label (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 *device; - const char *label; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2label", - &py_g, &device, &label)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_e2fsck_f", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_set_e2label (g, device, label); + r = guestfs_e2fsck_f (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -2927,71 +4407,70 @@ py_guestfs_set_e2label (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_get_e2label (PyObject *self, PyObject *args) +py_guestfs_sleep (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - char *r; - const char *device; + int r; + int secs; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2label", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Oi:guestfs_sleep", + &py_g, &secs)) return NULL; g = get_handle (py_g); - r = guestfs_get_e2label (g, device); - if (r == NULL) { + r = guestfs_sleep (g, secs); + 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_set_e2uuid (PyObject *self, PyObject *args) +py_guestfs_ntfs_3g_probe (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; + int rw; const char *device; - const char *uuid; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_set_e2uuid", - &py_g, &device, &uuid)) + if (!PyArg_ParseTuple (args, (char *) "Ois:guestfs_ntfs_3g_probe", + &py_g, &rw, &device)) return NULL; g = get_handle (py_g); - r = guestfs_set_e2uuid (g, device, uuid); + r = guestfs_ntfs_3g_probe (g, rw, 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_get_e2uuid (PyObject *self, PyObject *args) +py_guestfs_sh (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; char *r; - const char *device; + const char *command; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_get_e2uuid", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sh", + &py_g, &command)) return NULL; g = get_handle (py_g); - r = guestfs_get_e2uuid (g, device); + r = guestfs_sh (g, command); if (r == NULL) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -3003,71 +4482,70 @@ py_guestfs_get_e2uuid (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_fsck (PyObject *self, PyObject *args) +py_guestfs_sh_lines (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *fstype; - const char *device; + char **r; + const char *command; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_fsck", - &py_g, &fstype, &device)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_sh_lines", + &py_g, &command)) return NULL; g = get_handle (py_g); - r = guestfs_fsck (g, fstype, device); - if (r == -1) { + r = guestfs_sh_lines (g, command); + 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_zero (PyObject *self, PyObject *args) +py_guestfs_glob_expand (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *device; + char **r; + const char *pattern; - if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_zero", - &py_g, &device)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_glob_expand", + &py_g, &pattern)) return NULL; g = get_handle (py_g); - r = guestfs_zero (g, device); - if (r == -1) { + r = guestfs_glob_expand (g, pattern); + 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_grub_install (PyObject *self, PyObject *args) +py_guestfs_scrub_device (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *root; const char *device; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_grub_install", - &py_g, &root, &device)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_device", + &py_g, &device)) return NULL; g = get_handle (py_g); - r = guestfs_grub_install (g, root, device); + r = guestfs_scrub_device (g, device); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -3079,21 +4557,20 @@ py_guestfs_grub_install (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_cp (PyObject *self, PyObject *args) +py_guestfs_scrub_file (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *src; - const char *dest; + const char *file; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp", - &py_g, &src, &dest)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_file", + &py_g, &file)) return NULL; g = get_handle (py_g); - r = guestfs_cp (g, src, dest); + r = guestfs_scrub_file (g, file); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -3105,21 +4582,20 @@ py_guestfs_cp (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_cp_a (PyObject *self, PyObject *args) +py_guestfs_scrub_freespace (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; int r; - const char *src; - const char *dest; + const char *dir; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_cp_a", - &py_g, &src, &dest)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_scrub_freespace", + &py_g, &dir)) return NULL; g = get_handle (py_g); - r = guestfs_cp_a (g, src, dest); + r = guestfs_scrub_freespace (g, dir); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g)); return NULL; @@ -3131,44 +4607,73 @@ py_guestfs_cp_a (PyObject *self, PyObject *args) } static PyObject * -py_guestfs_mv (PyObject *self, PyObject *args) +py_guestfs_mkdtemp (PyObject *self, PyObject *args) { PyObject *py_g; guestfs_h *g; PyObject *py_r; - int r; - const char *src; - const char *dest; + char *r; + const char *template; - if (!PyArg_ParseTuple (args, (char *) "Oss:guestfs_mv", - &py_g, &src, &dest)) + if (!PyArg_ParseTuple (args, (char *) "Os:guestfs_mkdtemp", + &py_g, &template)) return NULL; g = get_handle (py_g); - r = guestfs_mv (g, src, dest); - if (r == -1) { + r = guestfs_mkdtemp (g, template); + 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 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 }, @@ -3180,6 +4685,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 }, @@ -3269,6 +4775,34 @@ static PyMethodDef methods[] = { { (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 }, + { (char *) "sh", py_guestfs_sh, METH_VARARGS, NULL }, + { (char *) "sh_lines", py_guestfs_sh_lines, METH_VARARGS, NULL }, + { (char *) "glob_expand", py_guestfs_glob_expand, METH_VARARGS, NULL }, + { (char *) "scrub_device", py_guestfs_scrub_device, METH_VARARGS, NULL }, + { (char *) "scrub_file", py_guestfs_scrub_file, METH_VARARGS, NULL }, + { (char *) "scrub_freespace", py_guestfs_scrub_freespace, METH_VARARGS, NULL }, + { (char *) "mkdtemp", py_guestfs_mkdtemp, METH_VARARGS, NULL }, { NULL, NULL, 0, NULL } };