/*

 * libvirt-gobject-domain.c: libvirt glib integration

 *

 * Copyright (C) 2008 Daniel P. Berrange

 * Copyright (C) 2010-2011 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see

 * <http://www.gnu.org/licenses/>.

 *

 * Author: Daniel P. Berrange <berrange@redhat.com>

 */

#include <config.h>

#include <glib.h>

#include <libvirt/virterror.h>

#include <string.h>

#if !defined(HAVE_VIR_DOMAIN_OPEN_GRAPHICS_FD) && !defined(G_OS_WIN32)

#include <sys/socket.h>

#endif

#include "libvirt-glib/libvirt-glib.h"

#include "libvirt-gobject/libvirt-gobject.h"

#include "libvirt-gobject-compat.h"

#include "libvirt-gobject/libvirt-gobject-domain-device-private.h"

#define GVIR_DOMAIN_GET_PRIVATE(obj)                         \

        (G_TYPE_INSTANCE_GET_PRIVATE((obj), GVIR_TYPE_DOMAIN, GVirDomainPrivate))

struct _GVirDomainPrivate

{

    virDomainPtr handle;

    gchar uuid[VIR_UUID_STRING_BUFLEN];

    GHashTable *snapshots;

    GMutex *lock;

};

G_DEFINE_TYPE_WITH_PRIVATE(GVirDomain, gvir_domain, G_TYPE_OBJECT);

enum {

    PROP_0,

    PROP_HANDLE,

    PROP_PERSISTENT,

};

enum {

    VIR_STARTED,

    VIR_SUSPENDED,

    VIR_RESUMED,

    VIR_STOPPED,

    VIR_UPDATED,

    VIR_PMSUSPENDED,

    LAST_SIGNAL

};

typedef struct {

    guint create_flags;

    GVirConfigDomainSnapshot *snapshot_config;

} SnapshotCreateData;

static void snapshot_create_data_free (SnapshotCreateData *data) {

    g_clear_object (&data->snapshot_config);

    g_slice_free (SnapshotCreateData, data);

}

static gint signals[LAST_SIGNAL];

#define GVIR_DOMAIN_ERROR gvir_domain_error_quark()

static GQuark

gvir_domain_error_quark(void)

{

    return g_quark_from_static_string("gvir-domain");

}

static void gvir_domain_get_property(GObject *object,

                                     guint prop_id,

                                     GValue *value,

                                     GParamSpec *pspec)

{

    GVirDomain *domain = GVIR_DOMAIN(object);

    GVirDomainPrivate *priv = domain->priv;

    switch (prop_id) {

    case PROP_HANDLE:

        g_value_set_boxed(value, priv->handle);

        break;

    case PROP_PERSISTENT:

        g_value_set_boolean(value, gvir_domain_get_persistent (domain));

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

    }

}

static void gvir_domain_set_property(GObject *object,

                                     guint prop_id,

                                     const GValue *value,

                                     GParamSpec *pspec)

{

    GVirDomain *domain = GVIR_DOMAIN(object);

    GVirDomainPrivate *priv = domain->priv;

    switch (prop_id) {

    case PROP_HANDLE:

        if (priv->handle)

            virDomainFree(priv->handle);

        priv->handle = g_value_dup_boxed(value);

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

    }

}

static void gvir_domain_finalize(GObject *object)

{

    GVirDomain *domain = GVIR_DOMAIN(object);

    GVirDomainPrivate *priv = domain->priv;

    if (priv->snapshots) {

        g_hash_table_unref(priv->snapshots);

    }

    g_mutex_free(priv->lock);

    virDomainFree(priv->handle);

    G_OBJECT_CLASS(gvir_domain_parent_class)->finalize(object);

}

static void gvir_domain_constructed(GObject *object)

