/* SPDX-License-Identifier: LGPL-2.1+ */
/*
 * Copyright (C) 2007 - 2008 Novell, Inc.
 * Copyright (C) 2007 - 2011 Red Hat, Inc.
 */

#include "nm-default.h"

#include "nm-remote-connection.h"

#include "nm-glib-aux/nm-dbus-aux.h"
#include "nm-dbus-interface.h"
#include "nm-utils.h"
#include "nm-setting-connection.h"
#include "nm-core-internal.h"
#include "nm-remote-connection-private.h"
#include "nm-object-private.h"
#include "nm-dbus-helpers.h"

/**
 * SECTION:nm-remote-connection
 * @short_description: A connection managed by NetworkManager server
 *
 * A #NMRemoteConnection represents a connection that is exported via
 * NetworkManager D-Bus interface.
 **/

/*****************************************************************************/

NM_GOBJECT_PROPERTIES_DEFINE(NMRemoteConnection,
                             PROP_UNSAVED,
                             PROP_FLAGS,
                             PROP_FILENAME,
                             PROP_VISIBLE, );

typedef struct {
    GCancellable *get_settings_cancellable;

    char *  filename;
    guint32 flags;
    bool    unsaved;

    bool visible : 1;
    bool is_initialized : 1;
} NMRemoteConnectionPrivate;

struct _NMRemoteConnection {
    NMObject                  parent;
    NMRemoteConnectionPrivate _priv;
};

struct _NMRemoteConnectionClass {
    NMObjectClass parent_class;
};

static void nm_remote_connection_connection_iface_init(NMConnectionInterface *iface);

G_DEFINE_TYPE_WITH_CODE(NMRemoteConnection,
                        nm_remote_connection,
                        NM_TYPE_OBJECT,
                        G_IMPLEMENT_INTERFACE(NM_TYPE_CONNECTION,
                                              nm_remote_connection_connection_iface_init);)

#define NM_REMOTE_CONNECTION_GET_PRIVATE(self) \
    _NM_GET_PRIVATE(self, NMRemoteConnection, NM_IS_REMOTE_CONNECTION, NMObject)

/*****************************************************************************/

/**
 * nm_remote_connection_update2:
 * @connection: the #NMRemoteConnection
 * @settings: (allow-none): optional connection to update the settings.
 * @flags: update-flags
 * @args: (allow-none): optional arguments.
 * @cancellable: a #GCancellable, or %NULL
 * @callback: callback to be called when the commit operation completes
 * @user_data: caller-specific data passed to @callback
 *
 * Asynchronously calls the Update2() D-Bus method.
 *
 * Since: 1.12
 **/
void
nm_remote_connection_update2(NMRemoteConnection *   connection,
                             GVariant *             settings,
                             NMSettingsUpdate2Flags flags,
                             GVariant *             args,
                             GCancellable *         cancellable,
                             GAsyncReadyCallback    callback,
                             gpointer               user_data)
{
    g_return_if_fail(NM_IS_REMOTE_CONNECTION(connection));
    g_return_if_fail(!settings || g_variant_is_of_type(settings, NM_VARIANT_TYPE_CONNECTION));
    g_return_if_fail(!args || g_variant_is_of_type(args, G_VARIANT_TYPE("a{sv}")));
    g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));

    if (!settings)
        settings = g_variant_new_array(G_VARIANT_TYPE("{sa{sv}}"), NULL, 0);
    if (!args)
        args = g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0);

    _nm_client_dbus_call(_nm_object_get_client(connection),
                         connection,
                         nm_remote_connection_update2,
                         cancellable,
                         callback,
                         user_data,
                         _nm_object_get_path(connection),
                         NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
                         "Update2",
                         g_variant_new("(@a{sa{sv}}u@a{sv})", settings, (guint32) flags, args),
                         G_VARIANT_TYPE("(a{sv})"),
                         G_DBUS_CALL_FLAGS_NONE,
                         NM_DBUS_DEFAULT_TIMEOUT_MSEC,
                         nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
}

