/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
 * Copyright (C) 2010 - 2011 Red Hat, Inc.
 */

#include "libnm-client-impl/nm-default-libnm.h"

#include "nm-secret-agent-old.h"

#include "c-list/src/c-list.h"
#include "libnm-core-intern/nm-core-internal.h"
#include "nm-dbus-helpers.h"
#include "nm-dbus-interface.h"
#include "nm-enum-types.h"
#include "libnm-glib-aux/nm-c-list.h"
#include "libnm-glib-aux/nm-dbus-aux.h"
#include "libnm-glib-aux/nm-time-utils.h"
#include "nm-simple-connection.h"

#define REGISTER_RETRY_TIMEOUT_MSEC 3000
#define _CALL_REGISTER_TIMEOUT_MSEC 15000

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

typedef struct {
    char *                 connection_path;
    char *                 setting_name;
    GDBusMethodInvocation *context;
    CList                  gsi_lst;
    bool                   is_cancelling : 1;
} GetSecretsInfo;

NM_GOBJECT_PROPERTIES_DEFINE(NMSecretAgentOld,
                             PROP_IDENTIFIER,
                             PROP_AUTO_REGISTER,
                             PROP_REGISTERED,
                             PROP_CAPABILITIES,
                             PROP_DBUS_CONNECTION, );

typedef struct {
    GDBusConnection *dbus_connection;
    GMainContext *   main_context;
    GMainContext *   dbus_context;
    GObject *        context_busy_watcher;
    GCancellable *   name_owner_cancellable;
    GCancellable *   registering_cancellable;
    GSource *        registering_retry_source;

    NMLInitData *init_data;

    CList gsi_lst_head;

    CList pending_tasks_register_lst_head;

    char *identifier;

    NMRefString *name_owner_curr;
    NMRefString *name_owner_next;

    gint64 registering_timeout_msec;

    guint name_owner_changed_id;

    guint exported_id;

    guint capabilities;

    guint8 registering_try_count;

    guint8 register_state_change_reenter : 2;

    bool session_bus : 1;

    bool auto_register : 1;

    bool is_registered : 1;

    bool is_enabled : 1;

    bool registration_force_unregister : 1;

    /* This is true, if we either are in the process of RegisterWithCapabilities() or
     * are already successfully registered.
     *
     * This is only TRUE, if the name owner was authenticated to run as root user.
     *
     * It also means, we should follow up with an Unregister() call during shutdown. */
    bool registered_against_server : 1;

    bool is_initialized : 1;
    bool is_destroyed : 1;
} NMSecretAgentOldPrivate;

static void nm_secret_agent_old_initable_iface_init(GInitableIface *iface);
static void nm_secret_agent_old_async_initable_iface_init(GAsyncInitableIface *iface);

G_DEFINE_ABSTRACT_TYPE_WITH_CODE(
    NMSecretAgentOld,
    nm_secret_agent_old,
    G_TYPE_OBJECT,
    G_IMPLEMENT_INTERFACE(G_TYPE_INITABLE, nm_secret_agent_old_initable_iface_init);
    G_IMPLEMENT_INTERFACE(G_TYPE_ASYNC_INITABLE, nm_secret_agent_old_async_initable_iface_init);)

#define NM_SECRET_AGENT_OLD_GET_PRIVATE(self) \
    (G_TYPE_INSTANCE_GET_PRIVATE((self), NM_TYPE_SECRET_AGENT_OLD, NMSecretAgentOldPrivate))

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

#define _NMLOG(level, ...)                                 \
    NML_DBUS_LOG((level),                                  \
                 "secret-agent[" NM_HASH_OBFUSCATE_PTR_FMT \
                 "]: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__), \
                 NM_HASH_OBFUSCATE_PTR(self) _NM_UTILS_MACRO_REST(__VA_ARGS__))

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

static const GDBusInterfaceInfo interface_info = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT(
    NM_DBUS_INTERFACE_SECRET_AGENT,
    .methods = NM_DEFINE_GDBUS_METHOD_INFOS(
        NM_DEFINE_GDBUS_METHOD_INFO("GetSecrets",
                                    .in_args = NM_DEFINE_GDBUS_ARG_INFOS(
                                        NM_DEFINE_GDBUS_ARG_INFO("connection", "a{sa{sv}}"),
                                        NM_DEFINE_GDBUS_ARG_INFO("connection_path", "o"),
                                        NM_DEFINE_GDBUS_ARG_INFO("setting_name", "s"),
                                        NM_DEFINE_GDBUS_ARG_INFO("hints", "as"),
                                        NM_DEFINE_GDBUS_ARG_INFO("flags", "u"), ),
                                    .out_args = NM_DEFINE_GDBUS_ARG_INFOS(
                                        NM_DEFINE_GDBUS_ARG_INFO("secrets", "a{sa{sv}}"), ), ),
        NM_DEFINE_GDBUS_METHOD_INFO("CancelGetSecrets",
                                    .in_args = NM_DEFINE_GDBUS_ARG_INFOS(
                                        NM_DEFINE_GDBUS_ARG_INFO("connection_path", "o"),
                                        NM_DEFINE_GDBUS_ARG_INFO("setting_name", "s"), ), ),
        NM_DEFINE_GDBUS_METHOD_INFO("SaveSecrets",
                                    .in_args = NM_DEFINE_GDBUS_ARG_INFOS(
                                        NM_DEFINE_GDBUS_ARG_INFO("connection", "a{sa{sv}}"),
                                        NM_DEFINE_GDBUS_ARG_INFO("connection_path", "o"), ), ),
        NM_DEFINE_GDBUS_METHOD_INFO(
            "DeleteSecrets",
            .in_args = NM_DEFINE_GDBUS_ARG_INFOS(
                NM_DEFINE_GDBUS_ARG_INFO("connection", "a{sa{sv}}"),
                NM_DEFINE_GDBUS_ARG_INFO("connection_path", "o"), ), ), ), );

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

static void _register_state_change(NMSecretAgentOld *self);

static void _register_dbus_call(NMSecretAgentOld *self);

static void _init_complete(NMSecretAgentOld *self, GError *error_take);

static void _register_state_complete(NMSecretAgentOld *self);

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

/**
 * nm_secret_agent_old_get_dbus_connection:
 * @self: the #NMSecretAgentOld instance
 *
 * Returns: (transfer none): the #GDBusConnection used by the secret agent.
 *   You may either set this as construct property %NM_SECRET_AGENT_OLD_DBUS_CONNECTION,
 *   or it will automatically set during initialization.
 *
 * Since: 1.24
 */
GDBusConnection *
nm_secret_agent_old_get_dbus_connection(NMSecretAgentOld *self)
{
    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), NULL);

    return NM_SECRET_AGENT_OLD_GET_PRIVATE(self)->dbus_connection;
}

/**
 * nm_secret_agent_old_get_main_context:
 * @self: the #NMSecretAgentOld instance
 *
 * Returns: (transfer none): the #GMainContext instance associate with the
 *   instance. This is the g_main_context_get_thread_default() at the time
 *   when creating the instance.
 *
 * Since: 1.24
 */
GMainContext *
nm_secret_agent_old_get_main_context(NMSecretAgentOld *self)
{
    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), NULL);

    return NM_SECRET_AGENT_OLD_GET_PRIVATE(self)->main_context;
}

/**
 * nm_secret_agent_old_get_context_busy_watcher:
 * @self: the #NMSecretAgentOld instance
 *
 * Returns a #GObject that stays alive as long as there are pending
 * requests in the #GDBusConnection. Such requests keep the #GMainContext
 * alive, and thus you may want to keep iterating the context as long
 * until a weak reference indicates that this object is gone. This is
 * useful because even when you destroy the instance right away (and all
 * the internally pending requests get cancelled), any pending g_dbus_connection_call()
 * requests will still invoke the result on the #GMainContext. Hence, this
 * allows you to know how long you must iterate the context to know
 * that all remains are cleaned up.
 *
 * Returns: (transfer none): a #GObject that you may register a weak pointer
 *   to know that the #GMainContext is still kept busy by @self.
 *
 * Since: 1.24
 */