{

    GVirDomain *domain = GVIR_DOMAIN(object);

    GVirDomainPrivate *priv = domain->priv;

    G_OBJECT_CLASS(gvir_domain_parent_class)->constructed(object);

    /* xxx we may want to turn this into an initable */

    if (virDomainGetUUIDString(priv->handle, priv->uuid) < 0)

        gvir_warning("Failed to get domain UUID on %p", priv->handle);

}

static void gvir_domain_class_init(GVirDomainClass *klass)

{

    GObjectClass *object_class = G_OBJECT_CLASS (klass);

    object_class->finalize = gvir_domain_finalize;

    object_class->get_property = gvir_domain_get_property;

    object_class->set_property = gvir_domain_set_property;

    object_class->constructed = gvir_domain_constructed;

    g_object_class_install_property(object_class,

                                    PROP_HANDLE,

                                    g_param_spec_boxed("handle",

                                                       "Handle",

                                                       "The domain handle",

                                                       GVIR_TYPE_DOMAIN_HANDLE,

                                                       G_PARAM_READABLE |

                                                       G_PARAM_WRITABLE |

                                                       G_PARAM_CONSTRUCT_ONLY |

                                                       G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(object_class,

                                    PROP_PERSISTENT,

                                    g_param_spec_boolean("persistent",

                                                         "Persistent",

                                                         "If domain is persistent",

                                                         TRUE,

                                                         G_PARAM_READABLE |

                                                         G_PARAM_STATIC_STRINGS));

    signals[VIR_STARTED] = g_signal_new("started",

                                        G_OBJECT_CLASS_TYPE(object_class),

                                        G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE |

                                        G_SIGNAL_NO_HOOKS | G_SIGNAL_DETAILED,

                                        G_STRUCT_OFFSET(GVirDomainClass, started),

                                        NULL, NULL,

                                        g_cclosure_marshal_VOID__VOID,

                                        G_TYPE_NONE,

                                        0);

    signals[VIR_SUSPENDED] = g_signal_new("suspended",

                                        G_OBJECT_CLASS_TYPE(object_class),

                                        G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE |

                                        G_SIGNAL_NO_HOOKS | G_SIGNAL_DETAILED,

                                        G_STRUCT_OFFSET(GVirDomainClass, suspended),

                                        NULL, NULL,

                                        g_cclosure_marshal_VOID__VOID,

                                        G_TYPE_NONE,

                                        0);

    signals[VIR_RESUMED] = g_signal_new("resumed",

                                        G_OBJECT_CLASS_TYPE(object_class),

                                        G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE |

                                        G_SIGNAL_NO_HOOKS | G_SIGNAL_DETAILED,

                                        G_STRUCT_OFFSET(GVirDomainClass, resumed),

                                        NULL, NULL,

                                        g_cclosure_marshal_VOID__VOID,

                                        G_TYPE_NONE,

                                        0);

    signals[VIR_STOPPED] = g_signal_new("stopped",

                                        G_OBJECT_CLASS_TYPE(object_class),

                                        G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE |

                                        G_SIGNAL_NO_HOOKS | G_SIGNAL_DETAILED,

                                        G_STRUCT_OFFSET(GVirDomainClass, stopped),

                                        NULL, NULL,

                                        g_cclosure_marshal_VOID__VOID,

                                        G_TYPE_NONE,

                                        0);

    signals[VIR_UPDATED] = g_signal_new("updated",

                                        G_OBJECT_CLASS_TYPE(object_class),

                                        G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE | G_SIGNAL_NO_HOOKS,

                                        G_STRUCT_OFFSET(GVirDomainClass, updated),

                                        NULL, NULL,

                                        g_cclosure_marshal_VOID__VOID,

                                        G_TYPE_NONE,

                                        0);

    signals[VIR_PMSUSPENDED] = g_signal_new("pmsuspended",

                                        G_OBJECT_CLASS_TYPE(object_class),

                                        G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE |

                                        G_SIGNAL_NO_HOOKS | G_SIGNAL_DETAILED,

                                        G_STRUCT_OFFSET(GVirDomainClass, pmsuspended),

                                        NULL, NULL,

                                        g_cclosure_marshal_VOID__VOID,

                                        G_TYPE_NONE,

                                        0);

}

static void gvir_domain_init(GVirDomain *domain)

{

    domain->priv = GVIR_DOMAIN_GET_PRIVATE(domain);

    domain->priv->lock = g_mutex_new();

}

typedef struct virDomain GVirDomainHandle;

static GVirDomainHandle*

gvir_domain_handle_copy(GVirDomainHandle *src)

{

    virDomainRef((virDomainPtr)src);

    return src;

}

static void

gvir_domain_handle_free(GVirDomainHandle *src)

{

    virDomainFree((virDomainPtr)src);

}

G_DEFINE_BOXED_TYPE(GVirDomainHandle, gvir_domain_handle,

                    gvir_domain_handle_copy, gvir_domain_handle_free)

static GVirDomainInfo *

gvir_domain_info_copy(GVirDomainInfo *info)

{

    return g_slice_dup(GVirDomainInfo, info);

}

static void

gvir_domain_info_free(GVirDomainInfo *info)

{

    g_slice_free(GVirDomainInfo, info);

}

G_DEFINE_BOXED_TYPE(GVirDomainInfo, gvir_domain_info,

                    gvir_domain_info_copy, gvir_domain_info_free)

const gchar *gvir_domain_get_name(GVirDomain *dom)

{

    GVirDomainPrivate *priv;

    const char *name;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), NULL);

    priv = dom->priv;

    if (!(name = virDomainGetName(priv->handle))) {

        gvir_warning("Failed to get domain name on %p", priv->handle);

        return NULL;

    }

    return name;

}