/**
 * nm_remote_connection_update2_finish:
 * @connection: the #NMRemoteConnection
 * @result: the result passed to the #GAsyncReadyCallback
 * @error: location for a #GError, or %NULL
 *
 * Gets the result of a call to nm_remote_connection_commit_changes_async().
 *
 * Returns: (transfer full): on success, a #GVariant of type "a{sv}" with the result. On failure,
 *   %NULL.
 **/
GVariant *
nm_remote_connection_update2_finish(NMRemoteConnection *connection,
                                    GAsyncResult *      result,
                                    GError **           error)
{
    gs_unref_variant GVariant *ret = NULL;
    GVariant *                 v_result;

    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), NULL);
    g_return_val_if_fail(nm_g_task_is_valid(result, connection, nm_remote_connection_update2),
                         NULL);

    ret = g_task_propagate_pointer(G_TASK(result), error);
    if (!ret)
        return NULL;

    g_variant_get(ret, "(@a{sv})", &v_result);

    return v_result;
}

/*****************************************************************************/

/**
 * nm_remote_connection_commit_changes:
 * @connection: the #NMRemoteConnection
 * @save_to_disk: whether to persist the changes to disk
 * @cancellable: a #GCancellable, or %NULL
 * @error: location for a #GError, or %NULL
 *
 * Send any local changes to the settings and properties of @connection to
 * NetworkManager. If @save_to_disk is %TRUE, the updated connection will be saved to
 * disk; if %FALSE, then only the in-memory representation will be changed.
 *
 * Returns: %TRUE on success, %FALSE on error, in which case @error will be set.
 *
 * Deprecated: 1.22: Use nm_remote_connection_commit_changes_async() or GDBusConnection.
 **/
gboolean
nm_remote_connection_commit_changes(NMRemoteConnection *connection,
                                    gboolean            save_to_disk,
                                    GCancellable *      cancellable,
                                    GError **           error)
{
    gs_unref_variant GVariant *ret = NULL;

    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), FALSE);
    g_return_val_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable), FALSE);

    ret = _nm_client_dbus_call_sync(
        _nm_object_get_client(connection),
        cancellable,
        _nm_object_get_path(connection),
        NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
        "Update2",
        g_variant_new("(@a{sa{sv}}u@a{sv})",
                      nm_connection_to_dbus(NM_CONNECTION(connection), NM_CONNECTION_SERIALIZE_ALL),
                      (guint32)(save_to_disk ? NM_SETTINGS_UPDATE2_FLAG_TO_DISK
                                             : NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY),
                      g_variant_new_array(G_VARIANT_TYPE("{sv}"), NULL, 0)),
        G_VARIANT_TYPE("(a{sv})"),
        G_DBUS_CALL_FLAGS_NONE,
        NM_DBUS_DEFAULT_TIMEOUT_MSEC,
        TRUE,
        error);
    if (!ret)
        return FALSE;

    return TRUE;
}

/**
 * nm_remote_connection_commit_changes_async:
 * @connection: the #NMRemoteConnection
 * @save_to_disk: whether to save the changes to persistent storage
 * @cancellable: a #GCancellable, or %NULL
 * @callback: callback to be called when the commit operation completes
 * @user_data: caller-specific data passed to @callback
 *
 * Asynchronously sends any local changes to the settings and properties of
 * @connection to NetworkManager. If @save is %TRUE, the updated connection will
 * be saved to disk; if %FALSE, then only the in-memory representation will be
 * changed.
 **/
void
nm_remote_connection_commit_changes_async(NMRemoteConnection *connection,
                                          gboolean            save_to_disk,
                                          GCancellable *      cancellable,
                                          GAsyncReadyCallback callback,
                                          gpointer            user_data)
{
    g_return_if_fail(NM_IS_REMOTE_CONNECTION(connection));
    g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));

    nm_remote_connection_update2(
        connection,
        nm_connection_to_dbus(NM_CONNECTION(connection), NM_CONNECTION_SERIALIZE_ALL),
        save_to_disk ? NM_SETTINGS_UPDATE2_FLAG_TO_DISK : NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY,
        NULL,
        cancellable,
        callback,
        user_data);
}