GObject *
nm_secret_agent_old_get_context_busy_watcher(NMSecretAgentOld *self)
{
    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), NULL);

    return NM_SECRET_AGENT_OLD_GET_PRIVATE(self)->context_busy_watcher;
}

/**
 * nm_secret_agent_old_get_dbus_name_owner:
 * @self: the #NMSecretAgentOld instance
 *
 * Returns: the current D-Bus name owner. While this property
 *   is set while registering, it really only makes sense when
 *   the nm_secret_agent_old_get_registered() indicates that
 *   registration is successful.
 *
 * Since: 1.24
 */
const char *
nm_secret_agent_old_get_dbus_name_owner(NMSecretAgentOld *self)
{
    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), NULL);

    return nm_ref_string_get_str(NM_SECRET_AGENT_OLD_GET_PRIVATE(self)->name_owner_curr);
}

/**
 * nm_secret_agent_old_get_registered:
 * @self: a #NMSecretAgentOld
 *
 * Note that the secret agent transparently registers and re-registers
 * as the D-Bus name owner appears. Hence, this property is not really
 * useful. Also, to be graceful against races during registration, the
 * instance will already accept requests while being in the process of
 * registering.
 * If you need to avoid races and want to wait until @self is registered,
 * call nm_secret_agent_old_register_async(). If that function completes
 * with success, you know the instance is registered.
 *
 * Returns: a %TRUE if the agent is registered, %FALSE if it is not.
 **/
gboolean
nm_secret_agent_old_get_registered(NMSecretAgentOld *self)
{
    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), FALSE);

    return NM_SECRET_AGENT_OLD_GET_PRIVATE(self)->is_registered;
}

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

static void
get_secret_info_free(GetSecretsInfo *info)
{
    nm_assert(info);
    nm_assert(!info->context);

    c_list_unlink_stale(&info->gsi_lst);
    g_free(info->connection_path);
    g_free(info->setting_name);
    nm_g_slice_free(info);
}

static void
get_secret_info_complete_and_free(GetSecretsInfo *info, GVariant *secrets, GError *error)
{
    if (error) {
        if (secrets)
            nm_g_variant_unref_floating(secrets);
        g_dbus_method_invocation_return_gerror(g_steal_pointer(&info->context), error);
    } else {
        g_dbus_method_invocation_return_value(g_steal_pointer(&info->context),
                                              g_variant_new("(@a{sa{sv}})", secrets));
    }
    get_secret_info_free(info);
}

static void
get_secret_info_complete_and_free_error(GetSecretsInfo *info,
                                        GQuark          error_domain,
                                        int             error_code,
                                        const char *    error_message)
{
    g_dbus_method_invocation_return_error_literal(g_steal_pointer(&info->context),
                                                  error_domain,
                                                  error_code,
                                                  error_message);
    get_secret_info_free(info);
}

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

static void
_dbus_connection_call_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    gs_unref_object GObject *context_busy_watcher = NULL;
    GAsyncReadyCallback      callback;
    gpointer                 callback_user_data;

    nm_utils_user_data_unpack(user_data, &context_busy_watcher, &callback, &callback_user_data);
    callback(source, result, callback_user_data);
}

static void
_dbus_connection_call(NMSecretAgentOld *  self,
                      const char *        bus_name,
                      const char *        object_path,
                      const char *        interface_name,
                      const char *        method_name,
                      GVariant *          parameters,
                      const GVariantType *reply_type,
                      GDBusCallFlags      flags,
                      int                 timeout_msec,
                      GCancellable *      cancellable,
                      GAsyncReadyCallback callback,
                      gpointer            user_data)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    nm_assert(nm_g_main_context_is_thread_default(priv->dbus_context));

    g_dbus_connection_call(
        priv->dbus_connection,
        bus_name,
        object_path,
        interface_name,
        method_name,
        parameters,
        reply_type,
        flags,
        timeout_msec,
        cancellable,
        callback ? _dbus_connection_call_cb : NULL,
        callback
            ? nm_utils_user_data_pack(g_object_ref(priv->context_busy_watcher), callback, user_data)
            : NULL);
}

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

static GetSecretsInfo *
find_get_secrets_info(NMSecretAgentOldPrivate *priv,
                      const char *             connection_path,
                      const char *             setting_name)
{
    GetSecretsInfo *info;

    c_list_for_each_entry (info, &priv->gsi_lst_head, gsi_lst) {
        if (nm_streq(connection_path, info->connection_path)
            && nm_streq(setting_name, info->setting_name))
            return info;
    }
    return NULL;
}

static void
_cancel_get_secret_request(NMSecretAgentOld *self, GetSecretsInfo *info, const char *message)
{
    c_list_unlink(&info->gsi_lst);
    info->is_cancelling = TRUE;

    _LOGT("cancel get-secrets request \"%s\", \"%s\": %s",
          info->connection_path,
          info->setting_name,
          message);

    NM_SECRET_AGENT_OLD_GET_CLASS(self)->cancel_get_secrets(self,
                                                            info->connection_path,
                                                            info->setting_name);

    get_secret_info_complete_and_free_error(info,
                                            NM_SECRET_AGENT_ERROR,
                                            NM_SECRET_AGENT_ERROR_AGENT_CANCELED,
                                            message);
}

static gboolean
verify_request(NMSecretAgentOld *     self,
               GDBusMethodInvocation *context,
               GVariant *             connection_dict,
               const char *           connection_path,
               NMConnection **        out_connection,
               GError **              error)
{
    gs_unref_object NMConnection *connection = NULL;
    gs_free_error GError *local              = NULL;

    if (!nm_dbus_path_not_empty(connection_path)) {
        g_set_error_literal(error,
                            NM_SECRET_AGENT_ERROR,
                            NM_SECRET_AGENT_ERROR_INVALID_CONNECTION,
                            "Invalid connection: no connection path given.");
        return FALSE;
    }

    connection = _nm_simple_connection_new_from_dbus(connection_dict,
                                                     NM_SETTING_PARSE_FLAGS_BEST_EFFORT,
                                                     &local);
    if (!connection) {
        g_set_error(error,
                    NM_SECRET_AGENT_ERROR,
                    NM_SECRET_AGENT_ERROR_INVALID_CONNECTION,
                    "Invalid connection: %s",
                    local->message);
        return FALSE;
    }

    nm_connection_set_path(connection, connection_path);
    NM_SET_OUT(out_connection, g_steal_pointer(&connection));
    return TRUE;
}

static void
get_secrets_cb(NMSecretAgentOld *self,
               NMConnection *    connection,
               GVariant *        secrets,
               GError *          error,
               gpointer          user_data)
{
    GetSecretsInfo *info = user_data;

    if (info->is_cancelling) {
        if (secrets)
            nm_g_variant_unref_floating(secrets);
        return;
    }

    _LOGT("request: get-secrets request \"%s\", \"%s\" complete with %s%s%s",
          info->connection_path,
          info->setting_name,
          NM_PRINT_FMT_QUOTED(error, "error: ", error->message, "", "success"));

    get_secret_info_complete_and_free(info, secrets, error);
}

static void
impl_get_secrets(NMSecretAgentOld *self, GVariant *parameters, GDBusMethodInvocation *context)
{
    NMSecretAgentOldPrivate *priv            = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    GError *                 error           = NULL;
    gs_unref_object NMConnection *connection = NULL;
    GetSecretsInfo *              info;
    gs_unref_variant GVariant *arg_connection = NULL;
    const char *               arg_connection_path;
    const char *               arg_setting_name;
    gs_free const char **      arg_hints = NULL;
    guint32                    arg_flags;

    g_variant_get(parameters,
                  "(@a{sa{sv}}&o&s^a&su)",
                  &arg_connection,
                  &arg_connection_path,
                  &arg_setting_name,
                  &arg_hints,
                  &arg_flags);

    if (!verify_request(self, context, arg_connection, arg_connection_path, &connection, &error)) {
        g_dbus_method_invocation_take_error(context, error);
        return;
    }

    _LOGT("request: get-secrets(\"%s\", \"%s\")", arg_connection_path, arg_setting_name);

    info = find_get_secrets_info(priv, arg_connection_path, arg_setting_name);
    if (info)
        _cancel_get_secret_request(self, info, "Request aborted due to new request");

    info  = g_slice_new(GetSecretsInfo);
    *info = (GetSecretsInfo){
        .context         = context,
        .connection_path = g_strdup(arg_connection_path),
        .setting_name    = g_strdup(arg_setting_name),
    };
    c_list_link_tail(&priv->gsi_lst_head, &info->gsi_lst);

    NM_SECRET_AGENT_OLD_GET_CLASS(self)->get_secrets(self,
                                                     connection,
                                                     info->connection_path,
                                                     info->setting_name,
                                                     arg_hints,
                                                     arg_flags,
                                                     get_secrets_cb,
                                                     info);
}

