NetworkManager/src/core/nm-dbus-object.c

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

#include "src/core/nm-default-daemon.h"

#include "nm-dbus-object.h"

#include "nm-dbus-manager.h"
#include "NetworkManagerUtils.h"

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

enum {
    EXPORTED_CHANGED,

    LAST_SIGNAL,
};

static guint signals[LAST_SIGNAL] = {0};

G_DEFINE_ABSTRACT_TYPE(NMDBusObject, nm_dbus_object, G_TYPE_OBJECT);

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

#define _NMLOG_DOMAIN LOGD_CORE
#define _NMLOG(level, ...) \
    __NMLOG_DEFAULT_WITH_ADDR(level, _NMLOG_DOMAIN, "dbus-object", __VA_ARGS__)

#define _NMLOG2_DOMAIN LOGD_DBUS_PROPS
#define _NMLOG2(level, ...) \
    __NMLOG_DEFAULT_WITH_ADDR(level, _NMLOG2_DOMAIN, "properties-changed", __VA_ARGS__)

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

static void
_emit_exported_changed(NMDBusObject *self)
{
    g_signal_emit(self, signals[EXPORTED_CHANGED], 0);
}

static char *
_create_export_path(NMDBusObjectClass *klass)
{
    nm_assert(NM_IS_DBUS_OBJECT_CLASS(klass));
    nm_assert(klass->export_path.path);

#if NM_MORE_ASSERTS
    {
        const char *p;

        p = strchr(klass->export_path.path, '%');
        if (klass->export_path.int_counter) {
            nm_assert(p);
            nm_assert(p[1] == 'l');
            nm_assert(p[2] == 'l');
            nm_assert(p[3] == 'u');
            nm_assert(p[4] == '\0');
        } else
            nm_assert(!p);
    }
#endif

    if (klass->export_path.int_counter) {
        NM_PRAGMA_WARNING_DISABLE("-Wformat-nonliteral")
        return g_strdup_printf(klass->export_path.path, ++(*klass->export_path.int_counter));
        NM_PRAGMA_WARNING_REENABLE
    }
    return g_strdup(klass->export_path.path);
}

/**
 * nm_dbus_object_export:
 * @self: an #NMDBusObject
 *
 * Exports @self on all active and future D-Bus connections.
 *
 * The path to export @self on is taken from its #NMObjectClass's %export_path
 * member. If the %export_path contains "%u", then it will be replaced with a
 * monotonically increasing integer ID (with each distinct %export_path having
 * its own counter). Otherwise, %export_path will be used literally (implying
 * that @self must be a singleton).
 *
 * Returns: the path @self was exported under
 */
const char *
nm_dbus_object_export(gpointer /* (NMDBusObject *) */ self)
{
    NMDBusObject  *self1      = self;
    static guint64 id_counter = 0;

    g_return_val_if_fail(NM_IS_DBUS_OBJECT(self1), NULL);

    g_return_val_if_fail(!self1->internal.path, self1->internal.path);

    nm_assert(!self1->internal.is_unexporting);

    self1->internal.path = _create_export_path(NM_DBUS_OBJECT_GET_CLASS(self1));

    self1->internal.export_version_id = ++id_counter;

    _LOGT("export: \"%s\"", self1->internal.path);

    _nm_dbus_manager_obj_export(self1);

    _emit_exported_changed(self1);
    return self1->internal.path;
}

/**
 * nm_dbus_object_unexport:
 * @self: an #NMDBusObject
 *
 * Unexports @self on all active D-Bus connections (and prevents it from being
 * auto-exported on future connections).
 */
void
nm_dbus_object_unexport(gpointer /* (NMDBusObject *) */ self)
{
    NMDBusObject *self1 = self;

    g_return_if_fail(NM_IS_DBUS_OBJECT(self1));

    g_return_if_fail(self1->internal.path);

    _LOGT("unexport: \"%s\"", self1->internal.path);

    /* note that we emit the signal *before* actually unexporting the object.
     * The reason is, that listeners want to use this signal to know that
     * the object goes away, and clear their D-Bus path to this object.
     *
     * But this must happen before we actually unregister the object, so
     * that we first emit a D-Bus signal that other objects no longer
     * reference this object, before finally unregistering the object itself.
     *
     * The inconvenient part is, that at this point nm_dbus_object_get_path()
     * still returns the path. So, the callee needs to handle that. Possibly
     * by using "nm_dbus_object_get_path_still_exported()". */
    self1->internal.is_unexporting = TRUE;

    _emit_exported_changed(self1);

    _nm_dbus_manager_obj_unexport(self1);

    nm_clear_g_free(&self1->internal.path);
    self1->internal.export_version_id = 0;

    self1->internal.is_unexporting = FALSE;
}

static gboolean
_unexport_on_idle_cb(gpointer user_data)
{
    gs_unref_object NMDBusObject *self = user_data;

    nm_dbus_object_unexport(self);
    return G_SOURCE_REMOVE;
}