/**
 * nm_remote_connection_commit_changes_finish:
 * @connection: the #NMRemoteConnection
 * @result: the result passed to the #GAsyncReadyCallback
 * @error: location for a #GError, or %NULL
 *
 * Gets the result of a call to nm_remote_connection_commit_changes_async().
 *
 * Returns: %TRUE on success, %FALSE on error, in which case @error will be set.
 **/
gboolean
nm_remote_connection_commit_changes_finish(NMRemoteConnection *connection,
                                           GAsyncResult *      result,
                                           GError **           error)
{
    gs_unref_variant GVariant *v_result = NULL;

    v_result = nm_remote_connection_update2_finish(connection, result, error);
    return !!v_result;
}

/*****************************************************************************/

/**
 * nm_remote_connection_save:
 * @connection: the #NMRemoteConnection
 * @cancellable: a #GCancellable, or %NULL
 * @error: location for a #GError, or %NULL
 *
 * Saves the connection to disk if the connection has changes that have not yet
 * been written to disk, or if the connection has never been saved.
 *
 * Returns: %TRUE on success, %FALSE on error, in which case @error will be set.
 *
 * Deprecated: 1.22: Use nm_remote_connection_save_async() or GDBusConnection.
 **/
gboolean
nm_remote_connection_save(NMRemoteConnection *connection, GCancellable *cancellable, GError **error)
{
    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), FALSE);
    g_return_val_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable), FALSE);

    return _nm_client_dbus_call_sync_void(_nm_object_get_client(connection),
                                          cancellable,
                                          _nm_object_get_path(connection),
                                          NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
                                          "Save",
                                          g_variant_new("()"),
                                          G_DBUS_CALL_FLAGS_NONE,
                                          NM_DBUS_DEFAULT_TIMEOUT_MSEC,
                                          TRUE,
                                          error);
}

/**
 * nm_remote_connection_save_async:
 * @connection: the #NMRemoteConnection
 * @cancellable: a #GCancellable, or %NULL
 * @callback: callback to be called when the save operation completes
 * @user_data: caller-specific data passed to @callback
 *
 * Saves the connection to disk if the connection has changes that have not yet
 * been written to disk, or if the connection has never been saved.
 **/
void
nm_remote_connection_save_async(NMRemoteConnection *connection,
                                GCancellable *      cancellable,
                                GAsyncReadyCallback callback,
                                gpointer            user_data)
{
    g_return_if_fail(NM_IS_REMOTE_CONNECTION(connection));
    g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));

    _nm_client_dbus_call(_nm_object_get_client(connection),
                         connection,
                         nm_remote_connection_save_async,
                         cancellable,
                         callback,
                         user_data,
                         _nm_object_get_path(connection),
                         NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
                         "Save",
                         g_variant_new("()"),
                         G_VARIANT_TYPE("()"),
                         G_DBUS_CALL_FLAGS_NONE,
                         NM_DBUS_DEFAULT_TIMEOUT_MSEC,
                         nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
}

/**
 * nm_remote_connection_save_finish:
 * @connection: the #NMRemoteConnection
 * @result: the result passed to the #GAsyncReadyCallback
 * @error: location for a #GError, or %NULL
 *
 * Gets the result of a call to nm_remote_connection_save_async().
 *
 * Returns: %TRUE on success, %FALSE on error, in which case @error will be set.
 **/
gboolean
nm_remote_connection_save_finish(NMRemoteConnection *connection,
                                 GAsyncResult *      result,
                                 GError **           error)
{
    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), FALSE);
    g_return_val_if_fail(nm_g_task_is_valid(result, connection, nm_remote_connection_save_async),
                         FALSE);

    return g_task_propagate_boolean(G_TASK(result), error);
}

/*****************************************************************************/

/**
 * nm_remote_connection_delete:
 * @connection: the #NMRemoteConnection
 * @cancellable: a #GCancellable, or %NULL
 * @error: location for a #GError, or %NULL
 *
 * Deletes the connection.
 *
 * Returns: %TRUE on success, %FALSE on error, in which case @error will be set.
 *
 * Deprecated: 1.22: Use nm_remote_connection_delete_async() or GDBusConnection.
 **/
