NetworkManager/src/nm-keep-alive.c

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

#include "nm-default.h"

#include "nm-keep-alive.h"

#include "settings/nm-settings-connection.h"
#include "nm-glib-aux/nm-dbus-aux.h"

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

NM_GOBJECT_PROPERTIES_DEFINE(NMKeepAlive, PROP_ALIVE, );

typedef struct {
    GObject *owner;

    NMSettingsConnection *connection;
    GDBusConnection *     dbus_connection;
    char *                dbus_client;

    GCancellable *dbus_client_confirm_cancellable;
    guint         subscription_id;

    bool armed : 1;
    bool disarmed : 1;

    bool alive : 1;
    bool dbus_client_confirmed : 1;
    bool dbus_client_watching : 1;
    bool connection_was_visible : 1;
} NMKeepAlivePrivate;

struct _NMKeepAlive {
    GObject            parent;
    NMKeepAlivePrivate _priv;
};

struct _NMKeepAliveClass {
    GObjectClass parent;
};

G_DEFINE_TYPE(NMKeepAlive, nm_keep_alive, G_TYPE_OBJECT)

#define NM_KEEP_ALIVE_GET_PRIVATE(self) _NM_GET_PRIVATE(self, NMKeepAlive, NM_IS_KEEP_ALIVE)

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

#define _NMLOG_DOMAIN      LOGD_CORE
#define _NMLOG(level, ...) __NMLOG_DEFAULT(level, _NMLOG_DOMAIN, "keep-alive", __VA_ARGS__)

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

static gboolean _is_alive_dbus_client(NMKeepAlive *self);
static void     cleanup_dbus_watch(NMKeepAlive *self);

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

static gboolean
_is_alive(NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    nm_assert(!priv->disarmed);

    if (!priv->armed) {
        /* before arming, the instance is always alive. */
        return TRUE;
    }

    if (priv->dbus_client_watching) {
        if (_is_alive_dbus_client(self)) {
            /* no matter what, the keep-alive is alive, because there is a D-Bus client
             * still around keeping it alive. */
            return TRUE;
        }
        /* the D-Bus client is gone. The only other binding (below) for the connection's
         * visibility cannot keep the instance alive.
         *
         * As such, a D-Bus client watch is authoritative and overrules other conditions (that
         * we have so far). */
        return FALSE;
    }

    if (priv->connection && priv->connection_was_visible
        && !NM_FLAGS_HAS(nm_settings_connection_get_flags(priv->connection),
                         NM_SETTINGS_CONNECTION_INT_FLAGS_VISIBLE)) {
        /* note that we only declare the keep-alive as dead due to invisible
         * connection, if
         *    (1) we monitor a connection, obviously
         *    (2) the connection was visible earlier and is no longer. It was
         *        was invisible all the time, it does not suffice.
         */
        return FALSE;
    }

    /* by default, the instance is alive. */
    return TRUE;
}

static void
_notify_alive(NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    if (priv->disarmed) {
        /* once disarmed, the alive state is frozen. */
        return;
    }

    if (priv->alive == _is_alive(self))
        return;
    priv->alive = !priv->alive;
    _LOGD("instance is now %s", priv->alive ? "alive" : "dead");
    _notify(self, PROP_ALIVE);
}

gboolean
nm_keep_alive_is_alive(NMKeepAlive *self)
{
    return NM_KEEP_ALIVE_GET_PRIVATE(self)->alive;
}

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

static void
connection_flags_changed(NMSettingsConnection *connection, NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    if (!priv->connection_was_visible
        && NM_FLAGS_HAS(nm_settings_connection_get_flags(priv->connection),
                        NM_SETTINGS_CONNECTION_INT_FLAGS_VISIBLE)) {
        /* the profile was never visible but now it becomes visible.
         * Remember that.
         *
         * Before this happens (that is, if the device was invisible all along),
         * the keep alive instance is considered alive (w.r.t. watching the connection).
         *
         * The reason is to allow a user to manually activate an invisible profile and keep
         * it alive. At least, as long until the user logs out the first time (which is the
         * first time, the profiles changes from visible to invisible).
         *
         * Yes, that is odd. How to improve? */
        priv->connection_was_visible = TRUE;
    }
    _notify_alive(self);
}