const gchar *gvir_domain_get_uuid(GVirDomain *dom)

{

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), NULL);

    return dom->priv->uuid;

}

gint gvir_domain_get_id(GVirDomain *dom,

                        GError **err)

{

    GVirDomainPrivate *priv;

    gint ret;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), -1);

    g_return_val_if_fail(err == NULL || *err == NULL, -1);

    priv = dom->priv;

    if ((ret = virDomainGetID(priv->handle)) < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to get ID for domain");

    }

    return ret;

}

/**

 * gvir_domain_start:

 * @dom: the domain

 * @flags:  the flags

 */

gboolean gvir_domain_start(GVirDomain *dom,

                           guint flags,

                           GError **err)

{

    GVirDomainPrivate *priv;

    int ret;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    priv = dom->priv;

    if (flags)

        ret = virDomainCreateWithFlags(priv->handle, flags);

    else

        ret = virDomainCreate(priv->handle);

    if (ret < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to start domain");

        return FALSE;

    }

    return TRUE;

}

static void

gvir_domain_start_helper(GTask *task,

                         gpointer source_object,

                         gpointer task_data,

                         GCancellable *cancellable G_GNUC_UNUSED)

{

    GVirDomain *dom = GVIR_DOMAIN(source_object);

    guint flags = GPOINTER_TO_UINT(task_data);

    GError *err = NULL;

    if (!gvir_domain_start(dom, flags, &err))

        g_task_return_error(task, err);

    else

        g_task_return_boolean(task, TRUE);

}

/**

 * gvir_domain_start_async:

 * @dom: the domain

 * @flags:  the flags

 * @cancellable: (allow-none)(transfer none): cancellation object

 * @callback: (scope async): completion callback

 * @user_data: (closure): opaque data for callback

 *

 * Asynchronous variant of #gvir_domain_start.

 */

void gvir_domain_start_async(GVirDomain *dom,

                             guint flags,

                             GCancellable *cancellable,

                             GAsyncReadyCallback callback,

                             gpointer user_data)

{

    GTask *task;

    g_return_if_fail(GVIR_IS_DOMAIN(dom));

    g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));

    task = g_task_new(G_OBJECT(dom),

                      cancellable,

                      callback,

                      user_data);

    g_task_set_task_data(task, GUINT_TO_POINTER(flags), NULL);

    g_task_run_in_thread(task, gvir_domain_start_helper);

    g_object_unref(task);

}