gboolean
nm_remote_connection_delete(NMRemoteConnection *connection,
                            GCancellable *      cancellable,
                            GError **           error)
{
    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), FALSE);

    return _nm_client_dbus_call_sync_void(_nm_object_get_client(connection),
                                          cancellable,
                                          _nm_object_get_path(connection),
                                          NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
                                          "Delete",
                                          g_variant_new("()"),
                                          G_DBUS_CALL_FLAGS_NONE,
                                          NM_DBUS_DEFAULT_TIMEOUT_MSEC,
                                          TRUE,
                                          error);
}

/**
 * nm_remote_connection_delete_async:
 * @connection: the #NMRemoteConnection
 * @cancellable: a #GCancellable, or %NULL
 * @callback: callback to be called when the delete operation completes
 * @user_data: caller-specific data passed to @callback
 *
 * Asynchronously deletes the connection.
 **/
void
nm_remote_connection_delete_async(NMRemoteConnection *connection,
                                  GCancellable *      cancellable,
                                  GAsyncReadyCallback callback,
                                  gpointer            user_data)
{
    g_return_if_fail(NM_IS_REMOTE_CONNECTION(connection));
    g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));

    _nm_client_dbus_call(_nm_object_get_client(connection),
                         connection,
                         nm_remote_connection_delete_async,
                         cancellable,
                         callback,
                         user_data,
                         _nm_object_get_path(connection),
                         NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
                         "Delete",
                         g_variant_new("()"),
                         G_VARIANT_TYPE("()"),
                         G_DBUS_CALL_FLAGS_NONE,
                         NM_DBUS_DEFAULT_TIMEOUT_MSEC,
                         nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
}

/**
 * nm_remote_connection_delete_finish:
 * @connection: the #NMRemoteConnection
 * @result: the result passed to the #GAsyncReadyCallback
 * @error: location for a #GError, or %NULL
 *
 * Gets the result of a call to nm_remote_connection_delete_async().
 *
 * Returns: %TRUE on success, %FALSE on error, in which case @error will be set.
 **/
gboolean
nm_remote_connection_delete_finish(NMRemoteConnection *connection,
                                   GAsyncResult *      result,
                                   GError **           error)
{
    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), FALSE);
    g_return_val_if_fail(nm_g_task_is_valid(result, connection, nm_remote_connection_delete_async),
                         FALSE);

    return g_task_propagate_boolean(G_TASK(result), error);
}

/**
 * nm_remote_connection_get_secrets:
 * @connection: the #NMRemoteConnection
 * @setting_name: the #NMSetting object name to get secrets for
 * @cancellable: a #GCancellable, or %NULL
 * @error: location for a #GError, or %NULL
 *
 * Request the connection's secrets. Note that this is a blocking D-Bus call,
 * not a simple property accessor.
 *
 * Returns: (transfer full): a #GVariant of type %NM_VARIANT_TYPE_CONNECTION containing
 * @connection's secrets, or %NULL on error.
 *
 * Deprecated: 1.22: Use nm_remote_connection_get_secrets_async() or GDBusConnection.
 **/
GVariant *
nm_remote_connection_get_secrets(NMRemoteConnection *connection,
                                 const char *        setting_name,
                                 GCancellable *      cancellable,
                                 GError **           error)
{
    gs_unref_variant GVariant *ret = NULL;
    GVariant *                 secrets;

    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), NULL);
    g_return_val_if_fail(setting_name, NULL);
    g_return_val_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable), NULL);

    ret = _nm_client_dbus_call_sync(_nm_object_get_client(connection),
                                    cancellable,
                                    _nm_object_get_path(connection),
                                    NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
                                    "GetSecrets",
                                    g_variant_new("(s)", setting_name),
                                    G_VARIANT_TYPE("(a{sa{sv}})"),
                                    G_DBUS_CALL_FLAGS_NONE,
                                    NM_DBUS_DEFAULT_TIMEOUT_MSEC,
                                    TRUE,
                                    error);
    if (!ret)
        return NULL;

    g_variant_get(ret, "(@a{sa{sv}})", &secrets);

    return secrets;
}