static void
impl_cancel_get_secrets(NMSecretAgentOld *     self,
                        GVariant *             parameters,
                        GDBusMethodInvocation *context)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    GetSecretsInfo *         info;
    const char *             arg_connection_path;
    const char *             arg_setting_name;

    g_variant_get(parameters, "(&o&s)", &arg_connection_path, &arg_setting_name);

    info = find_get_secrets_info(priv, arg_connection_path, arg_setting_name);
    if (!info) {
        g_dbus_method_invocation_return_error_literal(
            context,
            NM_SECRET_AGENT_ERROR,
            NM_SECRET_AGENT_ERROR_FAILED,
            "No secrets request in progress for this connection.");
        return;
    }

    _cancel_get_secret_request(self, info, "Request cancelled by NetworkManager");

    g_dbus_method_invocation_return_value(context, NULL);
}

static void
save_secrets_cb(NMSecretAgentOld *self, NMConnection *connection, GError *error, gpointer user_data)
{
    GDBusMethodInvocation *context = user_data;

    if (error)
        g_dbus_method_invocation_return_gerror(context, error);
    else
        g_dbus_method_invocation_return_value(context, NULL);
}

static void
impl_save_secrets(NMSecretAgentOld *self, GVariant *parameters, GDBusMethodInvocation *context)
{
    gs_unref_object NMConnection *connection  = NULL;
    gs_unref_variant GVariant *arg_connection = NULL;
    const char *               arg_connection_path;
    GError *                   error = NULL;

    g_variant_get(parameters, "(@a{sa{sv}}&o)", &arg_connection, &arg_connection_path);

    if (!verify_request(self, context, arg_connection, arg_connection_path, &connection, &error)) {
        g_dbus_method_invocation_take_error(context, error);
        return;
    }

    _LOGT("request: save-secrets(\"%s\")", arg_connection_path);

    NM_SECRET_AGENT_OLD_GET_CLASS(self)->save_secrets(self,
                                                      connection,
                                                      arg_connection_path,
                                                      save_secrets_cb,
                                                      context);
}

static void
delete_secrets_cb(NMSecretAgentOld *self,
                  NMConnection *    connection,
                  GError *          error,
                  gpointer          user_data)
{
    GDBusMethodInvocation *context = user_data;

    if (error)
        g_dbus_method_invocation_return_gerror(context, error);
    else
        g_dbus_method_invocation_return_value(context, NULL);
}

static void
impl_delete_secrets(NMSecretAgentOld *self, GVariant *parameters, GDBusMethodInvocation *context)
{
    gs_unref_object NMConnection *connection  = NULL;
    gs_unref_variant GVariant *arg_connection = NULL;
    const char *               arg_connection_path;
    GError *                   error = NULL;

    g_variant_get(parameters, "(@a{sa{sv}}&o)", &arg_connection, &arg_connection_path);

    if (!verify_request(self, context, arg_connection, arg_connection_path, &connection, &error)) {
        g_dbus_method_invocation_take_error(context, error);
        return;
    }

    _LOGT("request: delete-secrets(\"%s\")", arg_connection_path);

    NM_SECRET_AGENT_OLD_GET_CLASS(self)->delete_secrets(self,
                                                        connection,
                                                        arg_connection_path,
                                                        delete_secrets_cb,
                                                        context);
}

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

/**
 * nm_secret_agent_old_enable:
 * @self: the #NMSecretAgentOld instance
 * @enable: whether to enable or disable the listener.
 *
 * This has the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER
 * property.
 *
 * Unlike most other functions, you may already call this function before
 * initialization completes.
 *
 * Since: 1.24
 */
void
nm_secret_agent_old_enable(NMSecretAgentOld *self, gboolean enable)
{
    NMSecretAgentOldPrivate *priv;

    g_return_if_fail(NM_IS_SECRET_AGENT_OLD(self));

    priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    enable = (!!enable);

    if (priv->auto_register != enable) {
        priv->auto_register = enable;
        priv->is_enabled    = enable;
        _notify(self, PROP_AUTO_REGISTER);
    }
    _register_state_change(self);
}

static void
_secret_agent_old_destroy(NMSecretAgentOld *self)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    priv->is_destroyed = TRUE;

    if (priv->exported_id != 0) {
        g_dbus_connection_unregister_object(priv->dbus_connection,
                                            nm_steal_int(&priv->exported_id));
    }

    _register_state_change(self);

    nm_assert(!priv->name_owner_changed_id);
    nm_assert(!priv->name_owner_curr);
    nm_assert(!priv->name_owner_next);
    nm_assert(!priv->name_owner_cancellable);
    nm_assert(!priv->registering_retry_source);
    nm_assert(!priv->registering_cancellable);
    nm_assert(!priv->init_data);
    nm_assert(c_list_is_empty(&priv->gsi_lst_head));
    nm_assert(c_list_is_empty(&priv->pending_tasks_register_lst_head));
}

/**
 * nm_secret_agent_old_destroy:
 * @self: the #NMSecretAgentOld instance.
 *
 * Since 1.24, the instance will already register a D-Bus object on the
 * D-Bus connection during initialization. That object will stay registered
 * until @self gets unrefed (destroyed) or this function is called. This
 * function performs the necessary cleanup to tear down the instance. Afterwards,
 * the function can not longer be used. This is optional, but necessary to
 * ensure unregistering the D-Bus object at a define point, when other users
 * might still have a reference on @self.
 *
 * You may call this function any time and repeatedly. However, after destroying
 * the instance, it is a bug to still use the instance for other purposes. The
 * instance becomes defunct and cannot re-register.
 *
 * Since: 1.24
 */
void
nm_secret_agent_old_destroy(NMSecretAgentOld *self)
{
    g_return_if_fail(NM_IS_SECRET_AGENT_OLD(self));

    _LOGT("destroying");

    _secret_agent_old_destroy(self);
}

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

/**
 * nm_secret_agent_old_register:
 * @self: a #NMSecretAgentOld
 * @cancellable: a #GCancellable, or %NULL
 * @error: return location for a #GError, or %NULL
 *
 * Registers the #NMSecretAgentOld with the NetworkManager secret manager,
 * indicating to NetworkManager that the agent is able to provide and save
 * secrets for connections on behalf of its user.
 *
 * Returns: %TRUE if registration was successful, %FALSE on error.
 *
 * Since 1.24, this can no longer fail unless the @cancellable gets
 * cancelled. Contrary to nm_secret_agent_old_register_async(), this also
 * does not wait for the registration to succeed. You cannot synchronously
 * (without iterating the caller's GMainContext) wait for registration.
 *
 * Since 1.24, registration is idempotent. It has the same effect as setting
 * %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE or nm_secret_agent_old_enable().
 *
 * Deprecated: 1.24: Use nm_secret_agent_old_enable() or nm_secret_agent_old_register_async().
 **/