static void
_set_settings_connection_watch_visible(NMKeepAlive *         self,
                                       NMSettingsConnection *connection,
                                       gboolean              emit_signal)
{
    NMKeepAlivePrivate *priv                             = NM_KEEP_ALIVE_GET_PRIVATE(self);
    gs_unref_object NMSettingsConnection *old_connection = NULL;

    if (priv->connection == connection)
        return;

    if (priv->connection) {
        g_signal_handlers_disconnect_by_func(priv->connection,
                                             G_CALLBACK(connection_flags_changed),
                                             self);
        old_connection = g_steal_pointer(&priv->connection);
    }

    if (connection && !priv->disarmed) {
        priv->connection = g_object_ref(connection);
        priv->connection_was_visible =
            NM_FLAGS_HAS(nm_settings_connection_get_flags(priv->connection),
                         NM_SETTINGS_CONNECTION_INT_FLAGS_VISIBLE);
        g_signal_connect(priv->connection,
                         NM_SETTINGS_CONNECTION_FLAGS_CHANGED,
                         G_CALLBACK(connection_flags_changed),
                         self);
    }

    if (emit_signal)
        _notify_alive(self);
}

void
nm_keep_alive_set_settings_connection_watch_visible(NMKeepAlive *         self,
                                                    NMSettingsConnection *connection)
{
    _set_settings_connection_watch_visible(self, connection, TRUE);
}

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

static void
get_name_owner_cb(const char *name_owner, GError *error, gpointer user_data)
{
    NMKeepAlive *       self;
    NMKeepAlivePrivate *priv;

    if (!name_owner && g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
        return;

    self = user_data;
    priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    if (name_owner && nm_streq(name_owner, priv->dbus_client)) {
        /* all good, the name is confirmed. */
        return;
    }

    _LOGD("DBus client for keep alive is not on the bus");
    cleanup_dbus_watch(self);
    _notify_alive(self);
}

static gboolean
_is_alive_dbus_client(NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    if (!priv->dbus_client)
        return FALSE;

    if (!priv->dbus_client_confirmed) {
        /* it's unconfirmed that the D-Bus client is really alive.
         * It looks like it is, but as we are claiming that to be
         * the case, issue an async GetNameOwner call to make sure. */
        priv->dbus_client_confirmed           = TRUE;
        priv->dbus_client_confirm_cancellable = g_cancellable_new();

        nm_dbus_connection_call_get_name_owner(priv->dbus_connection,
                                               priv->dbus_client,
                                               -1,
                                               priv->dbus_client_confirm_cancellable,
                                               get_name_owner_cb,
                                               self);
    }
    return TRUE;
}

static void
cleanup_dbus_watch(NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    if (!priv->dbus_client)
        return;

    _LOGD("Cleanup DBus client watch");

    nm_clear_g_cancellable(&priv->dbus_client_confirm_cancellable);
    nm_clear_g_free(&priv->dbus_client);
    if (priv->dbus_connection) {
        g_dbus_connection_signal_unsubscribe(priv->dbus_connection,
                                             nm_steal_int(&priv->subscription_id));
        g_clear_object(&priv->dbus_connection);
    }
}

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)
{
    NMKeepAlive *self = NM_KEEP_ALIVE(user_data);
    const char * old_owner;
    const char * new_owner;

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

    if (!nm_streq0(new_owner, ""))
        return;

    _LOGD("DBus client for keep alive disappeared from bus");
    cleanup_dbus_watch(self);
    _notify_alive(self);
}

void
nm_keep_alive_set_dbus_client_watch(NMKeepAlive *    self,
                                    GDBusConnection *connection,
                                    const char *     client_address)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    if (priv->disarmed)
        return;

    cleanup_dbus_watch(self);

    if (client_address) {
        _LOGD("Registering dbus client watch for keep alive");

        priv->dbus_client           = g_strdup(client_address);
        priv->dbus_client_watching  = TRUE;
        priv->dbus_client_confirmed = FALSE;
        priv->dbus_connection       = g_object_ref(connection);
        priv->subscription_id =
            nm_dbus_connection_signal_subscribe_name_owner_changed(priv->dbus_connection,
                                                                   priv->dbus_client,
                                                                   name_owner_changed_cb,
                                                                   self,
                                                                   NULL);
    } else
        priv->dbus_client_watching = FALSE;

    _notify_alive(self);
}

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

/**
 * nm_keep_alive_arm:
 * @self: the #NMKeepAlive
 *
 * A #NMKeepAlive instance is unarmed by default. That means, it's
 * alive and stays alive until being armed. Arming means, that the conditions
 * start to be actively evaluated, that the alive state may change, and
 * that property changed signals are emitted.
 *
 * The opposite is nm_keep_alive_disarm() which freezes the alive state
 * for good. Once disarmed, the instance cannot be armed again. Arming an
 * instance multiple times has no effect. Arming an already disarmed instance
 * also has no effect. */