/**
 * nm_remote_connection_get_secrets_async:
 * @connection: the #NMRemoteConnection
 * @setting_name: the #NMSetting object name to get secrets for
 * @cancellable: a #GCancellable, or %NULL
 * @callback: callback to be called when the secret request completes
 * @user_data: caller-specific data passed to @callback
 *
 * Asynchronously requests the connection's secrets.
 **/
void
nm_remote_connection_get_secrets_async(NMRemoteConnection *connection,
                                       const char *        setting_name,
                                       GCancellable *      cancellable,
                                       GAsyncReadyCallback callback,
                                       gpointer            user_data)
{
    g_return_if_fail(NM_IS_REMOTE_CONNECTION(connection));
    g_return_if_fail(setting_name);
    g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));

    _nm_client_dbus_call(_nm_object_get_client(connection),
                         connection,
                         nm_remote_connection_get_secrets_async,
                         cancellable,
                         callback,
                         user_data,
                         _nm_object_get_path(connection),
                         NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
                         "GetSecrets",
                         g_variant_new("(s)", setting_name),
                         G_VARIANT_TYPE("(a{sa{sv}})"),
                         G_DBUS_CALL_FLAGS_NONE,
                         NM_DBUS_DEFAULT_TIMEOUT_MSEC,
                         nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
}

/**
 * nm_remote_connection_get_secrets_finish:
 * @connection: the #NMRemoteConnection
 * @result: the result passed to the #GAsyncReadyCallback
 * @error: location for a #GError, or %NULL
 *
 * Gets the result of a call to nm_remote_connection_get_secrets_async().
 *
 * Returns: (transfer full): a #GVariant of type %NM_VARIANT_TYPE_CONNECTION
 *   containing @connection's secrets, or %NULL on error.
 **/
GVariant *
nm_remote_connection_get_secrets_finish(NMRemoteConnection *connection,
                                        GAsyncResult *      result,
                                        GError **           error)
{
    gs_unref_variant GVariant *ret = NULL;
    GVariant *                 secrets;

    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), NULL);
    g_return_val_if_fail(
        nm_g_task_is_valid(result, connection, nm_remote_connection_get_secrets_async),
        FALSE);

    ret = g_task_propagate_pointer(G_TASK(result), error);
    if (!ret)
        return NULL;

    g_variant_get(ret, "(@a{sa{sv}})", &secrets);

    return secrets;
}

/**
 * nm_remote_connection_get_unsaved:
 * @connection: the #NMRemoteConnection
 *
 * Returns: %TRUE if the remote connection contains changes that have not
 * been saved to disk, %FALSE if the connection is the same as its on-disk
 * representation.
 **/
gboolean
nm_remote_connection_get_unsaved(NMRemoteConnection *connection)
{
    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), FALSE);

    return NM_REMOTE_CONNECTION_GET_PRIVATE(connection)->unsaved;
}

/**
 * nm_remote_connection_get_flags:
 * @connection: the #NMRemoteConnection
 *
 * Returns: the flags of the connection of type #NMSettingsConnectionFlags.
 *
 * Since: 1.12
 **/
NMSettingsConnectionFlags
nm_remote_connection_get_flags(NMRemoteConnection *connection)
{
    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), FALSE);

    return (NMSettingsConnectionFlags) NM_REMOTE_CONNECTION_GET_PRIVATE(connection)->flags;
}

/**
 * nm_remote_connection_get_filename:
 * @connection: the #NMRemoteConnection
 *
 * Returns: file that stores the connection in case the connection is file-backed.
 *
 * Since: 1.12
 **/
const char *
nm_remote_connection_get_filename(NMRemoteConnection *connection)
{
    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), NULL);

    return NM_REMOTE_CONNECTION_GET_PRIVATE(connection)->filename;
}