gboolean gvir_domain_start_finish(GVirDomain *dom,

                                  GAsyncResult *result,

                                  GError **err)

{

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    return g_task_propagate_boolean(G_TASK(result), err);

}

/**

 * gvir_domain_resume:

 * @dom: the domain

 * @err: Place-holder for possible errors

 *

 * Returns: TRUE on success

 */

gboolean gvir_domain_resume(GVirDomain *dom,

                            GError **err)

{

    GVirDomainPrivate *priv;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    priv = dom->priv;

    if (virDomainResume(priv->handle) < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to resume domain");

        return FALSE;

    }

    return TRUE;

}

static void

gvir_domain_resume_helper(GTask *task,

                          gpointer source_object,

                          gpointer task_data G_GNUC_UNUSED,

                          GCancellable *cancellable G_GNUC_UNUSED)

{

    GVirDomain *dom = GVIR_DOMAIN(source_object);

    GError *err = NULL;

    if (!gvir_domain_resume(dom, &err))

        g_task_return_error(task, err);

    else

        g_task_return_boolean(task, TRUE);

}

/**

 * gvir_domain_resume_async:

 * @dom: the domain to resume

 * @cancellable: (allow-none)(transfer none): cancellation object

 * @callback: (scope async): completion callback

 * @user_data: (closure): opaque data for callback

 *

 * Asynchronous variant of #gvir_domain_resume.

 */

void gvir_domain_resume_async(GVirDomain *dom,

                              GCancellable *cancellable,

                              GAsyncReadyCallback callback,

                              gpointer user_data)

{

    GTask *task;

    g_return_if_fail(GVIR_IS_DOMAIN(dom));

    g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));

    task = g_task_new(G_OBJECT(dom),

                      cancellable,

                      callback,

                      user_data);

    g_task_run_in_thread(task, gvir_domain_resume_helper);

    g_object_unref(task);

}

gboolean gvir_domain_resume_finish(GVirDomain *dom,

                                   GAsyncResult *result,

                                   GError **err)

{

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    return g_task_propagate_boolean(G_TASK(result), err);

}

/**

 * gvir_domain_wakeup:

 * @dom: the domain

 * @flags: placeholder for flags, pass 0

 * @err: Place-holder for possible errors

 *

 * Returns: TRUE on success

 */

gboolean gvir_domain_wakeup(GVirDomain *dom,

                            guint flags,

                            GError **err)

{

    GVirDomainPrivate *priv;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    priv = dom->priv;

    if (virDomainPMWakeup(priv->handle, flags) < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to wakeup domain");

        return FALSE;

    }

    return TRUE;

}

static void

gvir_domain_wakeup_helper(GTask *task,

                          gpointer source_object,

                          gpointer task_data,

                          GCancellable *cancellable G_GNUC_UNUSED)

{

    GVirDomain *dom = GVIR_DOMAIN(source_object);

    guint flags = GPOINTER_TO_UINT(task_data);

    GError *err = NULL;

    if (!gvir_domain_wakeup(dom, flags, &err))

        g_task_return_error(task, err);

    else

        g_task_return_boolean(task, TRUE);

}

/**

 * gvir_domain_wakeup_async:

 * @dom: the domain to wakeup

 * @flags: placeholder for flags, pass 0

 * @cancellable: (allow-none)(transfer none): cancellation object

 * @callback: (scope async): completion callback

 * @user_data: (closure): opaque data for callback

 *

 * Asynchronous variant of #gvir_domain_wakeup.

 */

void gvir_domain_wakeup_async(GVirDomain *dom,

                              guint flags,

                              GCancellable *cancellable,

                              GAsyncReadyCallback callback,

                              gpointer user_data)

{

    GTask *task;

    g_return_if_fail(GVIR_IS_DOMAIN(dom));

    g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));

    task = g_task_new(G_OBJECT(dom),

                      cancellable,

                      callback,

                      user_data);

    g_task_set_task_data(task, GUINT_TO_POINTER(flags), NULL);

    g_task_run_in_thread(task, gvir_domain_wakeup_helper);

    g_object_unref(task);

}