void
nm_keep_alive_arm(NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    if (!priv->armed) {
        priv->armed = TRUE;
        _notify_alive(self);
    }
}

/**
 * nm_keep_alive_disarm:
 * @self: the #NMKeepAlive instance
 *
 * Once the instance is disarmed, it will not change its alive state
 * anymore and will not emit anymore property changed signals about
 * alive state changed.
 *
 * As such, it will also free internal resources (since they no longer
 * affect the externally visible state).
 *
 * Once disarmed, the instance is frozen and cannot change anymore.
 */
void
nm_keep_alive_disarm(NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    priv->disarmed = TRUE;

    /* release internal data. */
    _set_settings_connection_watch_visible(self, NULL, FALSE);
    cleanup_dbus_watch(self);
}

/**
 * nm_keep_alive_destroy:
 * @self: (allow-none): the #NMKeepAlive instance to destroy.
 *
 * This does 3 things in one:
 *
 *   - set owner to %NULL
 *   - disarm the instance.
 *   - unref @self.
 */
void
nm_keep_alive_destroy(NMKeepAlive *self)
{
    if (!self)
        return;
    _nm_keep_alive_set_owner(self, NULL);
    nm_keep_alive_disarm(self);
    g_object_unref(self);
}

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

static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
    NMKeepAlive *self = NM_KEEP_ALIVE(object);

    switch (prop_id) {
    case PROP_ALIVE:
        g_value_set_boolean(value, nm_keep_alive_is_alive(self));
        break;
    default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
        break;
    }
}

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

/**
 * nm_keep_alive_get_owner:
 * @self: the #NMKeepAlive
 *
 * Returns: the owner instance associated with this @self. This commonly
 *   is set to be the target instance, which @self guards for being alive.
 *   Returns a gpointer, but of course it's some GObject instance. */
gpointer /* GObject * */
nm_keep_alive_get_owner(NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    nm_assert(!priv->owner || G_IS_OBJECT(priv->owner));

    return priv->owner;
}

/**
 * _nm_keep_alive_set_owner:
 * @self: the #NMKeepAlive
 * @owner: the owner to set or unset.
 *
 * Sets or unsets the owner instance. Think of the owner the target
 * instance that is guarded by @self. It's the responsibility of the
 * owner to set and properly unset this pointer. As the owner also
 * controls the lifetime of the NMKeepAlive instance.
 *
 * This API is not to be called by everybody, but only the owner of
 * @self.
 */
void
_nm_keep_alive_set_owner(NMKeepAlive *self, GObject *owner)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    nm_assert(!owner || G_IS_OBJECT(owner));

    /* it's bad style to reset the owner object. You are supposed to
     * set it once, and clear it once. That's it. */
    nm_assert(!owner || !priv->owner);

    /* optimally, we would take a reference to @owner. But the
     * owner already owns a reference to the keep-alive, so we cannot
     * just own a reference back.
     *
     * We could register a weak-pointer here. But instead, declare that
     * owner is required to set itself as owner when creating the
     * keep-alive instance, and unset itself when it lets go of the
     * keep-alive instance (at latest, when the owner itself gets destroyed).
     */
    priv->owner = owner;
}

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

static void
nm_keep_alive_init(NMKeepAlive *self)
{
    NMKeepAlivePrivate *priv = NM_KEEP_ALIVE_GET_PRIVATE(self);

    priv->alive = TRUE;

    nm_assert(priv->alive == _is_alive(self));
}

NMKeepAlive *
nm_keep_alive_new(void)
{
    return g_object_new(NM_TYPE_KEEP_ALIVE, NULL);
}

static void
dispose(GObject *object)
{
    NMKeepAlive *self = NM_KEEP_ALIVE(object);

    nm_assert(!NM_KEEP_ALIVE_GET_PRIVATE(self)->owner);

    /* disarm also happens to free all resources. */
    nm_keep_alive_disarm(self);
}

static void
nm_keep_alive_class_init(NMKeepAliveClass *keep_alive_class)
{
    GObjectClass *object_class = G_OBJECT_CLASS(keep_alive_class);

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

    obj_properties[PROP_ALIVE] = g_param_spec_string(NM_KEEP_ALIVE_ALIVE,
                                                     "",
                                                     "",
                                                     NULL,
                                                     G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);

    g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
}