gboolean
nm_secret_agent_old_register(NMSecretAgentOld *self, GCancellable *cancellable, GError **error)
{
    NMSecretAgentOldPrivate *priv;

    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), FALSE);
    g_return_val_if_fail(!error || !*error, FALSE);

    priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    g_return_val_if_fail(priv->is_initialized && !priv->is_destroyed, FALSE);

    priv->is_enabled = TRUE;
    _register_state_change(self);

    if (g_cancellable_set_error_if_cancelled(cancellable, error))
        return FALSE;

    /* This is a synchronous function, meaning: we are not allowed to iterate
     * the caller's GMainContext. This is a catch 22, because we don't want
     * to perform synchronous calls that bypasses the ordering of our otherwise
     * asynchronous mode of operation. Hence, we always signal success.
     * That's why this function is deprecated.
     *
     * So despite claiming success, we might still be in the process of registering
     * or NetworkManager might not be available.
     *
     * This is a change in behavior with respect to libnm before 1.24.
     */
    return TRUE;
}

static void
_register_cancelled_cb(GObject *object, gpointer user_data)
{
    GTask *         task0         = user_data;
    gs_unref_object GTask *  task = NULL;
    NMSecretAgentOld *       self = g_task_get_source_object(task0);
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    gulong *                 p_cancelled_id;
    NMCListElem *            elem;
    gs_free_error GError *error = NULL;

    elem = nm_c_list_elem_find_first(&priv->pending_tasks_register_lst_head, x, x == task0);

    g_return_if_fail(elem);

    task = nm_c_list_elem_free_steal(elem);

    p_cancelled_id = g_task_get_task_data(task);
    if (p_cancelled_id) {
        g_signal_handler_disconnect(g_task_get_cancellable(task), *p_cancelled_id);
        g_task_set_task_data(task, NULL, NULL);
    }

    nm_utils_error_set_cancelled(&error, FALSE, NULL);
    g_task_return_error(task, error);
}

/**
 * nm_secret_agent_old_register_async:
 * @self: a #NMSecretAgentOld
 * @cancellable: a #GCancellable, or %NULL
 * @callback: callback to call when the agent is registered
 * @user_data: data for @callback
 *
 * Asynchronously registers the #NMSecretAgentOld with the NetworkManager secret
 * manager, indicating to NetworkManager that the agent is able to provide and
 * save secrets for connections on behalf of its user.
 *
 * Since 1.24, registration cannot fail and is idempotent. It has
 * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE
 * or nm_secret_agent_old_enable().
 *
 * Since 1.24, the asynchronous result indicates whether the instance is successfully
 * registered. In any case, this call enables the agent and it will automatically
 * try to register and handle secret requests. A failure of this function only indicates
 * that currently the instance might not be ready (but since it will automatically
 * try to recover, it might be ready in a moment afterwards). Use this function if
 * you want to check and ensure that the agent is registered.
 **/
void
nm_secret_agent_old_register_async(NMSecretAgentOld *  self,
                                   GCancellable *      cancellable,
                                   GAsyncReadyCallback callback,
                                   gpointer            user_data)
{
    NMSecretAgentOldPrivate *priv;

    g_return_if_fail(NM_IS_SECRET_AGENT_OLD(self));
    g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));

    priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    g_return_if_fail(priv->is_initialized && !priv->is_destroyed);

    if (callback) {
        GTask *task;

        task = nm_g_task_new(self,
                             cancellable,
                             nm_secret_agent_old_register_async,
                             callback,
                             user_data);

        c_list_link_tail(&priv->pending_tasks_register_lst_head,
                         &nm_c_list_elem_new_stale(task)->lst);

        if (cancellable) {
            gulong cancelled_id;

            cancelled_id =
                g_cancellable_connect(cancellable, G_CALLBACK(_register_cancelled_cb), task, NULL);
            if (cancelled_id != 0) {
                g_task_set_task_data(task, g_memdup(&cancelled_id, sizeof(cancelled_id)), g_free);
            }
        }
    }

    priv->is_enabled = TRUE;
    _register_state_change(self);
}

/**
 * nm_secret_agent_old_register_finish:
 * @self: a #NMSecretAgentOld
 * @result: the result passed to the #GAsyncReadyCallback
 * @error: return location for a #GError, or %NULL
 *
 * Gets the result of a call to nm_secret_agent_old_register_async().
 *
 * Returns: %TRUE if registration was successful, %FALSE on error.
 *
 * Since 1.24, registration cannot fail and is idempotent. It has
 * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE
 * or nm_secret_agent_old_enable().
 **/
gboolean
nm_secret_agent_old_register_finish(NMSecretAgentOld *self, GAsyncResult *result, GError **error)
{
    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), FALSE);
    g_return_val_if_fail(nm_g_task_is_valid(result, self, nm_secret_agent_old_register_async),
                         FALSE);

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

/**
 * nm_secret_agent_old_unregister:
 * @self: a #NMSecretAgentOld
 * @cancellable: a #GCancellable, or %NULL
 * @error: return location for a #GError, or %NULL
 *
 * Unregisters the #NMSecretAgentOld with the NetworkManager secret manager,
 * indicating to NetworkManager that the agent will no longer provide or
 * store secrets on behalf of this user.
 *
 * Returns: %TRUE if unregistration was successful, %FALSE on error
 *
 * Since 1.24, registration cannot fail and is idempotent. It has
 * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
 * or nm_secret_agent_old_enable().
 *
 * Deprecated: 1.24: Use nm_secret_agent_old_enable().
 **/
gboolean
nm_secret_agent_old_unregister(NMSecretAgentOld *self, GCancellable *cancellable, GError **error)
{
    NMSecretAgentOldPrivate *priv;

    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), FALSE);
    g_return_val_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable), FALSE);
    g_return_val_if_fail(!error || !*error, FALSE);

    priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    g_return_val_if_fail(priv->is_initialized && !priv->is_destroyed, FALSE);

    priv->is_enabled = FALSE;
    _register_state_change(self);

    return !g_cancellable_set_error_if_cancelled(cancellable, error);
}

/**
 * nm_secret_agent_old_unregister_async:
 * @self: a #NMSecretAgentOld
 * @cancellable: a #GCancellable, or %NULL
 * @callback: callback to call when the agent is unregistered
 * @user_data: data for @callback
 *
 * Asynchronously unregisters the #NMSecretAgentOld with the NetworkManager secret
 * manager, indicating to NetworkManager that the agent will no longer provide
 * or store secrets on behalf of this user.
 *
 * Since 1.24, registration cannot fail and is idempotent. It has
 * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
 * or nm_secret_agent_old_enable().
 *
 * Deprecated: 1.24: Use nm_secret_agent_old_enable().
 **/
void
nm_secret_agent_old_unregister_async(NMSecretAgentOld *  self,
                                     GCancellable *      cancellable,
                                     GAsyncReadyCallback callback,
                                     gpointer            user_data)
{
    NMSecretAgentOldPrivate *priv;

    g_return_if_fail(NM_IS_SECRET_AGENT_OLD(self));
    g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));

    priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    g_return_if_fail(priv->is_initialized && !priv->is_destroyed);

    if (callback) {
        gs_unref_object GTask *task = NULL;

        task = nm_g_task_new(self,
                             cancellable,
                             nm_secret_agent_old_unregister_async,
                             callback,
                             user_data);
        g_task_return_boolean(task, TRUE);
    }

    priv->is_enabled = FALSE;
    _register_state_change(self);
}

/**
 * nm_secret_agent_old_unregister_finish:
 * @self: a #NMSecretAgentOld
 * @result: the result passed to the #GAsyncReadyCallback
 * @error: return location for a #GError, or %NULL
 *
 * Gets the result of a call to nm_secret_agent_old_unregister_async().
 *
 * Returns: %TRUE if unregistration was successful, %FALSE on error.
 *
 * Since 1.24, registration cannot fail and is idempotent. It has
 * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
 * or nm_secret_agent_old_enable().
 *
 * Deprecated: 1.24: Use nm_secret_agent_old_enable().
 **/
gboolean
nm_secret_agent_old_unregister_finish(NMSecretAgentOld *self, GAsyncResult *result, GError **error)
{
    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(self), FALSE);
    g_return_val_if_fail(nm_g_task_is_valid(result, self, nm_secret_agent_old_unregister_async),
                         FALSE);

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

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