gboolean gvir_domain_wakeup_finish(GVirDomain *dom,

                                   GAsyncResult *result,

                                   GError **err)

{

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    return g_task_propagate_boolean(G_TASK(result), err);

}

/**

 * gvir_domain_stop:

 * @dom: the domain

 * @flags:  the flags

 */

gboolean gvir_domain_stop(GVirDomain *dom,

                          guint flags,

                          GError **err)

{

    GVirDomainPrivate *priv;

    int ret;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    priv = dom->priv;

    if (flags)

        ret = virDomainDestroyFlags(priv->handle, flags);

    else

        ret = virDomainDestroy(priv->handle);

    if (ret < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to stop domain");

        return FALSE;

    }

    return TRUE;

}

/**

 * gvir_domain_delete:

 * @dom: the domain

 * @flags:  the flags

 */

gboolean gvir_domain_delete(GVirDomain *dom,

                            guint flags,

                            GError **err)

{

    GVirDomainPrivate *priv;

    int ret;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    priv = dom->priv;

    if (flags)

        ret = virDomainUndefineFlags(priv->handle, flags);

    else

        ret = virDomainUndefine(priv->handle);

    if (ret < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to delete domain");

        return FALSE;

    }

    return TRUE;

}

/**

 * gvir_domain_shutdown:

 * @dom: the domain

 * @flags:  the %GVirDomainShutdownFlags flags

 */

gboolean gvir_domain_shutdown(GVirDomain *dom,

                              guint flags,

                              GError **err)

{

    GVirDomainPrivate *priv;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    priv = dom->priv;

    if (virDomainShutdownFlags(priv->handle, flags) < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to shutdown domain");

        return FALSE;

    }

    return TRUE;

}

/**

 * gvir_domain_reboot:

 * @dom: the domain

 * @flags: the %GVirDomainRebootFlags flags

 */

gboolean gvir_domain_reboot(GVirDomain *dom,

                            guint flags,

                            GError **err)

{

    GVirDomainPrivate *priv;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    priv = dom->priv;

    if (virDomainReboot(priv->handle, flags) < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to reboot domain");

        return FALSE;

    }

    return TRUE;

}

/**

 * gvir_domain_save_to_file:

 * @dom: the domain

 * @filename: path to the output file

 * @custom_conf: (allow-none): configuration for domain or NULL

 * @flags: the flags

 *

 * Returns: TRUE on success, FALSE otherwise

 */

gboolean gvir_domain_save_to_file(GVirDomain *dom,

                                  gchar *filename,

                                  GVirConfigDomain *custom_conf,

                                  guint flags,

                                  GError **err)

{

    GVirDomainPrivate *priv;

    int ret;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(filename != NULL, FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    priv = dom->priv;

    if (flags || custom_conf != NULL) {

        gchar *custom_xml = NULL;

        if (custom_conf != NULL)

            custom_xml = gvir_config_object_to_xml(GVIR_CONFIG_OBJECT(custom_conf));

        ret = virDomainSaveFlags(priv->handle, filename, custom_xml, flags);

        g_free(custom_xml);

    }

    else {

        ret = virDomainSave(priv->handle, filename);

    }

    if (ret < 0) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to save domain to file");

        return FALSE;

    }

    return TRUE;

}

typedef struct {

    gchar *filename;

    GVirConfigDomain *custom_conf;

    guint flags;

} DomainSaveToFileData;

static void domain_save_to_file_data_free(DomainSaveToFileData *data)

{

    g_free(data->filename);

    g_clear_object(&data->custom_conf);

    g_slice_free(DomainSaveToFileData, data);

}

static void

gvir_domain_save_to_file_helper(GTask *task,

                                gpointer source_object,

                                gpointer task_data,

                                GCancellable *cancellable G_GNUC_UNUSED)