/**
 * nm_remote_connection_get_visible:
 * @connection: the #NMRemoteConnection
 *
 * Checks if the connection is visible to the current user.  If the
 * connection is not visible then it is essentially useless; it will
 * not contain any settings, and operations such as
 * nm_remote_connection_save() and nm_remote_connection_delete() will
 * always fail. (#NMRemoteSettings will not normally return
 * non-visible connections to callers, but it is possible for a
 * connection's visibility to change after you already have a
 * reference to it.)
 *
 * Returns: %TRUE if the remote connection is visible to the current
 * user, %FALSE if not.
 **/
gboolean
nm_remote_connection_get_visible(NMRemoteConnection *connection)
{
    g_return_val_if_fail(NM_IS_REMOTE_CONNECTION(connection), FALSE);

    return NM_REMOTE_CONNECTION_GET_PRIVATE(connection)->visible;
}

/*****************************************************************************/

GCancellable *
_nm_remote_settings_get_settings_prepare(NMRemoteConnection *self)
{
    NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE(self);

    nm_clear_g_cancellable(&priv->get_settings_cancellable);
    priv->get_settings_cancellable = g_cancellable_new();
    return priv->get_settings_cancellable;
}

void
_nm_remote_settings_get_settings_commit(NMRemoteConnection *self, GVariant *settings)
{
    NMRemoteConnectionPrivate *priv    = NM_REMOTE_CONNECTION_GET_PRIVATE(self);
    GError *                   error   = NULL;
    gboolean                   visible = FALSE;
    gboolean                   changed = FALSE;

    g_clear_object(&priv->get_settings_cancellable);

    if (!priv->is_initialized) {
        changed              = TRUE;
        priv->is_initialized = TRUE;
    }

    if (settings) {
        if (!_nm_connection_replace_settings((NMConnection *) self,
                                             settings,
                                             NM_SETTING_PARSE_FLAGS_BEST_EFFORT,
                                             &error)) {
            NML_NMCLIENT_LOG_E(_nm_object_get_client(self),
                               "[%s] failure to update settings: %s",
                               _nm_object_get_path(self),
                               error->message);
            g_clear_error(&error);
        } else
            visible = TRUE;
    } else
        nm_connection_clear_settings(NM_CONNECTION(self));

    if (priv->visible != visible) {
        priv->visible = visible;
        _nm_client_queue_notify_object(_nm_object_get_client(self),
                                       self,
                                       obj_properties[PROP_VISIBLE]);
        changed = TRUE;
    }

    if (changed)
        _nm_client_notify_object_changed(_nm_object_get_client(self), _nm_object_get_dbobj(self));
}

/*****************************************************************************/

static gboolean
is_ready(NMObject *nmobj)
{
    NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE(nmobj);

    if (!priv->is_initialized)
        return FALSE;

    return NM_OBJECT_CLASS(nm_remote_connection_parent_class)->is_ready(nmobj);
}

/*****************************************************************************/

static void
register_client(NMObject *nmobj, NMClient *client, NMLDBusObject *dbobj)
{
    NM_OBJECT_CLASS(nm_remote_connection_parent_class)->register_client(nmobj, client, dbobj);
    nm_connection_set_path(NM_CONNECTION(nmobj), dbobj->dbus_path->str);
    _nm_client_get_settings_call(client, dbobj);
}

static void
unregister_client(NMObject *nmobj, NMClient *client, NMLDBusObject *dbobj)
{
    nm_clear_g_cancellable(&NM_REMOTE_CONNECTION_GET_PRIVATE(nmobj)->get_settings_cancellable);
    NM_OBJECT_CLASS(nm_remote_connection_parent_class)->unregister_client(nmobj, client, dbobj);
}

/*****************************************************************************/