/**
 * nm_secret_agent_old_get_secrets: (virtual get_secrets):
 * @self: a #NMSecretAgentOld
 * @connection: the #NMConnection for which we're asked secrets
 * @setting_name: the name of the secret setting
 * @hints: (array zero-terminated=1): hints to the agent
 * @flags: flags that modify the behavior of the request
 * @callback: (scope async): a callback, to be invoked when the operation is done
 * @user_data: (closure): caller-specific data to be passed to @callback
 *
 * Asynchronously retrieves secrets belonging to @connection for the
 * setting @setting_name.  @flags indicate specific behavior that the secret
 * agent should use when performing the request, for example returning only
 * existing secrets without user interaction, or requesting entirely new
 * secrets from the user.
 */
void
nm_secret_agent_old_get_secrets(NMSecretAgentOld *             self,
                                NMConnection *                 connection,
                                const char *                   setting_name,
                                const char **                  hints,
                                NMSecretAgentGetSecretsFlags   flags,
                                NMSecretAgentOldGetSecretsFunc callback,
                                gpointer                       user_data)
{
    g_return_if_fail(NM_IS_SECRET_AGENT_OLD(self));
    g_return_if_fail(NM_IS_CONNECTION(connection));
    g_return_if_fail(nm_connection_get_path(connection));
    g_return_if_fail(setting_name && setting_name[0]);
    g_return_if_fail(!(flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM));
    g_return_if_fail(!(flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_NO_ERRORS));
    g_return_if_fail(callback != NULL);

    NM_SECRET_AGENT_OLD_GET_CLASS(self)->get_secrets(self,
                                                     connection,
                                                     nm_connection_get_path(connection),
                                                     setting_name,
                                                     hints,
                                                     flags,
                                                     callback,
                                                     user_data);
}

/**
 * nm_secret_agent_old_save_secrets: (virtual save_secrets):
 * @self: a #NMSecretAgentOld
 * @connection: a #NMConnection
 * @callback: (scope async): a callback, to be invoked when the operation is done
 * @user_data: (closure): caller-specific data to be passed to @callback
 *
 * Asynchronously ensures that all secrets inside @connection are stored to
 * disk.
 */
void
nm_secret_agent_old_save_secrets(NMSecretAgentOld *              self,
                                 NMConnection *                  connection,
                                 NMSecretAgentOldSaveSecretsFunc callback,
                                 gpointer                        user_data)
{
    g_return_if_fail(NM_IS_SECRET_AGENT_OLD(self));
    g_return_if_fail(NM_IS_CONNECTION(connection));
    g_return_if_fail(nm_connection_get_path(connection));

    NM_SECRET_AGENT_OLD_GET_CLASS(self)->save_secrets(self,
                                                      connection,
                                                      nm_connection_get_path(connection),
                                                      callback,
                                                      user_data);
}

/**
 * nm_secret_agent_old_delete_secrets: (virtual delete_secrets):
 * @self: a #NMSecretAgentOld
 * @connection: a #NMConnection
 * @callback: (scope async): a callback, to be invoked when the operation is done
 * @user_data: (closure): caller-specific data to be passed to @callback
 *
 * Asynchronously asks the agent to delete all saved secrets belonging to
 * @connection.
 */
void
nm_secret_agent_old_delete_secrets(NMSecretAgentOld *                self,
                                   NMConnection *                    connection,
                                   NMSecretAgentOldDeleteSecretsFunc callback,
                                   gpointer                          user_data)
{
    g_return_if_fail(NM_IS_SECRET_AGENT_OLD(self));
    g_return_if_fail(NM_IS_CONNECTION(connection));
    g_return_if_fail(nm_connection_get_path(connection));

    NM_SECRET_AGENT_OLD_GET_CLASS(self)->delete_secrets(self,
                                                        connection,
                                                        nm_connection_get_path(connection),
                                                        callback,
                                                        user_data);
}

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

static gboolean
validate_identifier(const char *identifier)
{
    const char *p = identifier;
    size_t      id_len;

    /* Length between 3 and 255 characters inclusive */
    id_len = strlen(identifier);
    if (id_len < 3 || id_len > 255)
        return FALSE;

    if ((identifier[0] == '.') || (identifier[id_len - 1] == '.'))
        return FALSE;

    /* FIXME: do complete validation here */
    while (p && *p) {
        if (!g_ascii_isalnum(*p) && (*p != '_') && (*p != '-') && (*p != '.'))
            return FALSE;
        if ((*p == '.') && (*(p + 1) == '.'))
            return FALSE;
        p++;
    }

    return TRUE;
}

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

static gboolean
_register_retry_cb(gpointer user_data)
{
    NMSecretAgentOld *       self                       = user_data;
    NMSecretAgentOldPrivate *priv                       = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;

    dbus_context = nm_g_main_context_push_thread_default_if_necessary(priv->dbus_context);

    nm_clear_g_source_inst(&priv->registering_retry_source);
    _register_dbus_call(self);
    return G_SOURCE_CONTINUE;
}

static void
_register_call_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMSecretAgentOld *       self  = user_data;
    NMSecretAgentOldPrivate *priv  = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    gs_unref_variant GVariant *ret = NULL;
    gs_free_error GError *error    = NULL;

    ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error);

    if (nm_utils_error_is_cancelled(error))
        return;

    nm_assert(!priv->registering_retry_source);
    nm_assert(!priv->is_registered);
    nm_assert(priv->registering_cancellable);

    if (nm_dbus_error_is(error, NM_DBUS_ERROR_NAME_UNKNOWN_METHOD)
        && nm_utils_get_monotonic_timestamp_msec() < priv->registering_timeout_msec) {
        guint timeout_msec;

        timeout_msec = (2u << NM_MIN(6u, ++priv->registering_try_count));

        _LOGT("register: registration failed with error \"%s\". Retry in %u msec...",
              error->message,
              timeout_msec);

        priv->registering_retry_source =
            nm_g_source_attach(nm_g_timeout_source_new(timeout_msec,
                                                       G_PRIORITY_DEFAULT,
                                                       _register_retry_cb,
                                                       self,
                                                       NULL),
                               priv->dbus_context);
        return;
    }

    g_clear_object(&priv->registering_cancellable);

    if (error) {
        /* registration apparently failed. However we still keep priv->registered_against_server TRUE, because
         *
         * - eventually we want to still make an Unregister() call. Even if it probably has no effect,
         *   better be sure.
         *
         * - we actually accept secret request (from the right name owner). We register so that
         *   NetworkManager knows that we are here. We don't require the registration to succeed
         *   for our purpose. If NetworkManager makes requests for us, despite the registration
         *   failing, that is fine. */
        _LOGT("register: registration failed with error \"%s\"", error->message);
        goto out;
    }

    _LOGT("register: registration succeeded");
    priv->is_registered = TRUE;
    _notify(self, PROP_REGISTERED);

out:
    _register_state_complete(self);
}

static void
_register_dbus_call(NMSecretAgentOld *self)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    _dbus_connection_call(self,
                          nm_ref_string_get_str(priv->name_owner_curr),
                          NM_DBUS_PATH_AGENT_MANAGER,
                          NM_DBUS_INTERFACE_AGENT_MANAGER,
                          "RegisterWithCapabilities",
                          g_variant_new("(su)", priv->identifier, (guint32) priv->capabilities),
                          G_VARIANT_TYPE("()"),
                          G_DBUS_CALL_FLAGS_NONE,
                          _CALL_REGISTER_TIMEOUT_MSEC,
                          priv->registering_cancellable,
                          _register_call_cb,
                          self);
}