{

    GVirDomain *dom = GVIR_DOMAIN(source_object);

    DomainSaveToFileData *data = (DomainSaveToFileData *) task_data;

    GError *err = NULL;

    if (!gvir_domain_save_to_file(dom, data->filename, data->custom_conf, data->flags, &err))

        g_task_return_error(task, err);

    else

        g_task_return_boolean(task, TRUE);

}

/**

 * gvir_domain_save_to_file_async:

 * @dom: the domain

 * @filename: path to output file

 * @custom_conf: (allow-none): configuration for domain or NULL

 * @flags: the flags

 * @cancellable: (allow-none) (transfer none): cancallation object

 * @callback: (scope async): completion callback

 * @user_data: (closure): opaque data for callback

 *

 * Asynchronous variant of #gvir_domain_save_to_file

 */

void gvir_domain_save_to_file_async(GVirDomain *dom,

                                    gchar *filename,

                                    GVirConfigDomain *custom_conf,

                                    guint flags,

                                    GCancellable *cancellable,

                                    GAsyncReadyCallback callback,

                                    gpointer user_data)

{

    GTask *task;

    DomainSaveToFileData *data;

    g_return_if_fail(GVIR_IS_DOMAIN(dom));

    g_return_if_fail(filename != NULL);

    g_return_if_fail((cancellable == NULL) || G_IS_CANCELLABLE(cancellable));

    data = g_slice_new0(DomainSaveToFileData);

    data->filename = g_strdup(filename);

    if (custom_conf != NULL)

        data->custom_conf = g_object_ref(custom_conf);

    data->flags = flags;

    task = g_task_new(G_OBJECT(dom),

                      cancellable,

                      callback,

                      user_data);

    g_task_set_task_data(task,

                         data,

                         (GDestroyNotify) domain_save_to_file_data_free);

    g_task_run_in_thread(task, gvir_domain_save_to_file_helper);

    g_object_unref(task);

}

/**

 * gvir_domain_save_to_file_finish:

 * @dom: the domain to save

 * @result: (transfer none): async method result

 * @err: Place-holder for possible errors

 *

 * Finishes the operation started by #gvir_domain_save_to_file_async.

 *

 * Returns: TRUE if domain was saved successfully, FALSE otherwise.

 */

gboolean gvir_domain_save_to_file_finish(GVirDomain *dom,

                                         GAsyncResult *result,

                                         GError **err)

{

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), FALSE);

    g_return_val_if_fail(g_task_is_valid(result, dom), FALSE);

    g_return_val_if_fail(err == NULL || *err == NULL, FALSE);

    return g_task_propagate_boolean(G_TASK(result), err);

}

/**

 * gvir_domain_get_config:

 * @dom: the domain

 * @flags: the %GVirDomainXMLFlags flags

 *

 * Returns: (transfer full): the config. The returned object should be

 * unreffed with g_object_unref() when no longer needed.

 */

GVirConfigDomain *gvir_domain_get_config(GVirDomain *dom,

                                         guint flags,

                                         GError **err)

{

    GVirDomainPrivate *priv;

    gchar *xml;

    g_return_val_if_fail(GVIR_IS_DOMAIN(dom), NULL);

    g_return_val_if_fail(err == NULL || *err == NULL, NULL);

    priv = dom->priv;

    if (!(xml = virDomainGetXMLDesc(priv->handle, flags))) {

        gvir_set_error_literal(err, GVIR_DOMAIN_ERROR,

                               0,

                               "Unable to get domain XML config");

        return NULL;

    }

    GVirConfigDomain *conf = gvir_config_domain_new_from_xml(xml, err);

    g_free(xml);

    if ((err != NULL) && (*err != NULL))

        return NULL;

    return conf;

}

/**

 * gvir_domain_set_config:

 * @domain: the domain

 * @conf: the new configuration for the domain

 * @err: (allow-none): Place-holder for error or NULL

 *

 * Resets configuration of an existing domain.

 *