void
nm_dbus_object_unexport_on_idle(gpointer /* (NMDBusObject *) */ self_take)
{
    NMDBusObject *self = g_steal_pointer(&self_take);

    if (!self)
        return;

    g_return_if_fail(NM_IS_DBUS_OBJECT(self));

    g_return_if_fail(self->internal.path);

    /* There is no mechanism to cancel or abort the unexport. It will always
     * gonna happen.
     *
     * However, we register it to block shutdown, so that we ensure that it will happen. */

    nm_shutdown_wait_obj_register_object(self, "unexport-dbus-obj-on-idle");

    /* pass on ownership. */
    nm_g_idle_add(_unexport_on_idle_cb, g_steal_pointer(&self));
}

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

gboolean
_nm_dbus_object_clear_and_unexport(NMDBusObject **location)
{
    NMDBusObject *self;

    g_return_val_if_fail(location, FALSE);

    if (!*location)
        return FALSE;

    self = g_steal_pointer(location);

    g_return_val_if_fail(NM_IS_DBUS_OBJECT(self), FALSE);

    if (self->internal.path)
        nm_dbus_object_unexport(self);

    g_object_unref(self);
    return TRUE;
}

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

void
nm_dbus_object_emit_signal_variant(NMDBusObject                      *self,
                                   const NMDBusInterfaceInfoExtended *interface_info,
                                   const GDBusSignalInfo             *signal_info,
                                   GVariant                          *args)
{
    if (!self->internal.path) {
        nm_g_variant_unref_floating(args);
        return;
    }
    _nm_dbus_manager_obj_emit_signal(self, interface_info, signal_info, args);
}

void
nm_dbus_object_emit_signal(NMDBusObject                      *self,
                           const NMDBusInterfaceInfoExtended *interface_info,
                           const GDBusSignalInfo             *signal_info,
                           const char                        *format,
                           ...)
{
    va_list ap;

    nm_assert(NM_IS_DBUS_OBJECT(self));
    nm_assert(format);

    if (!self->internal.path)
        return;

    va_start(ap, format);
    _nm_dbus_manager_obj_emit_signal(self,
                                     interface_info,
                                     signal_info,
                                     g_variant_new_va(format, NULL, &ap));
    va_end(ap);
}

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

static void
dispatch_properties_changed(GObject *object, guint n_pspecs, GParamSpec **pspecs)
{
    NMDBusObject *self = NM_DBUS_OBJECT(object);

    if (self->internal.path)
        _nm_dbus_manager_obj_notify(self, n_pspecs, (const GParamSpec *const *) pspecs);

    G_OBJECT_CLASS(nm_dbus_object_parent_class)
        ->dispatch_properties_changed(object, n_pspecs, pspecs);
}

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

static void
nm_dbus_object_init(NMDBusObject *self)
{
    c_list_init(&self->internal.objects_lst);
    c_list_init(&self->internal.registration_lst_head);
    self->internal.bus_manager = nm_g_object_ref(nm_dbus_manager_get());
}

static void
constructed(GObject *object)
{
    NMDBusObjectClass *klass;

    G_OBJECT_CLASS(nm_dbus_object_parent_class)->constructed(object);

    klass = NM_DBUS_OBJECT_GET_CLASS(object);

    if (klass->export_on_construction)
        nm_dbus_object_export((NMDBusObject *) object);

    /* NMDBusObject types should be very careful when overwriting notify().
     * It is possible to do, but this is a reminder that it's probably not
     * a good idea.
     *
     * It's not a good idea, because NMDBusObject uses dispatch_properties_changed()
     * to emit signals about a bunch of property changes. So, we want to make
     * use of g_object_freeze_notify() / g_object_thaw_notify() to combine multiple
     * property changes in one signal on D-Bus. Note that notify() is not invoked
     * while the signal is frozen, that means, whatever you do inside notify()
     * will not make it into the same batch of PropertiesChanged signal. That is
     * confusing, and probably not what you want.
     *
     * Simple solution: don't overwrite notify(). */
    nm_assert(!G_OBJECT_CLASS(klass)->notify);
}

static void
dispose(GObject *object)
{
    NMDBusObject *self = NM_DBUS_OBJECT(object);

    /* Objects should have already been unexported by their owner, unless
     * we are quitting, where many objects stick around until exit.
     */
    if (self->internal.path) {
        if (!nm_dbus_manager_is_stopping(nm_dbus_object_get_manager(self)))
            g_warn_if_reached();
        nm_dbus_object_unexport(self);
    }

    G_OBJECT_CLASS(nm_dbus_object_parent_class)->dispose(object);

    g_clear_object(&self->internal.bus_manager);
}

static void
nm_dbus_object_class_init(NMDBusObjectClass *klass)
{
    GObjectClass *object_class = G_OBJECT_CLASS(klass);

    object_class->constructed                 = constructed;
    object_class->dispose                     = dispose;
    object_class->dispatch_properties_changed = dispatch_properties_changed;

    signals[EXPORTED_CHANGED] = g_signal_new(NM_DBUS_OBJECT_EXPORTED_CHANGED,
                                             G_OBJECT_CLASS_TYPE(object_class),
                                             G_SIGNAL_RUN_FIRST,
                                             0,
                                             NULL,
                                             NULL,
                                             g_cclosure_marshal_VOID__VOID,
                                             G_TYPE_NONE,
                                             0);
}