static void
_get_connection_unix_user_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
    NMSecretAgentOld *       self;
    NMSecretAgentOldPrivate *priv;
    gs_unref_variant GVariant *ret   = NULL;
    gs_free_error GError *error      = NULL;
    guint32               sender_uid = 0;

    ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error);
    if (nm_utils_error_is_cancelled(error))
        return;

    self = user_data;
    priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    nm_assert(priv->registering_cancellable);
    nm_assert(!priv->registered_against_server);

    if (ret)
        g_variant_get(ret, "(u)", &sender_uid);

    if (ret && sender_uid == 0)
        _LOGT("register: peer %s is owned by root. Validated to accept requests.",
              priv->name_owner_curr->str);
    else if (ret && priv->session_bus) {
        _LOGT(
            "register: peer %s is owned by user %d for session bus. Validated to accept requests.",
            priv->name_owner_curr->str,
            sender_uid);
    } else {
        /* the peer is not validated. We don't actually register. */
        if (ret)
            _LOGT("register: peer %s is owned by user %u. Not validated as NetworkManager service.",
                  priv->name_owner_curr->str,
                  sender_uid);
        else
            _LOGT("register: failed to get user id for peer %s: %s. Not validated as "
                  "NetworkManager service.",
                  priv->name_owner_curr->str,
                  error->message);

        /* we actually don't do anything and keep the agent unregistered.
         *
         * We keep priv->registering_cancellable set to not retry this again, until we loose the
         * name owner. But the state of the agent is lingering and won't accept any requests. */
        return;
    }

    priv->registering_timeout_msec =
        nm_utils_get_monotonic_timestamp_msec() + REGISTER_RETRY_TIMEOUT_MSEC;
    priv->registering_try_count     = 0;
    priv->registered_against_server = TRUE;
    _register_dbus_call(self);
}

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

static void
_name_owner_changed(NMSecretAgentOld *self, const char *name_owner, gboolean is_event)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    if (is_event) {
        if (priv->name_owner_cancellable) {
            /* we are still fetching the name-owner. Ignore this event. */
            return;
        }
    } else
        g_clear_object(&priv->name_owner_cancellable);

    nm_ref_string_unref(priv->name_owner_next);
    priv->name_owner_next = nm_ref_string_new(nm_str_not_empty(name_owner));

    _LOGT("name-owner changed: %s%s%s -> %s%s%s",
          NM_PRINT_FMT_QUOTED(priv->name_owner_curr,
                              "\"",
                              priv->name_owner_curr->str,
                              "\"",
                              "(null)"),
          NM_PRINT_FMT_QUOTED(priv->name_owner_next,
                              "\"",
                              priv->name_owner_next->str,
                              "\"",
                              "(null)"));

    _register_state_change(self);
}

static void
_name_owner_changed_cb(GDBusConnection *connection,
                       const char *     sender_name,
                       const char *     object_path,
                       const char *     interface_name,
                       const char *     signal_name,
                       GVariant *       parameters,
                       gpointer         user_data)
{
    NMSecretAgentOld *self = user_data;
    const char *      new_owner;

    if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(sss)")))
        return;

    g_variant_get(parameters, "(&s&s&s)", NULL, NULL, &new_owner);

    _name_owner_changed(self, new_owner, TRUE);
}

static void
_name_owner_get_cb(const char *name_owner, GError *error, gpointer user_data)
{
    if (name_owner || !nm_utils_error_is_cancelled(error))
        _name_owner_changed(user_data, name_owner, FALSE);
}

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

static void
_method_call(GDBusConnection *      connection,
             const char *           sender,
             const char *           object_path,
             const char *           interface_name,
             const char *           method_name,
             GVariant *             parameters,
             GDBusMethodInvocation *context,
             gpointer               user_data)
{
    NMSecretAgentOld *       self = user_data;
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    nm_assert(nm_streq0(object_path, NM_DBUS_PATH_SECRET_AGENT));
    nm_assert(nm_streq0(interface_name, NM_DBUS_INTERFACE_SECRET_AGENT));
    nm_assert(sender);
    nm_assert(nm_streq0(sender, g_dbus_method_invocation_get_sender(context)));

    if (!priv->name_owner_curr || !priv->registered_against_server) {
        /* priv->registered_against_server means that we started to register, but not necessarily
         * that the registration fully succeeded. However, we already authenticated the request
         * and so we accept it, even if the registration is not yet complete. */
        g_dbus_method_invocation_return_error_literal(context,
                                                      NM_SECRET_AGENT_ERROR,
                                                      NM_SECRET_AGENT_ERROR_PERMISSION_DENIED,
                                                      "Request by non authenticated peer rejected");
        return;
    }

    if (nm_streq(method_name, "GetSecrets"))
        impl_get_secrets(self, parameters, context);
    else if (nm_streq(method_name, "CancelGetSecrets"))
        impl_cancel_get_secrets(self, parameters, context);
    else if (nm_streq(method_name, "SaveSecrets"))
        impl_save_secrets(self, parameters, context);
    else if (nm_streq(method_name, "DeleteSecrets"))
        impl_delete_secrets(self, parameters, context);
    else
        nm_assert_not_reached();
}

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

static void
_register_state_complete(NMSecretAgentOld *self)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    NMCListElem *            elem;
    gboolean                 any_tasks_to_complete = FALSE;

    if (!c_list_is_empty(&priv->pending_tasks_register_lst_head)) {
        /* add a dummy sentinel. We want to complete all the task we started
         * so far, but as we invoke user callbacks, the user might register
         * new tasks. Those we don't complete in this run. */
        g_object_ref(self);
        any_tasks_to_complete = TRUE;
        c_list_link_tail(&priv->pending_tasks_register_lst_head,
                         &nm_c_list_elem_new_stale(&any_tasks_to_complete)->lst);
    }

    _init_complete(self, NULL);

    if (any_tasks_to_complete) {
        while (
            (elem = c_list_first_entry(&priv->pending_tasks_register_lst_head, NMCListElem, lst))) {
            gpointer        data        = nm_c_list_elem_free_steal(elem);
            gs_unref_object GTask *task = NULL;

            if (data == &any_tasks_to_complete) {
                any_tasks_to_complete = FALSE;
                break;
            }

            task = data;

            if (!priv->is_registered) {
                g_task_return_error(task,
                                    g_error_new_literal(NM_SECRET_AGENT_ERROR,
                                                        NM_SECRET_AGENT_ERROR_FAILED,
                                                        _("registration failed")));
                continue;
            }
            g_task_return_boolean(task, TRUE);
        }
        nm_assert(!any_tasks_to_complete);
        g_object_unref(self);
    }
}