static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
    switch (prop_id) {
    case PROP_UNSAVED:
        g_value_set_boolean(value, NM_REMOTE_CONNECTION_GET_PRIVATE(object)->unsaved);
        break;
    case PROP_FLAGS:
        g_value_set_uint(value, NM_REMOTE_CONNECTION_GET_PRIVATE(object)->flags);
        break;
    case PROP_FILENAME:
        g_value_set_string(value, NM_REMOTE_CONNECTION_GET_PRIVATE(object)->filename);
        break;
    case PROP_VISIBLE:
        g_value_set_boolean(value, NM_REMOTE_CONNECTION_GET_PRIVATE(object)->visible);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

/*****************************************************************************/

static void
nm_remote_connection_init(NMRemoteConnection *self)
{}

static void
dispose(GObject *object)
{
    NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE(object);

    nm_clear_g_free(&priv->filename);

    G_OBJECT_CLASS(nm_remote_connection_parent_class)->dispose(object);
}

const NMLDBusMetaIface _nml_dbus_meta_iface_nm_settings_connection = NML_DBUS_META_IFACE_INIT_PROP(
    NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
    nm_remote_connection_get_type,
    NML_DBUS_META_INTERFACE_PRIO_INSTANTIATE_HIGH,
    NML_DBUS_META_IFACE_DBUS_PROPERTIES(
        NML_DBUS_META_PROPERTY_INIT_S("Filename",
                                      PROP_FILENAME,
                                      NMRemoteConnection,
                                      _priv.filename),
        NML_DBUS_META_PROPERTY_INIT_U("Flags", PROP_FLAGS, NMRemoteConnection, _priv.flags),
        NML_DBUS_META_PROPERTY_INIT_B("Unsaved",
                                      PROP_UNSAVED,
                                      NMRemoteConnection,
                                      _priv.unsaved), ), );

static void
nm_remote_connection_class_init(NMRemoteConnectionClass *klass)
{
    GObjectClass * object_class    = G_OBJECT_CLASS(klass);
    NMObjectClass *nm_object_class = NM_OBJECT_CLASS(klass);

    object_class->get_property = get_property;
    object_class->dispose      = dispose;

    nm_object_class->is_ready          = is_ready;
    nm_object_class->register_client   = register_client;
    nm_object_class->unregister_client = unregister_client;

    /**
     * NMRemoteConnection:unsaved:
     *
     * %TRUE if the remote connection contains changes that have not been saved
     * to disk, %FALSE if the connection is the same as its on-disk representation.
     **/
    obj_properties[PROP_UNSAVED] = g_param_spec_boolean(NM_REMOTE_CONNECTION_UNSAVED,
                                                        "",
                                                        "",
                                                        FALSE,
                                                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    /**
     * NMRemoteConnection:flags:
     *
     * The flags of the connection as unsigned integer. The values
     * correspond to the #NMSettingsConnectionFlags enum.
     *
     * Since: 1.12
     **/
    obj_properties[PROP_FLAGS] = g_param_spec_uint(NM_REMOTE_CONNECTION_FLAGS,
                                                   "",
                                                   "",
                                                   0,
                                                   G_MAXUINT32,
                                                   0,
                                                   G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    /**
     * NMRemoteConnection:filename:
     *
     * File that stores the connection in case the connection is
     * file-backed.
     *
     * Since: 1.12
     **/
    obj_properties[PROP_FILENAME] = g_param_spec_string(NM_REMOTE_CONNECTION_FILENAME,
                                                        "",
                                                        "",
                                                        NULL,
                                                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    /**
     * NMRemoteConnection:visible:
     *
     * %TRUE if the remote connection is visible to the current user, %FALSE if
     * not.  If the connection is not visible then it is essentially useless; it
     * will not contain any settings, and operations such as
     * nm_remote_connection_save() and nm_remote_connection_delete() will always
     * fail. (#NMRemoteSettings will not normally return non-visible connections
     * to callers, but it is possible for a connection's visibility to change
     * after you already have a reference to it.)
     **/
    obj_properties[PROP_VISIBLE] = g_param_spec_boolean(NM_REMOTE_CONNECTION_VISIBLE,
                                                        "",
                                                        "",
                                                        FALSE,
                                                        G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    _nml_dbus_meta_class_init_with_properties(object_class,
                                              &_nml_dbus_meta_iface_nm_settings_connection);
}

static void
nm_remote_connection_connection_iface_init(NMConnectionInterface *iface)
{}