static void
_register_state_change_do(NMSecretAgentOld *self)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    if (priv->is_destroyed)
        priv->is_enabled = FALSE;

    if (!priv->is_enabled || priv->registration_force_unregister
        || priv->name_owner_curr != priv->name_owner_next) {
        GetSecretsInfo *info;

        while ((info = c_list_first_entry(&priv->gsi_lst_head, GetSecretsInfo, gsi_lst))) {
            _cancel_get_secret_request(self, info, "The secret agent is going away");
            _register_state_change(self);
            return;
        }

        priv->registration_force_unregister = FALSE;

        nm_clear_g_cancellable(&priv->registering_cancellable);
        nm_clear_g_source_inst(&priv->registering_retry_source);

        if (priv->registered_against_server) {
            priv->registered_against_server = FALSE;
            if (priv->name_owner_curr) {
                _LOGT("register: unregister from %s", priv->name_owner_curr->str);
                _dbus_connection_call(self,
                                      priv->name_owner_curr->str,
                                      NM_DBUS_PATH_AGENT_MANAGER,
                                      NM_DBUS_INTERFACE_AGENT_MANAGER,
                                      "Unregister",
                                      g_variant_new("()"),
                                      G_VARIANT_TYPE("()"),
                                      G_DBUS_CALL_FLAGS_NONE,
                                      _CALL_REGISTER_TIMEOUT_MSEC,
                                      NULL,
                                      NULL,
                                      NULL);
            }
        }

        if (!priv->is_enabled) {
            nm_clear_g_cancellable(&priv->name_owner_cancellable);
            nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->name_owner_changed_id);
            nm_clear_pointer(&priv->name_owner_curr, nm_ref_string_unref);
            nm_clear_pointer(&priv->name_owner_next, nm_ref_string_unref);
        }

        if (priv->is_registered) {
            priv->is_registered = FALSE;
            if (!priv->is_destroyed) {
                _LOGT("register: now unregistered");
                _notify(self, PROP_REGISTERED);
                _register_state_change(self);
                return;
            }
        }

        if (!priv->is_enabled) {
            _register_state_complete(self);
            return;
        }

        if (priv->name_owner_curr != priv->name_owner_next) {
            nm_ref_string_unref(priv->name_owner_curr);
            priv->name_owner_curr = nm_ref_string_ref(priv->name_owner_next);
        }
    }

    if (priv->name_owner_changed_id == 0) {
        nm_assert(!priv->name_owner_cancellable);
        nm_assert(!priv->name_owner_curr);
        nm_assert(!priv->name_owner_next);
        priv->name_owner_cancellable = g_cancellable_new();
        priv->name_owner_changed_id =
            nm_dbus_connection_signal_subscribe_name_owner_changed(priv->dbus_connection,
                                                                   NM_DBUS_SERVICE,
                                                                   _name_owner_changed_cb,
                                                                   self,
                                                                   NULL);
        nm_dbus_connection_call_get_name_owner(priv->dbus_connection,
                                               NM_DBUS_SERVICE,
                                               -1,
                                               priv->name_owner_cancellable,
                                               _name_owner_get_cb,
                                               self);
        return;
    }

    if (priv->name_owner_cancellable) {
        /* we still wait for the name owner. Nothing to do for now. */
        return;
    }

    if (!priv->name_owner_curr) {
        /* we don't have a name owner. We are done and wait. */
        _register_state_complete(self);
        return;
    }

    if (priv->registering_cancellable) {
        /* we are already registering... wait longer. */
        return;
    }

    nm_assert(!priv->registering_retry_source);

    if (!priv->is_registered) {
        /* start registering... */
        priv->registering_cancellable = g_cancellable_new();
        _dbus_connection_call(self,
                              DBUS_SERVICE_DBUS,
                              DBUS_PATH_DBUS,
                              DBUS_INTERFACE_DBUS,
                              "GetConnectionUnixUser",
                              g_variant_new("(s)", priv->name_owner_curr->str),
                              G_VARIANT_TYPE("(u)"),
                              G_DBUS_CALL_FLAGS_NONE,
                              _CALL_REGISTER_TIMEOUT_MSEC,
                              priv->registering_cancellable,
                              _get_connection_unix_user_cb,
                              self);
        return;
    }

    /* we are fully registered and done. */
    _register_state_complete(self);
}

static void
_register_state_change(NMSecretAgentOld *self)
{
    _nm_unused gs_unref_object NMSecretAgentOld *self_keep_alive = g_object_ref(self);
    NMSecretAgentOldPrivate *                    priv   = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;

    if (priv->register_state_change_reenter == 0) {
        /* We are not yet initialized. Do nothing. */
        return;
    }

    if (priv->register_state_change_reenter != 1) {
        /* Recursive calls are prevented. Do nothing for now, but repeat
         * the state change afterwards. */
        priv->register_state_change_reenter = 3;
        return;
    }

    dbus_context = nm_g_main_context_push_thread_default_if_necessary(priv->dbus_context);

again:
    priv->register_state_change_reenter = 2;

    _register_state_change_do(self);

    if (priv->register_state_change_reenter != 2)
        goto again;

    priv->register_state_change_reenter = 1;
}

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

static void
_init_complete(NMSecretAgentOld *self, GError *error_take)
{
    NMSecretAgentOldPrivate *priv         = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    gs_free_error GError *error           = g_steal_pointer(&error_take);
    GError *              error_cancelled = NULL;

    if (!priv->init_data)
        return;

    if (g_cancellable_set_error_if_cancelled(priv->init_data->cancellable, &error_cancelled)) {
        g_clear_error(&error);
        g_propagate_error(&error, error_cancelled);
    }

    priv->is_initialized = (!error);

    _LOGT("%s init complete with %s%s%s",
          priv->init_data->is_sync ? "sync" : "async",
          NM_PRINT_FMT_QUOTED(error_take, "error: ", error_take->message, "", "success"));

    nml_init_data_return(g_steal_pointer(&priv->init_data), g_steal_pointer(&error));
}

static void
_init_register_object(NMSecretAgentOld *self)
{
    NMSecretAgentOldPrivate *priv          = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    gs_free_error GError *error            = NULL;
    GDBusInterfaceVTable  interface_vtable = {
        .method_call = _method_call,
    };

    if (g_cancellable_set_error_if_cancelled(priv->init_data->cancellable, &error)) {
        _init_complete(self, g_steal_pointer(&error));
        return;
    }

    priv->exported_id = g_dbus_connection_register_object(priv->dbus_connection,
                                                          NM_DBUS_PATH_SECRET_AGENT,
                                                          (GDBusInterfaceInfo *) &interface_info,
                                                          &interface_vtable,
                                                          self,
                                                          NULL,
                                                          &error);
    if (priv->exported_id == 0) {
        _init_complete(self, g_steal_pointer(&error));
        return;
    }

    priv->register_state_change_reenter = 1;

    _register_state_change(self);
}

static void
_init_got_bus(GObject *initable, GAsyncResult *result, gpointer user_data)
{
    NMSecretAgentOld *       self = user_data;
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    gs_free_error GError *error   = NULL;

    priv->dbus_connection = g_bus_get_finish(result, &error);
    if (!priv->dbus_connection) {
        _init_complete(self, g_steal_pointer(&error));
        return;
    }

    _LOGT("init: got GDBusConnection");

    _notify(self, PROP_DBUS_CONNECTION);

    _init_register_object(self);
}

static void
_init_start(NMSecretAgentOld *self)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    if (!priv->dbus_connection) {
        GBusType bus_type;

        bus_type = _nm_dbus_bus_type();

        priv->session_bus = (bus_type == G_BUS_TYPE_SESSION);

        g_bus_get(bus_type, priv->init_data->cancellable, _init_got_bus, self);
        return;
    }

    _init_register_object(self);
}

static void
init_async(GAsyncInitable *    initable,
           int                 io_priority,
           GCancellable *      cancellable,
           GAsyncReadyCallback callback,
           gpointer            user_data)
{
    NMSecretAgentOld *       self;
    NMSecretAgentOldClass *  klass;
    NMSecretAgentOldPrivate *priv;
    nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;
    gs_unref_object GTask *task                         = NULL;

    g_return_if_fail(NM_IS_SECRET_AGENT_OLD(initable));

    self = NM_SECRET_AGENT_OLD(initable);
    priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    g_return_if_fail(!priv->dbus_context);
    g_return_if_fail(!priv->is_destroyed);

    klass = NM_SECRET_AGENT_OLD_GET_CLASS(self);
    g_return_if_fail(klass->get_secrets);
    g_return_if_fail(klass->cancel_get_secrets);
    g_return_if_fail(klass->save_secrets);
    g_return_if_fail(klass->delete_secrets);

    _LOGT("init-async starting...");

    priv->dbus_context = g_main_context_ref(priv->main_context);

    dbus_context = nm_g_main_context_push_thread_default_if_necessary(priv->dbus_context);

    task = nm_g_task_new(self, cancellable, init_async, callback, user_data);
    g_task_set_priority(task, io_priority);

    priv->init_data = nml_init_data_new_async(cancellable, g_steal_pointer(&task));

    _init_start(self);
}

static gboolean
init_finish(GAsyncInitable *initable, GAsyncResult *result, GError **error)
{
    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(initable), FALSE);
    g_return_val_if_fail(nm_g_task_is_valid(result, initable, init_async), FALSE);

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

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

static gboolean
init_sync(GInitable *initable, GCancellable *cancellable, GError **error)
{
    gs_unref_object NMSecretAgentOld *self = NULL;
    NMSecretAgentOldPrivate *         priv;
    NMSecretAgentOldClass *           klass;
    GMainLoop *                       main_loop;
    GError *                          local_error = NULL;

    g_return_val_if_fail(NM_IS_SECRET_AGENT_OLD(initable), FALSE);

    self = g_object_ref(NM_SECRET_AGENT_OLD(initable));
    priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    g_return_val_if_fail(!priv->dbus_context, FALSE);
    g_return_val_if_fail(!priv->is_destroyed, FALSE);

    klass = NM_SECRET_AGENT_OLD_GET_CLASS(self);
    g_return_val_if_fail(klass->get_secrets, FALSE);
    g_return_val_if_fail(klass->cancel_get_secrets, FALSE);
    g_return_val_if_fail(klass->save_secrets, FALSE);
    g_return_val_if_fail(klass->delete_secrets, FALSE);

    _LOGT("init-sync");

    /* See NMClient's sync-init method for explanation about why we create
     * an internal GMainContext priv->dbus_context. */

    priv->dbus_context = g_main_context_new();

    g_main_context_push_thread_default(priv->dbus_context);

    main_loop = g_main_loop_new(priv->dbus_context, FALSE);

    priv->init_data = nml_init_data_new_sync(cancellable, main_loop, &local_error);

    _init_start(self);

    g_main_loop_run(main_loop);

    g_main_loop_unref(main_loop);

    g_main_context_pop_thread_default(priv->dbus_context);

    nm_context_busy_watcher_integrate_source(priv->main_context,
                                             priv->dbus_context,
                                             priv->context_busy_watcher);

    if (local_error) {
        g_propagate_error(error, local_error);
        return FALSE;
    }

    return TRUE;
}

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

static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(object);

    switch (prop_id) {
    case PROP_DBUS_CONNECTION:
        g_value_set_object(value, priv->dbus_connection);
        break;
    case PROP_IDENTIFIER:
        g_value_set_string(value, priv->identifier);
        break;
    case PROP_AUTO_REGISTER:
        g_value_set_boolean(value, priv->auto_register);
        break;
    case PROP_REGISTERED:
        g_value_set_boolean(value, priv->is_registered);
        break;
    case PROP_CAPABILITIES:
        g_value_set_flags(value, priv->capabilities);
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

static void
set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
    NMSecretAgentOld *       self = NM_SECRET_AGENT_OLD(object);
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);
    guint                    u;

    switch (prop_id) {
    case PROP_DBUS_CONNECTION:
        /* construct-only */
        priv->dbus_connection = g_value_dup_object(value);
        break;
    case PROP_IDENTIFIER:
        /* construct-only */
        priv->identifier = g_value_dup_string(value);
        g_return_if_fail(validate_identifier(priv->identifier));
        break;
    case PROP_AUTO_REGISTER:
        /* construct */
        priv->auto_register = g_value_get_boolean(value);
        priv->is_enabled    = priv->auto_register;
        _register_state_change(self);
        break;
    case PROP_CAPABILITIES:
        /* construct */
        u = g_value_get_flags(value);
        if (u != priv->capabilities) {
            priv->capabilities                  = u;
            priv->registration_force_unregister = TRUE;
            _register_state_change(self);
        }
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

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

static void
nm_secret_agent_old_init(NMSecretAgentOld *self)
{
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    _LOGT("create new instance");

    c_list_init(&priv->gsi_lst_head);
    c_list_init(&priv->pending_tasks_register_lst_head);

    priv->main_context         = g_main_context_ref_thread_default();
    priv->context_busy_watcher = g_object_new(G_TYPE_OBJECT, NULL);
}

static void
dispose(GObject *object)
{
    NMSecretAgentOld *self = NM_SECRET_AGENT_OLD(object);

    _LOGT("disposing");

    _secret_agent_old_destroy(self);

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

static void
finalize(GObject *object)
{
    NMSecretAgentOld *       self = NM_SECRET_AGENT_OLD(object);
    NMSecretAgentOldPrivate *priv = NM_SECRET_AGENT_OLD_GET_PRIVATE(self);

    _LOGT("finalizing");

    if (priv->dbus_context) {
        nml_cleanup_context_busy_watcher_on_idle(g_steal_pointer(&priv->context_busy_watcher),
                                                 priv->dbus_context);
    }

    g_clear_object(&priv->dbus_connection);
    nm_clear_pointer(&priv->dbus_context, g_main_context_unref);
    nm_clear_pointer(&priv->main_context, g_main_context_unref);

    g_clear_object(&priv->context_busy_watcher);

    g_free(priv->identifier);

    G_OBJECT_CLASS(nm_secret_agent_old_parent_class)->finalize(object);
}

static void
nm_secret_agent_old_class_init(NMSecretAgentOldClass *class)
{
    GObjectClass *object_class = G_OBJECT_CLASS(class);

    g_type_class_add_private(class, sizeof(NMSecretAgentOldPrivate));

    object_class->get_property = get_property;
    object_class->set_property = set_property;
    object_class->dispose      = dispose;
    object_class->finalize     = finalize;

    /**
     * NMSecretAgentOld:dbus-connection:
     *
     * The #GDBusConnection used by the instance. You may either set this
     * as construct-only property, or otherwise #NMSecretAgentOld will choose
     * a connection via g_bus_get() during initialization.
     *
     * Since: 1.24
     **/
    obj_properties[PROP_DBUS_CONNECTION] =
        g_param_spec_object(NM_SECRET_AGENT_OLD_DBUS_CONNECTION,
                            "",
                            "",
                            G_TYPE_DBUS_CONNECTION,
                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);

    /**
     * NMSecretAgentOld:identifier:
     *
     * Identifies this agent; only one agent in each user session may use the
     * same identifier.  Identifier formatting follows the same rules as
     * D-Bus bus names with the exception that the ':' character is not
     * allowed.  The valid set of characters is "[A-Z][a-z][0-9]_-." and the
     * identifier is limited in length to 255 characters with a minimum
     * of 3 characters.  An example valid identifier is 'org.gnome.nm-applet'
     * (without quotes).
     **/
    obj_properties[PROP_IDENTIFIER] =
        g_param_spec_string(NM_SECRET_AGENT_OLD_IDENTIFIER,
                            "",
                            "",
                            NULL,
                            G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);

    /**
     * NMSecretAgentOld:auto-register:
     *
     * If %TRUE (the default), the agent will always be registered when
     * NetworkManager is running; if NetworkManager exits and restarts, the
     * agent will re-register itself automatically.
     *
     * In particular, if this property is %TRUE at construct time, then the
     * agent will register itself with NetworkManager during
     * construction/initialization and initialization will only complete
     * after registration is completed (either successfully or unsuccessfully).
     * Since 1.24, a failure to register will no longer cause initialization
     * of #NMSecretAgentOld to fail.
     *
     * If the property is %FALSE, the agent will not automatically register with
     * NetworkManager, and nm_secret_agent_old_enable() or
     * nm_secret_agent_old_register_async() must be called to register it.
     *
     * Calling nm_secret_agent_old_enable() has the same effect as setting this
     * property.
     **/
    obj_properties[PROP_AUTO_REGISTER] =
        g_param_spec_boolean(NM_SECRET_AGENT_OLD_AUTO_REGISTER,
                             "",
                             "",
                             TRUE,
                             G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);

    /**
     * NMSecretAgentOld:registered:
     *
     * %TRUE if the agent is registered with NetworkManager, %FALSE if not.
     **/
    obj_properties[PROP_REGISTERED] =
        g_param_spec_boolean(NM_SECRET_AGENT_OLD_REGISTERED,
                             "",
                             "",
                             FALSE,
                             G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    /**
     * NMSecretAgentOld:capabilities:
     *
     * A bitfield of %NMSecretAgentCapabilities.
     *
     * Changing this property is possible at any time. In case the secret
     * agent is currently registered, this will cause a re-registration.
     **/
    obj_properties[PROP_CAPABILITIES] =
        g_param_spec_flags(NM_SECRET_AGENT_OLD_CAPABILITIES,
                           "",
                           "",
                           NM_TYPE_SECRET_AGENT_CAPABILITIES,
                           NM_SECRET_AGENT_CAPABILITY_NONE,
                           G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);

    g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
}

static void
nm_secret_agent_old_initable_iface_init(GInitableIface *iface)
{
    iface->init = init_sync;
}

static void
nm_secret_agent_old_async_initable_iface_init(GAsyncInitableIface *iface)
{
    iface->init_async  = init_async;
    iface->init_finish = init_finish;
}
