fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2025-12-20 07:00:05 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/src/libnm-client-impl/nm-client.c
Thomas Haller 36f8de25c4
all: fix various "-Wcast-align=strict" warnings 
The warning "-Wcast-align=strict" seems useful and will be enabled
next. Fix places that currently cause the warning by using the
new macro NM_CAST_ALIGN(). This macro also nm_assert()s that the alignment
is correct.
2022-12-09 09:15:56 +01:00

9233 lines
342 KiB
C
Raw Blame History

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2007 - 2008 Novell, Inc.
* Copyright (C) 2007 - 2018 Red Hat, Inc.
*/
#include "libnm-client-impl/nm-default-libnm.h"
#include "nm-client.h"
#include <libudev.h>
#include "libnm-std-aux/c-list-util.h"
#include "libnm-glib-aux/nm-c-list.h"
#include "libnm-glib-aux/nm-dbus-aux.h"
#include "libnm-core-aux-intern/nm-common-macros.h"
#include "nm-access-point.h"
#include "nm-active-connection.h"
#include "nm-checkpoint.h"
#include "libnm-core-intern/nm-core-internal.h"
#include "nm-dbus-helpers.h"
#include "nm-wifi-p2p-peer.h"
#include "nm-device-6lowpan.h"
#include "nm-device-adsl.h"
#include "nm-device-bond.h"
#include "nm-device-bridge.h"
#include "nm-device-bt.h"
#include "nm-device-dummy.h"
#include "nm-device-ethernet.h"
#include "nm-device-generic.h"
#include "nm-device-infiniband.h"
#include "nm-device-ip-tunnel.h"
#include "nm-device-loopback.h"
#include "nm-device-macsec.h"
#include "nm-device-macvlan.h"
#include "nm-device-modem.h"
#include "nm-device-ovs-bridge.h"
#include "nm-device-ovs-interface.h"
#include "nm-device-ovs-port.h"
#include "nm-device-ppp.h"
#include "nm-device-team.h"
#include "nm-device-tun.h"
#include "nm-device-vlan.h"
#include "nm-device-vxlan.h"
#include "nm-device-wifi-p2p.h"
#include "nm-device-wifi.h"
#include "nm-device-wireguard.h"
#include "nm-device-wpan.h"
#include "nm-device-olpc-mesh.h"
#include "nm-dhcp-config.h"
#include "nm-dhcp4-config.h"
#include "nm-dhcp6-config.h"
#include "nm-dns-manager.h"
#include "nm-ip4-config.h"
#include "nm-ip6-config.h"
#include "nm-object-private.h"
#include "nm-remote-connection.h"
#include "nm-utils.h"
#include "nm-vpn-connection.h"
/*****************************************************************************/
NM_CACHED_QUARK_FCN("nm-context-busy-watcher", nm_context_busy_watcher_quark);
static void
_context_busy_watcher_attach_integration_source_cb(gpointer data, GObject *where_the_object_was)
{
nm_g_source_destroy_and_unref(data);
}
void
nm_context_busy_watcher_integrate_source(GMainContext *outer_context,
GMainContext *inner_context,
GObject *context_busy_watcher)
{
GSource *source;
nm_assert(outer_context);
nm_assert(inner_context);
nm_assert(outer_context != inner_context);
nm_assert(G_IS_OBJECT(context_busy_watcher));
source = nm_utils_g_main_context_create_integrate_source(inner_context);
g_source_attach(source, outer_context);
/* The problem is...
*
* NMClient is associated with a GMainContext, just like its underlying GDBusConnection
* also queues signals and callbacks on that main context. During operation, NMClient
* will schedule async operations which will return asynchronously on that GMainContext.
*
* Note that depending on whether NMClient got initialized synchronously or asynchronously,
* it has an internal priv->dbus_context that is different from the outer priv->main_context.
* However, the problem is in both cases.
*
* So, as long as there are pending D-Bus calls, the GMainContext is referenced and kept alive.
* When NMClient gets destroyed, the pending calls get cancelled, but the async callback are still
* scheduled to return.
* That means, the main context stays alive until it gets iterated long enough so that all pending
* operations are completed.
*
* Note that pending operations don't keep NMClient alive, so NMClient can already be gone by
* then, but the user still should iterate the main context long enough to process the (cancelled)
* callbacks... at least, if the user cares about whether the remaining memory and file descriptors
* of the GMainContext can be reclaimed.
*
* In hindsight, maybe pending references should kept NMClient alive. But then NMClient would
* need a special "shutdown()" API that the user must invoke, because unrefing would no longer
* be enough to ensure a shutdown (imagine a situation where NMClient receives a constant flow
* of "CheckPermissions" signals, which keeps retriggering an async request). Anyway, we cannot
* add such a shutdown API now, as it would break client's expectations that they can just unref
* the NMClient to destroy it.
*
* So, we allow NMClient to unref, but the user is advised to keep iterating the main context.
* But for how long? Here comes nm_client_get_context_busy_watcher() into play. The user may
* subscribe a weak pointer to that instance and should keep iterating as long as the object
* exists.
*
* Now, back to synchronous initialization: here we have the internal priv->dbus_context context.
* We also cannot remove that context right away, instead we need to keep it integrated in the
* caller's priv->main_context as long as we have pending calls: that is, as long as the
* context-busy-watcher is alive.
*/
g_object_weak_ref(context_busy_watcher,
_context_busy_watcher_attach_integration_source_cb,
source);
}
/*****************************************************************************/
typedef struct {
/* It is quite wasteful to require 2 pointers per property (of an instance) only to track whether
* the property got changed. But it's convenient! */
CList changed_prop_lst;
GVariant *prop_data_value;
} NMLDBusObjPropData;
typedef struct {
CList iface_lst;
union {
const NMLDBusMetaIface *meta;
NMRefString *name;
} dbus_iface;
CList changed_prop_lst_head;
/* We also keep track of non-well known interfaces. The presence of a D-Bus interface
* is what makes a D-Bus alive or not. As we should track all D-Bus objects, we also
* need to track whether there are any interfaces on it -- even if we otherwise don't
* care about the interface. */
bool dbus_iface_is_wellknown : 1;
/* if TRUE, the interface is about to be removed. */
bool iface_removed : 1;
bool nmobj_checked : 1;
bool nmobj_compatible : 1;
NMLDBusObjPropData prop_datas[];
} NMLDBusObjIfaceData;
/* The dbus_path must be the first element, so when we hash the object by the dbus_path,
* we also can lookup the object by only having a NMRefString at hand
* using nm_pdirect_hash()/nm_pdirect_equal(). */
G_STATIC_ASSERT(G_STRUCT_OFFSET(NMLDBusObject, dbus_path) == 0);
typedef void (*NMLDBusObjWatchNotifyFcn)(NMClient *client, gpointer obj_watcher);
struct _NMLDBusObjWatcher {
NMLDBusObject *dbobj;
struct {
CList watcher_lst;
NMLDBusObjWatchNotifyFcn notify_fcn;
} _priv;
};
typedef struct {
NMLDBusObjWatcher parent;
gpointer user_data;
} NMLDBusObjWatcherWithPtr;
/*****************************************************************************/
NM_GOBJECT_PROPERTIES_DEFINE(NMClient,
PROP_DBUS_CONNECTION,
PROP_DBUS_NAME_OWNER,
PROP_VERSION,
PROP_INSTANCE_FLAGS,
PROP_STATE,
PROP_STARTUP,
PROP_NM_RUNNING,
PROP_NETWORKING_ENABLED,
PROP_WIRELESS_ENABLED,
PROP_WIRELESS_HARDWARE_ENABLED,
PROP_WWAN_ENABLED,
PROP_WWAN_HARDWARE_ENABLED,
PROP_WIMAX_ENABLED,
PROP_WIMAX_HARDWARE_ENABLED,
PROP_RADIO_FLAGS,
PROP_ACTIVE_CONNECTIONS,
PROP_CONNECTIVITY,
PROP_CONNECTIVITY_CHECK_URI,
PROP_CONNECTIVITY_CHECK_AVAILABLE,
PROP_CONNECTIVITY_CHECK_ENABLED,
PROP_PRIMARY_CONNECTION,
PROP_ACTIVATING_CONNECTION,
PROP_DEVICES,
PROP_ALL_DEVICES,
PROP_CONNECTIONS,
PROP_HOSTNAME,
PROP_CAN_MODIFY,
PROP_METERED,
PROP_DNS_MODE,
PROP_DNS_RC_MANAGER,
PROP_DNS_CONFIGURATION,
PROP_CHECKPOINTS,
PROP_CAPABILITIES,
PROP_PERMISSIONS_STATE, );
enum {
DEVICE_ADDED,
DEVICE_REMOVED,
ANY_DEVICE_ADDED,
ANY_DEVICE_REMOVED,
PERMISSION_CHANGED,
CONNECTION_ADDED,
CONNECTION_REMOVED,
ACTIVE_CONNECTION_ADDED,
ACTIVE_CONNECTION_REMOVED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = {0};
enum {
PROPERTY_O_IDX_NM_ACTIVATING_CONNECTION = 0,
PROPERTY_O_IDX_NM_PRIMAY_CONNECTION,
_PROPERTY_O_IDX_NM_NUM,
};
enum {
PROPERTY_AO_IDX_DEVICES = 0,
PROPERTY_AO_IDX_ALL_DEVICES,
PROPERTY_AO_IDX_ACTIVE_CONNECTIONS,
PROPERTY_AO_IDX_CHECKPOINTS,
_PROPERTY_AO_IDX_NM_NUM,
};
typedef struct {
struct udev *udev;
GMainContext *main_context;
GMainContext *dbus_context;
GObject *context_busy_watcher;
GDBusConnection *dbus_connection;
NMLInitData *init_data;
GHashTable *dbus_objects;
CList obj_changed_lst_head;
GCancellable *name_owner_get_cancellable;
GCancellable *get_managed_objects_cancellable;
CList queue_notify_lst_head;
CList notify_event_lst_head;
CList dbus_objects_lst_head_watched_only;
CList dbus_objects_lst_head_on_dbus;
CList dbus_objects_lst_head_with_nmobj_not_ready;
CList dbus_objects_lst_head_with_nmobj_ready;
NMLDBusObject *dbobj_nm;
NMLDBusObject *dbobj_settings;
NMLDBusObject *dbobj_dns_manager;
gsize log_call_counter;
guint8 *permissions;
GCancellable *permissions_cancellable;
char *name_owner;
guint name_owner_changed_id;
guint dbsid_nm_object_manager;
guint dbsid_dbus_properties_properties_changed;
guint dbsid_nm_settings_connection_updated;
guint dbsid_nm_connection_active_state_changed;
guint dbsid_nm_vpn_connection_state_changed;
guint dbsid_nm_check_permissions;
NMClientInstanceFlags instance_flags : 5;
NMTernary permissions_state : 3;
bool instance_flags_constructed : 1;
bool udev_inited : 1;
bool notify_event_lst_changed : 1;
bool check_dbobj_visible_all : 1;
bool nm_running : 1;
struct {
NMLDBusPropertyO property_o[_PROPERTY_O_IDX_NM_NUM];
NMLDBusPropertyAO property_ao[_PROPERTY_AO_IDX_NM_NUM];
char *connectivity_check_uri;
char *version;
guint32 *capabilities_arr;
gsize capabilities_len;
guint32 connectivity;
guint32 state;
guint32 metered;
guint32 radio_flags;
bool connectivity_check_available;
bool connectivity_check_enabled;
bool networking_enabled;
bool startup;
bool wireless_enabled;
bool wireless_hardware_enabled;
bool wwan_enabled;
bool wwan_hardware_enabled;
} nm;
struct {
NMLDBusPropertyAO connections;
char *hostname;
bool can_modify;
} settings;
struct {
GPtrArray *configuration;
char *mode;
char *rc_manager;
} dns_manager;
} NMClientPrivate;
struct _NMClient {
union {
GObject parent;
NMObjectBase obj_base;
};
NMClientPrivate _priv;
};
struct _NMClientClass {
union {
GObjectClass parent;
NMObjectBaseClass obj_base;
};
};
static void nm_client_initable_iface_init(GInitableIface *iface);
static void nm_client_async_initable_iface_init(GAsyncInitableIface *iface);
G_DEFINE_TYPE_WITH_CODE(NMClient,
nm_client,
G_TYPE_OBJECT,
G_IMPLEMENT_INTERFACE(G_TYPE_INITABLE, nm_client_initable_iface_init);
G_IMPLEMENT_INTERFACE(G_TYPE_ASYNC_INITABLE,
nm_client_async_initable_iface_init);)
#define NM_CLIENT_GET_PRIVATE(self) _NM_GET_PRIVATE(self, NMClient, NM_IS_CLIENT)
/*****************************************************************************/
static void _init_start_check_complete(NMClient *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);
static void name_owner_get_call(NMClient *self);
static void _set_nm_running(NMClient *self);
/*****************************************************************************/
static NMRefString *_dbus_path_nm = NULL;
static NMRefString *_dbus_path_settings = NULL;
static NMRefString *_dbus_path_dns_manager = NULL;
/*****************************************************************************/
static NM_UTILS_LOOKUP_STR_DEFINE(
nml_dbus_obj_state_to_string,
NMLDBusObjState,
NM_UTILS_LOOKUP_DEFAULT_WARN("???"),
NM_UTILS_LOOKUP_ITEM(NML_DBUS_OBJ_STATE_UNLINKED, "unlinked"),
NM_UTILS_LOOKUP_ITEM(NML_DBUS_OBJ_STATE_WATCHED_ONLY, "watched-only"),
NM_UTILS_LOOKUP_ITEM(NML_DBUS_OBJ_STATE_ON_DBUS, "on-dbus"),
NM_UTILS_LOOKUP_ITEM(NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY, "not-ready"),
NM_UTILS_LOOKUP_ITEM(NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY, "ready"), );
/*****************************************************************************/
/**
* nm_client_error_quark:
*
* Registers an error quark for #NMClient if necessary.
*
* Returns: the error quark used for #NMClient errors.
**/
NM_CACHED_QUARK_FCN("nm-client-error-quark", nm_client_error_quark);
/*****************************************************************************/
NMLInitData *
nml_init_data_new_sync(GCancellable *cancellable, GMainLoop *main_loop, GError **error_location)
{
NMLInitData *init_data;
init_data = g_slice_new(NMLInitData);
*init_data = (NMLInitData){
.cancellable = nm_g_object_ref(cancellable),
.is_sync = TRUE,
.data.sync =
{
.main_loop = main_loop,
.error_location = error_location,
},
};
return init_data;
}
NMLInitData *
nml_init_data_new_async(GCancellable *cancellable, GTask *task_take)
{
NMLInitData *init_data;
init_data = g_slice_new(NMLInitData);
*init_data = (NMLInitData){
.cancellable = nm_g_object_ref(cancellable),
.is_sync = FALSE,
.data.async =
{
.task = g_steal_pointer(&task_take),
},
};
return init_data;
}
void
nml_init_data_return(NMLInitData *init_data, GError *error_take)
{
nm_assert(init_data);
nm_clear_pointer(&init_data->cancel_on_idle_source, nm_g_source_destroy_and_unref);
nm_clear_g_signal_handler(init_data->cancellable, &init_data->cancelled_id);
if (init_data->is_sync) {
if (error_take)
g_propagate_error(init_data->data.sync.error_location, error_take);
g_main_loop_quit(init_data->data.sync.main_loop);
} else {
if (error_take)
g_task_return_error(init_data->data.async.task, error_take);
else
g_task_return_boolean(init_data->data.async.task, TRUE);
g_object_unref(init_data->data.async.task);
}
nm_g_object_unref(init_data->cancellable);
nm_g_slice_free(init_data);
}
/*****************************************************************************/
GError *
_nm_client_new_error_nm_not_running(void)
{
return g_error_new_literal(NM_CLIENT_ERROR,
NM_CLIENT_ERROR_MANAGER_NOT_RUNNING,
"NetworkManager is not running");
}
GError *
_nm_client_new_error_nm_not_cached(void)
{
return g_error_new_literal(NM_CLIENT_ERROR,
NM_CLIENT_ERROR_FAILED,
"Object is no longer in the client cache");
}
static void
_nm_client_dbus_call_simple_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
GAsyncReadyCallback callback;
gpointer callback_user_data;
gs_unref_object GObject *context_busy_watcher = NULL;
gpointer obfuscated_self_ptr;
gpointer log_call_counter_ptr;
nm_utils_user_data_unpack(user_data,
&callback,
&callback_user_data,
&context_busy_watcher,
&obfuscated_self_ptr,
&log_call_counter_ptr);
NML_DBUS_LOG(_NML_NMCLIENT_LOG_LEVEL_COERCE(NML_DBUS_LOG_LEVEL_TRACE),
"nmclient[" NM_HASH_OBFUSCATE_PTR_FMT "]: call[%" G_GSIZE_FORMAT "] completed",
(guint64) GPOINTER_TO_SIZE(obfuscated_self_ptr),
GPOINTER_TO_SIZE(log_call_counter_ptr));
callback(source, result, callback_user_data);
}
void
_nm_client_dbus_call_simple(NMClient *self,
GCancellable *cancellable,
const char *object_path,
const char *interface_name,
const char *method_name,
GVariant *parameters,
const GVariantType *reply_type,
GDBusCallFlags flags,
int timeout_msec,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;
gs_free char *log_str = NULL;
gsize log_call_counter;
nm_assert(priv->name_owner);
nm_assert(!cancellable || G_IS_CANCELLABLE(cancellable));
nm_assert(callback);
nm_assert(object_path);
nm_assert(interface_name);
nm_assert(method_name);
nm_assert(reply_type);
dbus_context = nm_g_main_context_push_thread_default_if_necessary(priv->dbus_context);
log_call_counter = ++priv->log_call_counter;
NML_NMCLIENT_LOG_T(self,
"call[%" G_GSIZE_FORMAT "] D-Bus method on %s: %s, %s.%s -> %s (%s)",
log_call_counter,
priv->name_owner,
object_path,
interface_name,
method_name,
(const char *) reply_type ?: "???",
parameters ? (log_str = g_variant_print(parameters, TRUE)) : "NULL");
g_dbus_connection_call(priv->dbus_connection,
priv->name_owner,
object_path,
interface_name,
method_name,
parameters,
reply_type,
flags,
timeout_msec,
cancellable,
_nm_client_dbus_call_simple_cb,
nm_utils_user_data_pack(callback,
user_data,
g_object_ref(priv->context_busy_watcher),
GSIZE_TO_POINTER(NM_HASH_OBFUSCATE_PTR(self)),
GSIZE_TO_POINTER(log_call_counter)));
}
void
_nm_client_dbus_call(NMClient *self,
gpointer source_obj,
gpointer source_tag,
GCancellable *cancellable,
GAsyncReadyCallback user_callback,
gpointer user_callback_data,
const char *object_path,
const char *interface_name,
const char *method_name,
GVariant *parameters,
const GVariantType *reply_type,
GDBusCallFlags flags,
int timeout_msec,
GAsyncReadyCallback internal_callback)
{
NMClientPrivate *priv;
gs_unref_object GTask *task = NULL;
nm_assert(!source_obj || G_IS_OBJECT(source_obj));
nm_assert(source_tag);
nm_assert(!cancellable || G_IS_CANCELLABLE(cancellable));
nm_assert(internal_callback);
nm_assert(object_path);
nm_assert(interface_name);
nm_assert(method_name);
nm_assert(reply_type);
task = nm_g_task_new(source_obj, cancellable, source_tag, user_callback, user_callback_data);
if (!self) {
if (parameters)
nm_g_variant_unref_floating(parameters);
g_task_return_error(task, _nm_client_new_error_nm_not_cached());
return;
}
priv = NM_CLIENT_GET_PRIVATE(self);
if (!priv->name_owner) {
if (parameters)
nm_g_variant_unref_floating(parameters);
g_task_return_error(task, _nm_client_new_error_nm_not_running());
return;
}
_nm_client_dbus_call_simple(self,
cancellable,
object_path,
interface_name,
method_name,
parameters,
reply_type,
flags,
timeout_msec,
internal_callback,
g_steal_pointer(&task));
}
GVariant *
_nm_client_dbus_call_sync(NMClient *self,
GCancellable *cancellable,
const char *object_path,
const char *interface_name,
const char *method_name,
GVariant *parameters,
const GVariantType *reply_type,
GDBusCallFlags flags,
int timeout_msec,
gboolean strip_dbus_error,
GError **error)
{
NMClientPrivate *priv;
gs_unref_variant GVariant *ret = NULL;
nm_assert(!cancellable || G_IS_CANCELLABLE(cancellable));
nm_assert(!error || !*error);
nm_assert(object_path);
nm_assert(interface_name);
nm_assert(method_name);
nm_assert(parameters);
nm_assert(reply_type);
if (!self) {
nm_g_variant_unref_floating(parameters);
nm_g_set_error_take_lazy(error, _nm_client_new_error_nm_not_cached());
return NULL;
}
priv = NM_CLIENT_GET_PRIVATE(self);
if (!priv->name_owner) {
nm_g_variant_unref_floating(parameters);
nm_g_set_error_take_lazy(error, _nm_client_new_error_nm_not_running());
return NULL;
}
ret = g_dbus_connection_call_sync(priv->dbus_connection,
priv->name_owner,
object_path,
interface_name,
method_name,
parameters,
reply_type,
flags,
timeout_msec,
cancellable,
error);
if (!ret) {
if (error && strip_dbus_error)
g_dbus_error_strip_remote_error(*error);
return NULL;
}
return g_steal_pointer(&ret);
}
gboolean
_nm_client_dbus_call_sync_void(NMClient *self,
GCancellable *cancellable,
const char *object_path,
const char *interface_name,
const char *method_name,
GVariant *parameters,
GDBusCallFlags flags,
int timeout_msec,
gboolean strip_dbus_error,
GError **error)
{
gs_unref_variant GVariant *ret = NULL;
ret = _nm_client_dbus_call_sync(self,
cancellable,
object_path,
interface_name,
method_name,
parameters,
G_VARIANT_TYPE("()"),
flags,
timeout_msec,
strip_dbus_error,
error);
return !!ret;
}
void
_nm_client_set_property_sync_legacy(NMClient *self,
const char *object_path,
const char *interface_name,
const char *property_name,
const char *format_string,
...)
{
NMClientPrivate *priv;
GVariant *val;
gs_unref_variant GVariant *ret = NULL;
va_list ap;
nm_assert(!self || NM_IS_CLIENT(self));
nm_assert(interface_name);
nm_assert(property_name);
nm_assert(format_string);
if (!self)
return;
priv = NM_CLIENT_GET_PRIVATE(self);
if (!priv->name_owner)
return;
va_start(ap, format_string);
val = g_variant_new_va(format_string, NULL, &ap);
va_end(ap);
nm_assert(val);
/* A synchronous D-Bus call that is not cancellable an ignores the return value.
* This function only exists for backward compatibility. */
ret = g_dbus_connection_call_sync(priv->dbus_connection,
priv->name_owner,
object_path,
DBUS_INTERFACE_PROPERTIES,
"Set",
g_variant_new("(ssv)", interface_name, property_name, val),
NULL,
G_DBUS_CALL_FLAGS_NONE,
2000,
NULL,
NULL);
}
/*****************************************************************************/
#define _assert_main_context_is_current_source(self, x_context) \
G_STMT_START \
{ \
if (NM_MORE_ASSERTS > 0) { \
GSource *_source = g_main_current_source(); \
\
if (_source) { \
NMClientPrivate *_priv = NM_CLIENT_GET_PRIVATE(self); \
\
nm_assert(g_source_get_context(_source) == _priv->x_context); \
nm_assert(nm_g_main_context_can_acquire(_priv->x_context)); \
} \
} \
} \
G_STMT_END
#define _assert_main_context_is_current_thread_default(self, x_context) \
G_STMT_START \
{ \
if (NM_MORE_ASSERTS > 0) { \
NMClientPrivate *_priv = NM_CLIENT_GET_PRIVATE(self); \
\
nm_assert((g_main_context_get_thread_default() ?: g_main_context_default()) \
== _priv->x_context); \
nm_assert(nm_g_main_context_can_acquire(_priv->x_context)); \
} \
} \
G_STMT_END
/*****************************************************************************/
void
_nm_client_queue_notify_object(NMClient *self, gpointer nmobj, const GParamSpec *pspec)
{
NMObjectBase *base;
nm_assert(NM_IS_CLIENT(self));
nm_assert(NM_IS_OBJECT(nmobj) || NM_IS_CLIENT(nmobj));
base = (NMObjectBase *) nmobj;
if (base->is_disposing) {
/* Don't emit property changed signals once the NMClient
* instance is about to shut down. */
nm_assert(nmobj == self);
return;
}
if (c_list_is_empty(&base->queue_notify_lst)) {
c_list_link_tail(&NM_CLIENT_GET_PRIVATE(self)->queue_notify_lst_head,
&base->queue_notify_lst);
g_object_ref(nmobj);
g_object_freeze_notify(nmobj);
}
if (pspec)
g_object_notify_by_pspec(nmobj, (GParamSpec *) pspec);
}
/*****************************************************************************/
gpointer
_nm_client_notify_event_queue(NMClient *self,
int priority,
NMClientNotifyEventCb callback,
gsize event_size)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NMClientNotifyEvent *notify_event;
nm_assert(callback);
nm_assert(event_size > sizeof(NMClientNotifyEvent));
notify_event = g_malloc(event_size);
notify_event->priority = priority;
notify_event->callback = callback;
c_list_link_tail(&priv->notify_event_lst_head, &notify_event->lst);
priv->notify_event_lst_changed = TRUE;
return notify_event;
}
NMClientNotifyEventWithPtr *
_nm_client_notify_event_queue_with_ptr(NMClient *self,
int priority,
NMClientNotifyEventWithPtrCb callback,
gpointer user_data)
{
NMClientNotifyEventWithPtr *notify_event;
notify_event = _nm_client_notify_event_queue(self,
priority,
(NMClientNotifyEventCb) callback,
sizeof(NMClientNotifyEventWithPtr));
notify_event->user_data = user_data;
return notify_event;
}
/*****************************************************************************/
typedef struct {
NMClientNotifyEvent parent;
GObject *source;
NMObject *obj;
guint signal_id;
} NMClientNotifyEventObjAddedRemove;
static void
_nm_client_notify_event_queue_emit_obj_signal_cb(NMClient *self, gpointer notify_event_base)
{
NMClientNotifyEventObjAddedRemove *notify_event = notify_event_base;
NML_NMCLIENT_LOG_T(
self,
"[%s] emit \"%s\" signal for %s",
NM_IS_CLIENT(notify_event->source) ? "nmclient" : _nm_object_get_path(notify_event->source),
g_signal_name(notify_event->signal_id),
_nm_object_get_path(notify_event->obj));
nm_assert(NM_IS_OBJECT(notify_event->source) || NM_IS_CLIENT(notify_event->source));
g_signal_emit(notify_event->source, notify_event->signal_id, 0, notify_event->obj);
g_object_unref(notify_event->obj);
g_object_unref(notify_event->source);
}
void
_nm_client_notify_event_queue_emit_obj_signal(NMClient *self,
GObject *source,
NMObject *nmobj,
gboolean is_added /* or else removed */,
int prio_offset,
guint signal_id)
{
NMClientNotifyEventObjAddedRemove *notify_event;
nm_assert(prio_offset >= 0);
nm_assert(prio_offset < 20);
nm_assert(NM_IS_OBJECT(source) || NM_IS_CLIENT(source));
nm_assert(NM_IS_OBJECT(nmobj));
if (((NMObjectBase *) source)->is_disposing) {
nm_assert(NM_IS_CLIENT(source));
return;
}
notify_event = _nm_client_notify_event_queue(
self,
is_added ? NM_CLIENT_NOTIFY_EVENT_PRIO_AFTER - 20 + prio_offset
: NM_CLIENT_NOTIFY_EVENT_PRIO_BEFORE + 20 - prio_offset,
_nm_client_notify_event_queue_emit_obj_signal_cb,
sizeof(NMClientNotifyEventObjAddedRemove));
notify_event->source = g_object_ref(source);
notify_event->obj = g_object_ref(nmobj);
notify_event->signal_id = signal_id;
}
/*****************************************************************************/
static int
_nm_client_notify_event_cmp(const CList *a, const CList *b, const void *user_data)
{
NM_CMP_DIRECT(c_list_entry(a, NMClientNotifyEvent, lst)->priority,
c_list_entry(b, NMClientNotifyEvent, lst)->priority);
return 0;
}
static void
_nm_client_notify_event_emit_parts(NMClient *self, int max_priority /* included! */)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NMClientNotifyEvent *notify_event;
while (TRUE) {
if (priv->notify_event_lst_changed) {
priv->notify_event_lst_changed = FALSE;
c_list_sort(&priv->notify_event_lst_head, _nm_client_notify_event_cmp, NULL);
}
notify_event = c_list_first_entry(&priv->notify_event_lst_head, NMClientNotifyEvent, lst);
if (!notify_event)
return;
if (notify_event->priority > max_priority)
return;
c_list_unlink_stale(&notify_event->lst);
notify_event->callback(self, notify_event);
g_free(notify_event);
}
}
static void
_nm_client_notify_event_emit(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NMObjectBase *base;
_nm_client_notify_event_emit_parts(self, NM_CLIENT_NOTIFY_EVENT_PRIO_GPROP);
while (
(base = c_list_first_entry(&priv->queue_notify_lst_head, NMObjectBase, queue_notify_lst))) {
c_list_unlink(&base->queue_notify_lst);
g_object_thaw_notify(G_OBJECT(base));
g_object_unref(base);
}
_nm_client_notify_event_emit_parts(self, G_MAXINT);
}
/*****************************************************************************/
GDBusConnection *
_nm_client_get_dbus_connection(NMClient *self)
{
return NM_CLIENT_GET_PRIVATE(self)->dbus_connection;
}
const char *
_nm_client_get_dbus_name_owner(NMClient *self)
{
return NM_CLIENT_GET_PRIVATE(self)->name_owner;
}
GMainContext *
_nm_client_get_context_main(NMClient *self)
{
return NM_CLIENT_GET_PRIVATE(self)->main_context;
}
GMainContext *
_nm_client_get_context_dbus(NMClient *self)
{
return NM_CLIENT_GET_PRIVATE(self)->dbus_context;
}
/**
* nm_client_get_main_context:
* @self: the #NMClient instance
*
* The #NMClient instance is permanently associated with the current
* thread default #GMainContext, referenced the time when the instance
* was created. To receive events, the user must iterate this context
* and can use it to synchronize access to the client.
*
* Note that even after #NMClient instance got destroyed, there might
* still be pending sources registered in the context. That means, to fully
* clean up, the user must continue iterating the context as long as
* the nm_client_get_context_busy_watcher() object is alive.
*
* Returns: (transfer none): the #GMainContext of the client.
*
* Since: 1.22
*/
GMainContext *
nm_client_get_main_context(NMClient *self)
{
g_return_val_if_fail(NM_IS_CLIENT(self), NULL);
return _nm_client_get_context_main(self);
}
/**
* nm_client_get_context_busy_watcher:
* @self: the NMClient instance.
*
* Returns: (transfer none): a GObject that stays alive as long as there are pending
* D-Bus operations.
*
* NMClient will schedule asynchronous D-Bus requests which will complete on
* the GMainContext associated with the instance. When destroying the NMClient
* instance, those requests are cancelled right away, however their pending requests are
* still outstanding and queued in the GMainContext. These outstanding callbacks
* keep the GMainContext alive. In order to fully release all resources,
* the user must keep iterating the main context until all these callbacks
* are handled. Of course, at this point no more actual callbacks will be invoked
* for the user, those are all cancelled internally.
*
* This just leaves one problem: how long does the user need to keep the
* GMainContext running to ensure everything is cleaned up? The answer is
* this GObject. Subscribe a weak reference to the returned object and keep
* iterating the main context until the object got unreferenced.
*
* Note that after the NMClient instance gets destroyed, all outstanding operations
* will be cancelled right away. That means, the user needs to iterate the #GMainContext
* a bit longer, but it is guaranteed that the cleanup happens soon after.
*
* The way of using the context-busy-watch, is by registering a weak pointer to
* see when it gets destroyed. That means, user code should not take additional
* references on this object to not keep it alive longer.
*
* If you plan to exit the program after releasing the NMClient instance
* you may not need to worry about these "leaks". Also, if you anyway plan to continue
* iterating the #GMainContext afterwards, then you don't need to care when exactly
* NMClient is gone completely.
*
* Since: 1.22
*/
GObject *
nm_client_get_context_busy_watcher(NMClient *self)
{
GObject *w;
g_return_val_if_fail(NM_IS_CLIENT(self), NULL);
w = NM_CLIENT_GET_PRIVATE(self)->context_busy_watcher;
return g_object_get_qdata(w, nm_context_busy_watcher_quark()) ?: w;
}
struct udev *
_nm_client_get_udev(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
if (G_UNLIKELY(!priv->udev_inited)) {
priv->udev_inited = TRUE;
/* for testing, we don't want to use udev in libnm. */
if (!nm_streq0(g_getenv("LIBNM_USE_NO_UDEV"), "1"))
priv->udev = udev_new();
}
return priv->udev;
}
/*****************************************************************************/
static void
_ASSERT_dbobj(NMLDBusObject *dbobj, NMClient *self)
{
#if NM_MORE_ASSERTS > 5
nm_assert(NM_IS_CLIENT(self));
nm_assert(NML_IS_DBUS_OBJECT(dbobj));
nm_assert(dbobj == g_hash_table_lookup(NM_CLIENT_GET_PRIVATE(self)->dbus_objects, dbobj));
#endif
}
static NMLDBusObject *
nml_dbus_object_new(NMRefString *dbus_path_take)
{
NMLDBusObject *dbobj;
nm_assert(NM_IS_REF_STRING(dbus_path_take));
dbobj = g_slice_new(NMLDBusObject);
*dbobj = (NMLDBusObject){
.dbus_path = g_steal_pointer(&dbus_path_take),
.ref_count = 1,
.dbus_objects_lst = C_LIST_INIT(dbobj->dbus_objects_lst),
.iface_lst_head = C_LIST_INIT(dbobj->iface_lst_head),
.watcher_lst_head = C_LIST_INIT(dbobj->watcher_lst_head),
.obj_changed_lst = C_LIST_INIT(dbobj->obj_changed_lst),
.obj_state = NML_DBUS_OBJ_STATE_UNLINKED,
};
return dbobj;
}
NMLDBusObject *
nml_dbus_object_ref(NMLDBusObject *dbobj)
{
nm_assert(dbobj);
nm_assert(dbobj->ref_count > 0);
dbobj->ref_count++;
return dbobj;
}
void
nml_dbus_object_unref(NMLDBusObject *dbobj)
{
nm_assert(dbobj);
nm_assert(dbobj->ref_count > 0);
if (--dbobj->ref_count > 0)
return;
nm_assert(c_list_is_empty(&dbobj->obj_changed_lst));
nm_assert(c_list_is_empty(&dbobj->iface_lst_head));
nm_assert(c_list_is_empty(&dbobj->watcher_lst_head));
nm_assert(!dbobj->nmobj);
nm_ref_string_unref(dbobj->dbus_path);
nm_g_slice_free(dbobj);
}
static NMLDBusObjIfaceData *
nml_dbus_object_iface_data_get(NMLDBusObject *dbobj,
const char *dbus_iface_name,
gboolean allow_create)
{
const NMLDBusMetaIface *meta_iface;
NMLDBusObjIfaceData *db_iface_data;
NMLDBusObjPropData *db_prop_data;
guint count = 0;
guint i;
nm_assert(NML_IS_DBUS_OBJECT(dbobj));
nm_assert(dbus_iface_name);
#if NM_MORE_ASSERTS > 10
{
gboolean expect_well_known = TRUE;
/* all well-known interfaces must come first in the list. */
c_list_for_each_entry (db_iface_data, &dbobj->iface_lst_head, iface_lst) {
if (db_iface_data->dbus_iface_is_wellknown == expect_well_known)
continue;
nm_assert(expect_well_known);
expect_well_known = FALSE;
}
}
#endif
meta_iface = nml_dbus_meta_iface_get(dbus_iface_name);
if (meta_iface) {
c_list_for_each_entry (db_iface_data, &dbobj->iface_lst_head, iface_lst) {
if (!db_iface_data->dbus_iface_is_wellknown)
break;
if (db_iface_data->iface_removed)
continue;
if (db_iface_data->dbus_iface.meta == meta_iface)
return db_iface_data;
count++;
}
} else {
c_list_for_each_entry_prev (db_iface_data, &dbobj->iface_lst_head, iface_lst) {
if (db_iface_data->dbus_iface_is_wellknown)
break;
if (db_iface_data->iface_removed)
continue;
if (nm_streq(db_iface_data->dbus_iface.name->str, dbus_iface_name))
return db_iface_data;
count++;
}
}
if (!allow_create)
return NULL;
if (count > 20) {
/* We track the list of interfaces that an object has in a linked list.
* That is efficient and convenient, if we assume that each object only has a small
* number of interfaces (which very much should be the case). Here, something is very
* odd, maybe there is a bug or the server side is misbehaving. Anyway, error out. */
return NULL;
}
db_iface_data = g_malloc(
G_STRUCT_OFFSET(NMLDBusObjIfaceData, prop_datas)
+ (meta_iface ? (sizeof(NMLDBusObjPropData) * meta_iface->n_dbus_properties) : 0u));
if (meta_iface) {
*db_iface_data = (NMLDBusObjIfaceData){
.dbus_iface.meta = meta_iface,
.dbus_iface_is_wellknown = TRUE,
.changed_prop_lst_head = C_LIST_INIT(db_iface_data->changed_prop_lst_head),
.iface_removed = FALSE,
};
db_prop_data = &db_iface_data->prop_datas[0];
for (i = 0; i < meta_iface->n_dbus_properties; i++, db_prop_data++) {
*db_prop_data = (NMLDBusObjPropData){
.prop_data_value = NULL,
.changed_prop_lst = C_LIST_INIT(db_prop_data->changed_prop_lst),
};
}
c_list_link_front(&dbobj->iface_lst_head, &db_iface_data->iface_lst);
} else {
/* Intentionally don't initialize the other fields. We are not supposed
* to touch them, and a valgrind warning would be preferable. */
db_iface_data->dbus_iface.name = nm_ref_string_new(dbus_iface_name);
db_iface_data->dbus_iface_is_wellknown = FALSE;
db_iface_data->iface_removed = FALSE;
c_list_link_tail(&dbobj->iface_lst_head, &db_iface_data->iface_lst);
}
return db_iface_data;
}
static void
nml_dbus_obj_iface_data_destroy(NMLDBusObjIfaceData *db_iface_data)
{
guint i;
nm_assert(db_iface_data);
nm_assert(c_list_is_empty(&db_iface_data->iface_lst));
if (db_iface_data->dbus_iface_is_wellknown) {
for (i = 0; i < db_iface_data->dbus_iface.meta->n_dbus_properties; i++)
nm_g_variant_unref(db_iface_data->prop_datas[i].prop_data_value);
} else
nm_ref_string_unref(db_iface_data->dbus_iface.name);
g_free(db_iface_data);
}
gpointer
nml_dbus_object_get_property_location(NMLDBusObject *dbobj,
const NMLDBusMetaIface *meta_iface,
const NMLDBusMetaProperty *meta_property)
{
char *target_c;
target_c = ((gpointer) dbobj->nmobj);
if (meta_iface->base_struct_offset > 0)
target_c = *NM_CAST_ALIGN(gpointer, &target_c[meta_iface->base_struct_offset]);
return &target_c[meta_property->prop_struct_offset];
}
static void
nml_dbus_object_set_obj_state(NMLDBusObject *dbobj, NMLDBusObjState obj_state, NMClient *self)
{
NMClientPrivate *priv;
nm_assert(NM_IS_CLIENT(self));
nm_assert(NML_IS_DBUS_OBJECT(dbobj));
#if NM_MORE_ASSERTS > 10
priv = NM_CLIENT_GET_PRIVATE(self);
switch (dbobj->obj_state) {
case NML_DBUS_OBJ_STATE_UNLINKED:
nm_assert(c_list_is_empty(&dbobj->dbus_objects_lst));
break;
case NML_DBUS_OBJ_STATE_WATCHED_ONLY:
nm_assert(
c_list_contains(&priv->dbus_objects_lst_head_watched_only, &dbobj->dbus_objects_lst));
break;
case NML_DBUS_OBJ_STATE_ON_DBUS:
nm_assert(c_list_contains(&priv->dbus_objects_lst_head_on_dbus, &dbobj->dbus_objects_lst));
break;
case NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY:
nm_assert(c_list_contains(&priv->dbus_objects_lst_head_with_nmobj_not_ready,
&dbobj->dbus_objects_lst));
break;
case NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY:
nm_assert(c_list_contains(&priv->dbus_objects_lst_head_with_nmobj_ready,
&dbobj->dbus_objects_lst));
break;
}
#endif
if (dbobj->obj_state == obj_state)
return;
NML_NMCLIENT_LOG_T(self,
"[%s]: set D-Bus object state %s",
dbobj->dbus_path->str,
nml_dbus_obj_state_to_string(obj_state));
priv = NM_CLIENT_GET_PRIVATE(self);
dbobj->obj_state = obj_state;
switch (obj_state) {
case NML_DBUS_OBJ_STATE_UNLINKED:
c_list_unlink(&dbobj->dbus_objects_lst);
c_list_unlink(&dbobj->obj_changed_lst);
dbobj->obj_changed_type = NML_DBUS_OBJ_CHANGED_TYPE_NONE;
break;
case NML_DBUS_OBJ_STATE_WATCHED_ONLY:
nm_c_list_move_tail(&priv->dbus_objects_lst_head_watched_only, &dbobj->dbus_objects_lst);
break;
case NML_DBUS_OBJ_STATE_ON_DBUS:
nm_c_list_move_tail(&priv->dbus_objects_lst_head_on_dbus, &dbobj->dbus_objects_lst);
break;
case NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY:
nm_c_list_move_tail(&priv->dbus_objects_lst_head_with_nmobj_not_ready,
&dbobj->dbus_objects_lst);
break;
case NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY:
nm_c_list_move_tail(&priv->dbus_objects_lst_head_with_nmobj_ready,
&dbobj->dbus_objects_lst);
break;
default:
nm_assert_not_reached();
}
}
/*****************************************************************************/
static void
nml_dbus_object_obj_changed_link(NMClient *self,
NMLDBusObject *dbobj,
NMLDBusObjChangedType changed_type)
{
nm_assert(NM_IS_CLIENT(self));
nm_assert(NML_IS_DBUS_OBJECT(dbobj));
nm_assert(changed_type != NML_DBUS_OBJ_CHANGED_TYPE_NONE);
/* Links @dbobj in the "obj_changed_lst", with the new "changed_type". */
if (!NM_FLAGS_ALL((NMLDBusObjChangedType) dbobj->obj_changed_type, changed_type))
NML_NMCLIENT_LOG_T(self,
"[%s]: changed-type 0x%02x linked",
dbobj->dbus_path->str,
(guint) changed_type);
if (dbobj->obj_changed_type == NML_DBUS_OBJ_CHANGED_TYPE_NONE) {
NMClientPrivate *priv;
/* We set the changed-type flag. Need to queue the object in the
* changed list. */
nm_assert(c_list_is_empty(&dbobj->obj_changed_lst));
priv = NM_CLIENT_GET_PRIVATE(self);
c_list_link_tail(&priv->obj_changed_lst_head, &dbobj->obj_changed_lst);
} else {
/* The object has changes flags and must be linked already. Note that
* this may be priv->obj_changed_lst_head, or a temporary list on the
* stack.
*
* This dance with the temporary list is done to ensure we can enqueue
* objects while we process the changes. */
nm_assert(!c_list_is_empty(&dbobj->obj_changed_lst));
}
dbobj->obj_changed_type |= changed_type;
nm_assert(NM_FLAGS_ALL(dbobj->obj_changed_type, changed_type));
}
static NMLDBusObjChangedType
nml_dbus_object_obj_changed_consume(NMClient *self,
NMLDBusObject *dbobj,
NMLDBusObjChangedType changed_type)
{
NMClientPrivate *priv;
NMLDBusObjChangedType changed_type_res;
/* We have @dbobj which has some "obj_changed_type" set (consequently,
* it's linked in the "obj_changed_lst"). Here we consume the @changed_type,
* meaning, to clear those flags from "obj_change_type" (and return
* the flags that were cleared/present or NONE, if the current object
* doesn't have these changed-types. */
nm_assert(NM_IS_CLIENT(self));
nm_assert(NML_IS_DBUS_OBJECT(dbobj));
nm_assert(changed_type != NML_DBUS_OBJ_CHANGED_TYPE_NONE);
nm_assert(dbobj->obj_changed_type != NML_DBUS_OBJ_CHANGED_TYPE_NONE);
nm_assert(!c_list_is_empty(&dbobj->obj_changed_lst));
changed_type_res = dbobj->obj_changed_type & changed_type;
dbobj->obj_changed_type &= ~changed_type;
if (dbobj->obj_changed_type == NML_DBUS_OBJ_CHANGED_TYPE_NONE) {
/* No other "obj_change_type" left. Unlink the object from the
* "changed_type_list". */
c_list_unlink(&dbobj->obj_changed_lst);
nm_assert(changed_type_res != NML_DBUS_OBJ_CHANGED_TYPE_NONE);
NML_NMCLIENT_LOG_T(self,
"[%s]: changed-type 0x%02x consumed",
dbobj->dbus_path->str,
(guint) changed_type_res);
return changed_type_res;
}
priv = NM_CLIENT_GET_PRIVATE(self);
/* Actually, at this point, @dbobj is not linked in priv->obj_changed_lst_head,
* instead, it's linked on a temporary list. As we still have changes left after
* consuming "changed_type", we move it to priv->obj_changed_lst_head. */
nm_assert(!c_list_contains(&priv->obj_changed_lst_head, &dbobj->obj_changed_lst));
nm_c_list_move_tail(&priv->obj_changed_lst_head, &dbobj->obj_changed_lst);
NML_NMCLIENT_LOG_T(self,
"[%s]: changed-type 0x%02x consumed (still has 0x%02x)",
dbobj->dbus_path->str,
(guint) changed_type_res,
(guint) dbobj->obj_changed_type);
return changed_type_res;
}
static gboolean
nml_dbus_object_obj_changed_any_linked(NMClient *self, NMLDBusObjChangedType changed_type)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NMLDBusObject *dbobj;
nm_assert(changed_type != NML_DBUS_OBJ_CHANGED_TYPE_NONE);
c_list_for_each_entry (dbobj, &priv->obj_changed_lst_head, obj_changed_lst) {
nm_assert(dbobj->obj_changed_type != NML_DBUS_OBJ_CHANGED_TYPE_NONE);
if (NM_FLAGS_ANY(dbobj->obj_changed_type, changed_type))
return TRUE;
}
return FALSE;
}
/*****************************************************************************/
static void
_dbobjs_notify_watchers_for_dbobj(NMClient *self, NMLDBusObject *dbobj)
{
NMLDBusObjWatcher *obj_watcher;
NMLDBusObjWatcher *obj_watcher_safe;
c_list_for_each_entry_safe (obj_watcher,
obj_watcher_safe,
&dbobj->watcher_lst_head,
_priv.watcher_lst)
obj_watcher->_priv.notify_fcn(self, obj_watcher);
}
static gboolean
_dbobjs_check_dbobj_ready(NMClient *self, NMLDBusObject *dbobj)
{
nm_assert(NM_IS_CLIENT(self));
nm_assert(NML_IS_DBUS_OBJECT(dbobj));
nm_assert(G_IS_OBJECT(dbobj->nmobj));
nm_assert(NM_IS_OBJECT(dbobj->nmobj) || NM_IS_CLIENT(dbobj->nmobj));
nm_assert(NM_IN_SET((NMLDBusObjState) dbobj->obj_state,
NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY,
NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY));
if (G_LIKELY(dbobj->obj_state == NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY))
return TRUE;
if (!NM_OBJECT_GET_CLASS(dbobj->nmobj)->is_ready(NM_OBJECT(dbobj->nmobj)))
return FALSE;
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY, self);
nml_dbus_object_obj_changed_link(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
_dbobjs_notify_watchers_for_dbobj(self, dbobj);
return TRUE;
}
void
_nm_client_notify_object_changed(NMClient *self, NMLDBusObject *dbobj)
{
nml_dbus_object_obj_changed_link(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
_dbobjs_notify_watchers_for_dbobj(self, dbobj);
}
/*****************************************************************************/
static NMLDBusObject *
_dbobjs_dbobj_get_r(NMClient *self, NMRefString *dbus_path_r)
{
nm_assert(NM_IS_REF_STRING(dbus_path_r));
return g_hash_table_lookup(NM_CLIENT_GET_PRIVATE(self)->dbus_objects, &dbus_path_r);
}
static NMLDBusObject *
_dbobjs_dbobj_get_s(NMClient *self, const char *dbus_path)
{
nm_auto_ref_string NMRefString *dbus_path_r = NULL;
nm_assert(dbus_path);
dbus_path_r = nm_ref_string_new(dbus_path);
return _dbobjs_dbobj_get_r(self, dbus_path_r);
}
static NMLDBusObject *
_dbobjs_dbobj_create(NMClient *self, NMRefString *dbus_path_take)
{
nm_auto_ref_string NMRefString *dbus_path = g_steal_pointer(&dbus_path_take);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NMLDBusObject *dbobj;
nm_assert(!_dbobjs_dbobj_get_r(self, dbus_path));
dbobj = nml_dbus_object_new(g_steal_pointer(&dbus_path));
if (!g_hash_table_add(priv->dbus_objects, dbobj))
nm_assert_not_reached();
return dbobj;
}
static NMLDBusObject *
_dbobjs_dbobj_get_or_create(NMClient *self, NMRefString *dbus_path_take)
{
nm_auto_ref_string NMRefString *dbus_path = g_steal_pointer(&dbus_path_take);
NMLDBusObject *dbobj;
dbobj = _dbobjs_dbobj_get_r(self, dbus_path);
if (dbobj)
return dbobj;
return _dbobjs_dbobj_create(self, g_steal_pointer(&dbus_path));
}
static NMLDBusObject *
_dbobjs_get_nmobj(NMClient *self, const char *dbus_path, GType gtype)
{
NMLDBusObject *dbobj;
nm_assert(gtype == G_TYPE_NONE || g_type_is_a(gtype, NM_TYPE_OBJECT));
dbobj = _dbobjs_dbobj_get_s(self, dbus_path);
if (!dbobj)
return NULL;
if (!dbobj->nmobj)
return NULL;
if (gtype != G_TYPE_NONE && !g_type_is_a(G_OBJECT_TYPE(dbobj->nmobj), gtype))
return NULL;
return dbobj;
}
static gpointer
_dbobjs_get_nmobj_unpack_visible(NMClient *self, const char *dbus_path, GType gtype)
{
NMLDBusObject *dbobj;
dbobj = _dbobjs_get_nmobj(self, dbus_path, gtype);
if (!dbobj)
return NULL;
if (dbobj->obj_state != NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY)
return NULL;
return dbobj->nmobj;
}
/*****************************************************************************/
static gpointer
_dbobjs_obj_watcher_register_o(NMClient *self,
NMLDBusObject *dbobj,
NMLDBusObjWatchNotifyFcn notify_fcn,
gsize struct_size)
{
NMLDBusObjWatcher *obj_watcher;
nm_assert(NM_IS_CLIENT(self));
_ASSERT_dbobj(dbobj, self);
nm_assert(notify_fcn);
nm_assert(struct_size > sizeof(NMLDBusObjWatcher));
obj_watcher = g_malloc(struct_size);
obj_watcher->dbobj = dbobj;
obj_watcher->_priv.notify_fcn = notify_fcn;
/* we must enqueue the item in the front of the list. That is, because while
* invoking notify_fcn(), we iterate the watchers front-to-end. As we want to
* allow the callee to register new watches and unregister itself, this is
* the right way to do it. */
c_list_link_front(&dbobj->watcher_lst_head, &obj_watcher->_priv.watcher_lst);
return obj_watcher;
}
static gpointer
_dbobjs_obj_watcher_register_r(NMClient *self,
NMRefString *dbus_path_take,
NMLDBusObjWatchNotifyFcn notify_fcn,
gsize struct_size)
{
nm_auto_ref_string NMRefString *dbus_path = g_steal_pointer(&dbus_path_take);
NMLDBusObject *dbobj;
nm_assert(NM_IS_CLIENT(self));
nm_assert(notify_fcn);
dbobj = _dbobjs_dbobj_get_or_create(self, g_steal_pointer(&dbus_path));
if (dbobj->obj_state == NML_DBUS_OBJ_STATE_UNLINKED)
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_WATCHED_ONLY, self);
return _dbobjs_obj_watcher_register_o(self, dbobj, notify_fcn, struct_size);
}
static void
_dbobjs_obj_watcher_unregister(NMClient *self, gpointer obj_watcher_base)
{
NMLDBusObjWatcher *obj_watcher = obj_watcher_base;
NMLDBusObject *dbobj;
nm_assert(NM_IS_CLIENT(self));
nm_assert(obj_watcher);
nm_assert(NML_IS_DBUS_OBJECT(obj_watcher->dbobj));
nm_assert(g_hash_table_lookup(NM_CLIENT_GET_PRIVATE(self)->dbus_objects, obj_watcher->dbobj)
== obj_watcher->dbobj);
nm_assert(
c_list_contains(&obj_watcher->dbobj->watcher_lst_head, &obj_watcher->_priv.watcher_lst));
c_list_unlink(&obj_watcher->_priv.watcher_lst);
dbobj = obj_watcher->dbobj;
g_free(obj_watcher);
if (c_list_is_empty(&dbobj->iface_lst_head) && c_list_is_empty(&dbobj->watcher_lst_head)) {
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NML_NMCLIENT_LOG_T(self, "[%s]: drop D-Bus watcher", dbobj->dbus_path->str);
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_UNLINKED, self);
if (!g_hash_table_steal(priv->dbus_objects, dbobj))
nm_assert_not_reached();
nml_dbus_object_unref(dbobj);
}
}
/*****************************************************************************/
typedef struct {
NMLDBusObjWatcher parent;
NMLDBusPropertyO *pr_o;
} PropertyOData;
gpointer
nml_dbus_property_o_get_obj(NMLDBusPropertyO *pr_o)
{
nm_assert(!pr_o->nmobj || nml_dbus_property_o_is_ready(pr_o));
return pr_o->nmobj;
}
gboolean
nml_dbus_property_o_is_ready(const NMLDBusPropertyO *pr_o)
{
return pr_o->is_ready || !pr_o->owner_dbobj;
}
gboolean
nml_dbus_property_o_is_ready_fully(const NMLDBusPropertyO *pr_o)
{
return !pr_o->owner_dbobj || !pr_o->obj_watcher || pr_o->nmobj;
}
static void
nml_dbus_property_o_notify_changed(NMLDBusPropertyO *pr_o, NMClient *self)
{
const NMLDBusPropertVTableO *vtable;
GObject *nmobj = NULL;
gboolean is_ready = TRUE;
gboolean changed_ready;
GType gtype;
nm_assert(pr_o);
nm_assert(NM_IS_CLIENT(self));
if (!pr_o->owner_dbobj)
return;
if (!pr_o->is_changed) {
if (pr_o->is_ready)
return;
goto done;
}
pr_o->is_changed = FALSE;
if (!pr_o->obj_watcher)
goto done;
if (!pr_o->obj_watcher->dbobj->nmobj) {
if (pr_o->obj_watcher->dbobj->obj_state >= NML_DBUS_OBJ_STATE_ON_DBUS) {
NML_NMCLIENT_LOG_W(
self,
"[%s]: property %s references %s but object is not created",
pr_o->owner_dbobj->dbus_path->str,
pr_o->meta_iface->dbus_properties[pr_o->dbus_property_idx].dbus_property_name,
pr_o->obj_watcher->dbobj->dbus_path->str);
} else {
NML_NMCLIENT_LOG_E(
self,
"[%s]: property %s references %s but object is not present on D-Bus",
pr_o->owner_dbobj->dbus_path->str,
pr_o->meta_iface->dbus_properties[pr_o->dbus_property_idx].dbus_property_name,
pr_o->obj_watcher->dbobj->dbus_path->str);
}
goto done;
}
vtable = pr_o->meta_iface->dbus_properties[pr_o->dbus_property_idx].extra.property_vtable_o;
gtype = vtable->get_o_type_fcn();
if (!g_type_is_a(G_OBJECT_TYPE(pr_o->obj_watcher->dbobj->nmobj), gtype)) {
NML_NMCLIENT_LOG_E(
self,
"[%s]: property %s references %s with unexpected GObject type %s instead of %s",
pr_o->owner_dbobj->dbus_path->str,
pr_o->meta_iface->dbus_properties[pr_o->dbus_property_idx].dbus_property_name,
pr_o->obj_watcher->dbobj->dbus_path->str,
G_OBJECT_TYPE_NAME(pr_o->obj_watcher->dbobj->nmobj),
g_type_name(gtype));
goto done;
}
if (pr_o->obj_watcher->dbobj == pr_o->owner_dbobj) {
NML_NMCLIENT_LOG_W(
self,
"[%s]: property %s references itself",
pr_o->owner_dbobj->dbus_path->str,
pr_o->meta_iface->dbus_properties[pr_o->dbus_property_idx].dbus_property_name);
nmobj = pr_o->owner_dbobj->nmobj;
goto done;
}
pr_o->block_is_changed = TRUE;
is_ready = _dbobjs_check_dbobj_ready(self, pr_o->obj_watcher->dbobj);
pr_o->block_is_changed = FALSE;
if (!is_ready) {
is_ready = vtable->is_always_ready;
goto done;
}
nmobj = pr_o->obj_watcher->dbobj->nmobj;
done:
changed_ready = FALSE;
if (!pr_o->is_ready && is_ready) {
pr_o->is_ready = TRUE;
changed_ready = TRUE;
}
if (pr_o->nmobj != nmobj) {
pr_o->nmobj = nmobj;
_nm_client_queue_notify_object(
self,
pr_o->owner_dbobj->nmobj,
pr_o->meta_iface->obj_properties
[pr_o->meta_iface->dbus_properties[pr_o->dbus_property_idx].obj_properties_idx]);
}
if (changed_ready && pr_o->owner_dbobj->obj_state == NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY)
nml_dbus_object_obj_changed_link(self, pr_o->owner_dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
}
void
nml_dbus_property_o_notify_changed_many(NMLDBusPropertyO *ptr, guint len, NMClient *self)
{
while (len-- > 0)
nml_dbus_property_o_notify_changed(ptr++, self);
}
static void
nml_dbus_property_o_notify_watch_cb(NMClient *self, gpointer obj_watcher)
{
PropertyOData *pr_o_data = obj_watcher;
NMLDBusPropertyO *pr_o = pr_o_data->pr_o;
nm_assert(pr_o->obj_watcher == obj_watcher);
if (!pr_o->block_is_changed && !pr_o->is_changed) {
pr_o->is_changed = TRUE;
nml_dbus_object_obj_changed_link(self, pr_o->owner_dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
}
}
static NMLDBusNotifyUpdatePropFlags
nml_dbus_property_o_notify(NMClient *self,
NMLDBusPropertyO *pr_o,
NMLDBusObject *dbobj,
const NMLDBusMetaIface *meta_iface,
guint dbus_property_idx,
GVariant *value)
{
const char *dbus_path = NULL;
gboolean changed = FALSE;
if (!pr_o->owner_dbobj) {
nm_assert(!pr_o->meta_iface);
nm_assert(pr_o->dbus_property_idx == 0);
nm_assert(!pr_o->is_ready);
pr_o->owner_dbobj = dbobj;
pr_o->meta_iface = meta_iface;
pr_o->dbus_property_idx = dbus_property_idx;
} else {
nm_assert(pr_o->owner_dbobj == dbobj);
nm_assert(pr_o->meta_iface == meta_iface);
nm_assert(pr_o->dbus_property_idx == dbus_property_idx);
}
if (value)
dbus_path = nm_dbus_path_not_empty(g_variant_get_string(value, NULL));
if (pr_o->obj_watcher
&& (!dbus_path || !nm_streq(dbus_path, pr_o->obj_watcher->dbobj->dbus_path->str))) {
_dbobjs_obj_watcher_unregister(self, g_steal_pointer(&pr_o->obj_watcher));
changed = TRUE;
}
if (!pr_o->obj_watcher && dbus_path) {
pr_o->obj_watcher = _dbobjs_obj_watcher_register_r(self,
nm_ref_string_new(dbus_path),
nml_dbus_property_o_notify_watch_cb,
sizeof(PropertyOData));
((PropertyOData *) pr_o->obj_watcher)->pr_o = pr_o;
changed = TRUE;
}
if (changed && !pr_o->is_changed) {
pr_o->is_changed = TRUE;
nml_dbus_object_obj_changed_link(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
}
return NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NONE;
}
void
nml_dbus_property_o_clear(NMLDBusPropertyO *pr_o, NMClient *self)
{
if (pr_o->obj_watcher) {
nm_assert(NM_IS_CLIENT(self));
_dbobjs_obj_watcher_unregister(self, g_steal_pointer(&pr_o->obj_watcher));
}
if (pr_o->nmobj && pr_o->owner_dbobj && pr_o->owner_dbobj->nmobj) {
_nm_client_queue_notify_object(
self,
pr_o->owner_dbobj->nmobj,
pr_o->meta_iface->obj_properties
[pr_o->meta_iface->dbus_properties[pr_o->dbus_property_idx].obj_properties_idx]);
}
pr_o->owner_dbobj = NULL;
pr_o->meta_iface = NULL;
pr_o->dbus_property_idx = 0;
pr_o->is_ready = FALSE;
pr_o->nmobj = NULL;
}
void
nml_dbus_property_o_clear_many(NMLDBusPropertyO *pr_o, guint len, NMClient *self)
{
while (len-- > 0)
nml_dbus_property_o_clear(pr_o++, self);
}
/*****************************************************************************/
typedef struct _NMLDBusPropertyAOData {
NMLDBusObjWatcher obj_watcher;
NMLDBusPropertyAO *parent;
CList data_lst;
GObject *nmobj;
struct _NMLDBusPropertyAOData *changed_next;
bool is_ready : 1;
bool is_notified : 1;
bool is_changed : 1;
bool block_is_changed : 1;
} PropertyAOData;
static void
_ASSERT_pr_ao(NMLDBusPropertyAO *pr_ao)
{
nm_assert(pr_ao);
#if NM_MORE_ASSERTS > 10
if (pr_ao->owner_dbobj) {
guint n_not_ready = 0;
guint n_is_changed = 0;
guint n_is_changed_2;
PropertyAOData *pr_ao_data;
c_list_for_each_entry (pr_ao_data, &pr_ao->data_lst_head, data_lst) {
if (pr_ao_data->is_changed)
n_is_changed++;
if (!pr_ao_data->is_ready)
n_not_ready++;
}
nm_assert(n_not_ready == pr_ao->n_not_ready);
n_is_changed_2 = 0;
pr_ao_data = pr_ao->changed_head;
while (pr_ao_data) {
nm_assert(pr_ao_data->is_changed);
n_is_changed_2++;
pr_ao_data = pr_ao_data->changed_next;
}
nm_assert(n_is_changed == n_is_changed_2);
}
#endif
}
static gboolean
nml_dbus_property_ao_notify_changed_ao(PropertyAOData *pr_ao_data,
NMClient *self,
gboolean is_added /* or else removed */)
{
NMLDBusPropertyAO *pr_ao;
const NMLDBusPropertVTableAO *vtable;
if (!pr_ao_data->nmobj)
return FALSE;
nm_assert(pr_ao_data->is_ready);
if (is_added) {
if (pr_ao_data->is_notified)
return FALSE;
pr_ao_data->is_notified = TRUE;
} else {
if (!pr_ao_data->is_notified)
return FALSE;
pr_ao_data->is_notified = FALSE;
}
pr_ao = pr_ao_data->parent;
vtable = pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx].extra.property_vtable_ao;
if (vtable->notify_changed_ao)
vtable->notify_changed_ao(pr_ao, self, NM_OBJECT(pr_ao_data->nmobj), is_added);
return TRUE;
}
const GPtrArray *
nml_dbus_property_ao_get_objs_as_ptrarray(NMLDBusPropertyAO *pr_ao)
{
if (!pr_ao->arr) {
PropertyAOData *pr_ao_data;
gsize n;
n = 0;
if (pr_ao->owner_dbobj) {
c_list_for_each_entry (pr_ao_data, &pr_ao->data_lst_head, data_lst) {
if (pr_ao_data->nmobj)
n++;
}
}
pr_ao->arr = g_ptr_array_new_full(n, g_object_unref);
if (pr_ao->owner_dbobj) {
c_list_for_each_entry (pr_ao_data, &pr_ao->data_lst_head, data_lst) {
if (pr_ao_data->nmobj)
g_ptr_array_add(pr_ao->arr, g_object_ref(pr_ao_data->nmobj));
}
}
}
return pr_ao->arr;
}
gboolean
nml_dbus_property_ao_is_ready(const NMLDBusPropertyAO *pr_ao)
{
return pr_ao->n_not_ready == 0;
}
static void
nml_dbus_property_ao_notify_changed(NMLDBusPropertyAO *pr_ao, NMClient *self)
{
gboolean changed_prop = FALSE;
gboolean changed_ready = FALSE;
PropertyAOData *pr_ao_data;
nm_assert(NM_IS_CLIENT(self));
_ASSERT_pr_ao(pr_ao);
if (!pr_ao->owner_dbobj)
return;
if (!pr_ao->is_changed) {
if (pr_ao->n_not_ready == 0)
return;
goto done;
}
pr_ao->is_changed = FALSE;
while (pr_ao->changed_head) {
const NMLDBusPropertVTableAO *vtable;
GObject *nmobj = NULL;
gboolean is_ready = TRUE;
GType gtype;
pr_ao_data = g_steal_pointer(&pr_ao->changed_head);
nm_assert(pr_ao_data->is_changed);
pr_ao->changed_head = pr_ao_data->changed_next;
pr_ao_data->is_changed = FALSE;
if (!pr_ao_data->obj_watcher.dbobj->nmobj) {
if (pr_ao_data->obj_watcher.dbobj->obj_state >= NML_DBUS_OBJ_STATE_ON_DBUS) {
NML_NMCLIENT_LOG_W(
self,
"[%s]: property %s references %s but object is not created",
pr_ao->owner_dbobj->dbus_path->str,
pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx].dbus_property_name,
pr_ao_data->obj_watcher.dbobj->dbus_path->str);
} else {
NML_NMCLIENT_LOG_E(
self,
"[%s]: property %s references %s but object is not present on D-Bus",
pr_ao->owner_dbobj->dbus_path->str,
pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx].dbus_property_name,
pr_ao_data->obj_watcher.dbobj->dbus_path->str);
}
goto done_pr_ao_data;
}
vtable =
pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx].extra.property_vtable_ao;
gtype = vtable->get_o_type_fcn();
if (!g_type_is_a(G_OBJECT_TYPE(pr_ao_data->obj_watcher.dbobj->nmobj), gtype)) {
NML_NMCLIENT_LOG_E(
self,
"[%s]: property %s references %s with unexpected GObject type %s instead of %s",
pr_ao->owner_dbobj->dbus_path->str,
pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx].dbus_property_name,
pr_ao_data->obj_watcher.dbobj->dbus_path->str,
G_OBJECT_TYPE_NAME(pr_ao_data->obj_watcher.dbobj->nmobj),
g_type_name(gtype));
goto done_pr_ao_data;
}
if (pr_ao_data->obj_watcher.dbobj == pr_ao->owner_dbobj) {
NML_NMCLIENT_LOG_W(
self,
"[%s]: property %s references itself",
pr_ao->owner_dbobj->dbus_path->str,
pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx].dbus_property_name);
nmobj = pr_ao->owner_dbobj->nmobj;
goto done_pr_ao_data;
}
pr_ao_data->block_is_changed = TRUE;
is_ready = _dbobjs_check_dbobj_ready(self, pr_ao_data->obj_watcher.dbobj);
pr_ao_data->block_is_changed = FALSE;
if (!is_ready) {
is_ready = vtable->is_always_ready;
goto done_pr_ao_data;
}
if (vtable->check_nmobj_visible_fcn
&& !vtable->check_nmobj_visible_fcn(pr_ao_data->obj_watcher.dbobj->nmobj)) {
is_ready = TRUE;
goto done_pr_ao_data;
}
nmobj = pr_ao_data->obj_watcher.dbobj->nmobj;
done_pr_ao_data:
if (!pr_ao_data->is_ready && is_ready) {
nm_assert(pr_ao->n_not_ready > 0);
pr_ao->n_not_ready--;
pr_ao_data->is_ready = TRUE;
changed_ready = TRUE;
}
if (pr_ao_data->nmobj != nmobj) {
if (nml_dbus_property_ao_notify_changed_ao(pr_ao_data, self, FALSE))
changed_prop = TRUE;
pr_ao_data->nmobj = nmobj;
}
if (!pr_ao_data->is_notified) {
if (nml_dbus_property_ao_notify_changed_ao(pr_ao_data, self, TRUE))
changed_prop = TRUE;
}
}
_ASSERT_pr_ao(pr_ao);
done:
if (changed_prop) {
nm_clear_pointer(&pr_ao->arr, g_ptr_array_unref);
_nm_client_queue_notify_object(
self,
pr_ao->owner_dbobj->nmobj,
pr_ao->meta_iface->obj_properties
[pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx].obj_properties_idx]);
}
if (changed_ready && pr_ao->n_not_ready == 0
&& pr_ao->owner_dbobj->obj_state == NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY)
nml_dbus_object_obj_changed_link(self, pr_ao->owner_dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
}
void
nml_dbus_property_ao_notify_changed_many(NMLDBusPropertyAO *ptr, guint len, NMClient *self)
{
while (len-- > 0)
nml_dbus_property_ao_notify_changed(ptr++, self);
}
static void
nml_dbus_property_ao_notify_watch_cb(NMClient *self, gpointer obj_watcher)
{
PropertyAOData *pr_ao_data = obj_watcher;
NMLDBusPropertyAO *pr_ao = pr_ao_data->parent;
nm_assert(g_hash_table_lookup(pr_ao->hash, pr_ao_data) == pr_ao_data);
if (!pr_ao_data->block_is_changed && !pr_ao_data->is_changed) {
pr_ao_data->is_changed = TRUE;
pr_ao_data->changed_next = pr_ao->changed_head;
pr_ao->changed_head = pr_ao_data;
if (!pr_ao->is_changed) {
pr_ao->is_changed = TRUE;
nml_dbus_object_obj_changed_link(self,
pr_ao->owner_dbobj,
NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
}
}
_ASSERT_pr_ao(pr_ao);
}
NMLDBusNotifyUpdatePropFlags
nml_dbus_property_ao_notify(NMClient *self,
NMLDBusPropertyAO *pr_ao,
NMLDBusObject *dbobj,
const NMLDBusMetaIface *meta_iface,
guint dbus_property_idx,
GVariant *value)
{
CList stale_lst_head = C_LIST_INIT(stale_lst_head);
PropertyAOData *pr_ao_data;
gboolean changed_prop = FALSE;
gboolean changed_obj = FALSE;
if (!pr_ao->owner_dbobj) {
nm_assert(!pr_ao->data_lst_head.next);
nm_assert(!pr_ao->data_lst_head.prev);
nm_assert(!pr_ao->hash);
nm_assert(!pr_ao->meta_iface);
nm_assert(pr_ao->dbus_property_idx == 0);
nm_assert(pr_ao->n_not_ready == 0);
nm_assert(!pr_ao->changed_head);
nm_assert(!pr_ao->is_changed);
c_list_init(&pr_ao->data_lst_head);
pr_ao->hash = g_hash_table_new(nm_ppdirect_hash, nm_ppdirect_equal);
pr_ao->owner_dbobj = dbobj;
pr_ao->meta_iface = meta_iface;
pr_ao->dbus_property_idx = dbus_property_idx;
} else {
nm_assert(pr_ao->data_lst_head.next);
nm_assert(pr_ao->data_lst_head.prev);
nm_assert(pr_ao->hash);
nm_assert(pr_ao->meta_iface == meta_iface);
nm_assert(pr_ao->dbus_property_idx == dbus_property_idx);
}
c_list_splice(&stale_lst_head, &pr_ao->data_lst_head);
if (value) {
GVariantIter iter;
const char *path;
g_variant_iter_init(&iter, value);
while (g_variant_iter_next(&iter, "&o", &path)) {
nm_auto_ref_string NMRefString *dbus_path_r = NULL;
gpointer p_dbus_path_1;
G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(PropertyAOData, obj_watcher) == 0);
G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(NMLDBusObjWatcher, dbobj) == 0);
G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(NMLDBusObject, dbus_path) == 0);
if (!nm_dbus_path_not_empty(path)) {
/* should not happen. Anyway, silently skip empty paths. */
continue;
}
dbus_path_r = nm_ref_string_new(path);
p_dbus_path_1 = &dbus_path_r;
pr_ao_data = g_hash_table_lookup(pr_ao->hash, &p_dbus_path_1);
if (pr_ao_data) {
/* With this implementation we cannot track the same path multiple times.
* Of course, for none of the properties where we use this, the server
* should expose the same path more than once, so this limitation is fine
* (maybe even preferable to drop duplicates form NMClient's API). */
nm_assert(pr_ao_data->obj_watcher.dbobj->dbus_path == dbus_path_r);
if (!changed_prop && pr_ao_data->is_notified) {
/* The order of a notified entry changed. That means, we need to signal
* a change of the property. This detection of a change is not always
* correct, in particular we might detect some changes when there were
* none. That's not a serious problem, and fixing it would be expensive
* to implement. */
changed_prop = (c_list_first(&stale_lst_head) != &pr_ao_data->data_lst);
}
nm_c_list_move_tail(&pr_ao->data_lst_head, &pr_ao_data->data_lst);
} else {
pr_ao_data = _dbobjs_obj_watcher_register_r(self,
g_steal_pointer(&dbus_path_r),
nml_dbus_property_ao_notify_watch_cb,
sizeof(PropertyAOData)),
pr_ao_data->parent = pr_ao;
pr_ao_data->nmobj = NULL;
pr_ao_data->changed_next = NULL;
pr_ao_data->is_changed = TRUE;
pr_ao_data->block_is_changed = FALSE;
pr_ao_data->is_ready = FALSE;
pr_ao_data->is_notified = FALSE;
c_list_link_tail(&pr_ao->data_lst_head, &pr_ao_data->data_lst);
if (!g_hash_table_add(pr_ao->hash, pr_ao_data))
nm_assert_not_reached();
nm_assert(pr_ao->n_not_ready < G_MAXUINT);
pr_ao->n_not_ready++;
}
#if NM_MORE_ASSERTS > 10
{
nm_auto_ref_string NMRefString *p = nm_ref_string_new(path);
gpointer pp = &p;
nm_assert(g_hash_table_lookup(pr_ao->hash, &pp) == pr_ao_data);
}
#endif
}
}
pr_ao->changed_head = NULL;
c_list_for_each_entry (pr_ao_data, &pr_ao->data_lst_head, data_lst) {
if (pr_ao_data->is_changed) {
pr_ao_data->changed_next = pr_ao->changed_head;
pr_ao->changed_head = pr_ao_data;
changed_obj = TRUE;
}
}
while ((pr_ao_data = c_list_first_entry(&stale_lst_head, PropertyAOData, data_lst))) {
changed_obj = TRUE;
c_list_unlink(&pr_ao_data->data_lst);
if (!g_hash_table_remove(pr_ao->hash, pr_ao_data))
nm_assert_not_reached();
if (!pr_ao_data->is_ready) {
nm_assert(pr_ao->n_not_ready > 0);
pr_ao->n_not_ready--;
} else {
if (nml_dbus_property_ao_notify_changed_ao(pr_ao_data, self, FALSE))
changed_prop = TRUE;
}
_dbobjs_obj_watcher_unregister(self, pr_ao_data);
}
_ASSERT_pr_ao(pr_ao);
if (changed_obj) {
pr_ao->is_changed = TRUE;
nml_dbus_object_obj_changed_link(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
}
if (changed_prop) {
nm_clear_pointer(&pr_ao->arr, g_ptr_array_unref);
_nm_client_queue_notify_object(
self,
pr_ao->owner_dbobj->nmobj,
pr_ao->meta_iface->obj_properties
[pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx].obj_properties_idx]);
}
return NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NONE;
}
gboolean
nml_dbus_property_ao_clear(NMLDBusPropertyAO *pr_ao, NMClient *self)
{
gboolean changed_prop = FALSE;
_ASSERT_pr_ao(pr_ao);
if (!pr_ao->owner_dbobj) {
nm_assert(pr_ao->n_not_ready == 0);
nm_assert((!pr_ao->data_lst_head.next && !pr_ao->data_lst_head.prev)
|| (pr_ao->data_lst_head.next == pr_ao->data_lst_head.prev));
nm_assert(!pr_ao->hash);
nm_assert(!pr_ao->meta_iface);
nm_assert(pr_ao->dbus_property_idx == 0);
nm_assert(!pr_ao->is_changed);
} else {
PropertyAOData *pr_ao_data;
nm_assert(NM_IS_CLIENT(self));
nm_assert(pr_ao->data_lst_head.next);
nm_assert(pr_ao->data_lst_head.prev);
nm_assert(pr_ao->hash);
nm_assert(pr_ao->meta_iface);
while ((pr_ao_data = c_list_first_entry(&pr_ao->data_lst_head, PropertyAOData, data_lst))) {
if (!pr_ao_data->is_ready) {
nm_assert(pr_ao->n_not_ready > 0);
pr_ao->n_not_ready--;
} else {
if (nml_dbus_property_ao_notify_changed_ao(pr_ao_data, self, FALSE))
changed_prop = TRUE;
}
c_list_unlink(&pr_ao_data->data_lst);
if (!g_hash_table_remove(pr_ao->hash, pr_ao_data))
nm_assert_not_reached();
_dbobjs_obj_watcher_unregister(self, pr_ao_data);
}
nm_assert(c_list_is_empty(&pr_ao->data_lst_head));
nm_assert(pr_ao->n_not_ready == 0);
nm_assert(g_hash_table_size(pr_ao->hash) == 0);
if (changed_prop && pr_ao->owner_dbobj->nmobj) {
_nm_client_queue_notify_object(
self,
pr_ao->owner_dbobj->nmobj,
pr_ao->meta_iface
->obj_properties[pr_ao->meta_iface->dbus_properties[pr_ao->dbus_property_idx]
.obj_properties_idx]);
}
nm_assert(c_list_is_empty(&pr_ao->data_lst_head));
nm_assert(pr_ao->n_not_ready == 0);
nm_assert(g_hash_table_size(pr_ao->hash) == 0);
nm_clear_pointer(&pr_ao->hash, g_hash_table_unref);
pr_ao->owner_dbobj = NULL;
pr_ao->meta_iface = NULL;
pr_ao->dbus_property_idx = 0;
pr_ao->data_lst_head.next = NULL;
pr_ao->data_lst_head.prev = NULL;
pr_ao->is_changed = FALSE;
}
nm_clear_pointer(&pr_ao->arr, g_ptr_array_unref);
return changed_prop;
}
void
nml_dbus_property_ao_clear_many(NMLDBusPropertyAO *pr_ao, guint len, NMClient *self)
{
while (len-- > 0)
nml_dbus_property_ao_clear(pr_ao++, self);
}
/*****************************************************************************/
NMLDBusNotifyUpdatePropFlags
_nml_dbus_notify_update_prop_ignore(NMClient *self,
NMLDBusObject *dbobj,
const NMLDBusMetaIface *meta_iface,
guint dbus_property_idx,
GVariant *value)
{
return NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NONE;
}
NMLDBusNotifyUpdatePropFlags
_nml_dbus_notify_update_prop_o(NMClient *self,
NMLDBusObject *dbobj,
const NMLDBusMetaIface *meta_iface,
guint dbus_property_idx,
GVariant *value)
{
const char *path = NULL;
NMRefString **p_property;
if (value)
path = g_variant_get_string(value, NULL);
p_property =
nml_dbus_object_get_property_location(dbobj,
meta_iface,
&meta_iface->dbus_properties[dbus_property_idx]);
if (!nm_streq0(nm_ref_string_get_str(*p_property), path)) {
nm_ref_string_unref(*p_property);
*p_property = nm_ref_string_new(path);
}
return NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NOTIFY;
}
/*****************************************************************************/
static void
_obj_handle_dbus_prop_changes(NMClient *self,
NMLDBusObject *dbobj,
NMLDBusObjIfaceData *db_iface_data,
guint dbus_property_idx,
GVariant *value)
{
const NMLDBusMetaIface *meta_iface = db_iface_data->dbus_iface.meta;
const NMLDBusMetaProperty *meta_property = &meta_iface->dbus_properties[dbus_property_idx];
gpointer p_property;
const char *dbus_type_s;
const GParamSpec *param_spec;
NMLDBusNotifyUpdatePropFlags notify_update_prop_flags;
nm_assert(G_IS_OBJECT(dbobj->nmobj));
if (value && !g_variant_is_of_type(value, meta_property->dbus_type)) {
NML_NMCLIENT_LOG_E(self,
"[%s] property %s.%s expected of type \"%s\" but is \"%s\". Ignore",
dbobj->dbus_path->str,
meta_iface->dbus_iface_name,
meta_property->dbus_property_name,
(const char *) meta_property->dbus_type,
(const char *) g_variant_get_type(value));
value = NULL;
}
if (meta_property->notify_update_prop) {
notify_update_prop_flags =
meta_property->notify_update_prop(self, dbobj, meta_iface, dbus_property_idx, value);
if (notify_update_prop_flags == NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NONE)
return;
nm_assert(notify_update_prop_flags == NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NOTIFY);
nm_assert(G_IS_OBJECT(dbobj->nmobj));
nm_assert(meta_iface->obj_properties);
nm_assert(meta_property->obj_properties_idx > 0);
param_spec = meta_iface->obj_properties[meta_property->obj_properties_idx];
goto notify;
}
p_property = nml_dbus_object_get_property_location(dbobj, meta_iface, meta_property);
dbus_type_s = (const char *) meta_property->dbus_type;
nm_assert(G_IS_OBJECT(dbobj->nmobj));
nm_assert(meta_iface->obj_properties);
nm_assert(meta_property->obj_properties_idx > 0);
param_spec = meta_iface->obj_properties[meta_property->obj_properties_idx];
notify_update_prop_flags = NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NOTIFY;
switch (dbus_type_s[0]) {
case 'b':
nm_assert(dbus_type_s[1] == '\0');
if (value)
*((bool *) p_property) = g_variant_get_boolean(value);
else if (param_spec->value_type == G_TYPE_BOOLEAN)
*((bool *) p_property) = ((GParamSpecBoolean *) param_spec)->default_value;
else {
nm_assert_not_reached();
*((bool *) p_property) = FALSE;
}
break;
case 'y':
nm_assert(dbus_type_s[1] == '\0');
if (value)
*((guint8 *) p_property) = g_variant_get_byte(value);
else {
nm_assert(nm_utils_g_param_spec_is_default(param_spec));
*((guint8 *) p_property) = 0;
}
break;
case 'q':
nm_assert(dbus_type_s[1] == '\0');
if (value)
*((guint16 *) p_property) = g_variant_get_uint16(value);
else {
nm_assert(nm_utils_g_param_spec_is_default(param_spec));
*((guint16 *) p_property) = 0;
}
break;
case 'i':
nm_assert(dbus_type_s[1] == '\0');
if (value)
*((gint32 *) p_property) = g_variant_get_int32(value);
else if (param_spec->value_type == G_TYPE_INT)
*((gint32 *) p_property) = ((GParamSpecInt *) param_spec)->default_value;
else {
nm_assert(nm_utils_g_param_spec_is_default(param_spec));
*((gint32 *) p_property) = 0;
}
break;
case 'u':
nm_assert(dbus_type_s[1] == '\0');
if (value)
*((guint32 *) p_property) = g_variant_get_uint32(value);
else {
nm_assert(nm_utils_g_param_spec_is_default(param_spec));
*((guint32 *) p_property) = 0;
}
break;
case 'x':
nm_assert(dbus_type_s[1] == '\0');
if (value)
*((gint64 *) p_property) = g_variant_get_int64(value);
else if (param_spec->value_type == G_TYPE_INT64)
*((gint64 *) p_property) = ((GParamSpecInt64 *) param_spec)->default_value;
else {
nm_assert(nm_utils_g_param_spec_is_default(param_spec));
*((gint64 *) p_property) = 0;
}
break;
case 't':
nm_assert(dbus_type_s[1] == '\0');
if (value)
*((guint64 *) p_property) = g_variant_get_uint64(value);
else {
nm_assert(nm_utils_g_param_spec_is_default(param_spec));
*((guint64 *) p_property) = 0;
}
break;
case 's':
nm_assert(dbus_type_s[1] == '\0');
nm_clear_g_free((char **) p_property);
if (value)
*((char **) p_property) = g_variant_dup_string(value, NULL);
else {
nm_assert(nm_utils_g_param_spec_is_default(param_spec));
*((char **) p_property) = NULL;
}
break;
case 'o':
nm_assert(dbus_type_s[1] == '\0');
notify_update_prop_flags = nml_dbus_property_o_notify(self,
p_property,
dbobj,
meta_iface,
dbus_property_idx,
value);
break;
case 'a':
switch (dbus_type_s[1]) {
case 'y':
nm_assert(dbus_type_s[2] == '\0');
{
gconstpointer v;
gsize l;
GBytes *b = NULL;
if (value) {
v = g_variant_get_fixed_array(value, &l, 1);
if (l > 0) {
/* empty arrays are coerced to NULL. */
b = g_bytes_new(v, l);
}
}
nm_clear_pointer((GBytes **) p_property, g_bytes_unref);
*((GBytes **) p_property) = b;
}
break;
case 's':
nm_assert(dbus_type_s[2] == '\0');
nm_assert(param_spec->value_type == G_TYPE_STRV);
g_strfreev(*((char ***) p_property));
if (value)
*((char ***) p_property) = g_variant_dup_strv(value, NULL);
else
*((char ***) p_property) = NULL;
break;
case 'o':
nm_assert(dbus_type_s[2] == '\0');
notify_update_prop_flags = nml_dbus_property_ao_notify(self,
p_property,
dbobj,
meta_iface,
dbus_property_idx,
value);
break;
default:
nm_assert_not_reached();
}
break;
default:
nm_assert_not_reached();
}
notify:
if (NM_FLAGS_HAS(notify_update_prop_flags, NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NOTIFY))
g_object_notify_by_pspec(dbobj->nmobj, (GParamSpec *) param_spec);
}
static void
_obj_handle_dbus_iface_changes(NMClient *self,
NMLDBusObject *dbobj,
NMLDBusObjIfaceData *db_iface_data)
{
NMLDBusObjPropData *db_prop_data;
gboolean is_self = (G_OBJECT(self) == dbobj->nmobj);
gboolean is_removed;
gboolean type_compatible;
guint8 i_prop;
nm_assert(NM_IS_CLIENT(self));
nm_assert(is_self || NM_IS_OBJECT(dbobj->nmobj));
if (G_UNLIKELY(!db_iface_data->nmobj_checked)) {
db_iface_data->nmobj_checked = TRUE;
type_compatible = db_iface_data->dbus_iface.meta->get_type_fcn
&& g_type_is_a(G_OBJECT_TYPE(dbobj->nmobj),
db_iface_data->dbus_iface.meta->get_type_fcn());
db_iface_data->nmobj_compatible = type_compatible;
} else
type_compatible = db_iface_data->nmobj_compatible;
if (!type_compatible) {
/* on D-Bus, we have this interface associate with the object, but apparently
* it is not compatible. This is either a bug, or NetworkManager exposed an
* unexpected interface on D-Bus object for which we create a certain NMObject
* type. */
return;
}
is_removed = c_list_is_empty(&db_iface_data->iface_lst);
nm_assert(is_removed || !c_list_is_empty(&db_iface_data->changed_prop_lst_head));
_nm_client_queue_notify_object(self, dbobj->nmobj, NULL);
if (is_removed) {
for (i_prop = 0; i_prop < db_iface_data->dbus_iface.meta->n_dbus_properties; i_prop++) {
const GVariantType *dbus_type =
db_iface_data->dbus_iface.meta->dbus_properties[i_prop].dbus_type;
/* Unset properties that can potentially contain objects, to release them,
* but keep the rest around, because it might still make sense to know what
* they were (e.g. when a device has been removed we'd like know what interface
* name it had, or keep the state to avoid spurious state change into UNKNOWN). */
if (g_variant_type_is_array(dbus_type)
|| g_variant_type_equal(dbus_type, G_VARIANT_TYPE_OBJECT_PATH))
_obj_handle_dbus_prop_changes(self, dbobj, db_iface_data, i_prop, NULL);
}
} else {
while ((db_prop_data = c_list_first_entry(&db_iface_data->changed_prop_lst_head,
NMLDBusObjPropData,
changed_prop_lst))) {
gs_unref_variant GVariant *prop_data_value = NULL;
c_list_unlink(&db_prop_data->changed_prop_lst);
nm_assert(db_prop_data >= db_iface_data->prop_datas);
nm_assert(
db_prop_data
< &db_iface_data->prop_datas[db_iface_data->dbus_iface.meta->n_dbus_properties]);
nm_assert(db_prop_data->prop_data_value);
/* Currently, NMLDBusObject forgets about the variant. Theoretically, it could cache
* it, but there is no need because we update the property in nmobj (which extracts and
* keeps the property value itself).
*
* Note that we only consume the variant here when we process it.
* That implies that we already created a NMObject for the dbobj
* instance. Unless that happens, we cache the last seen property values. */
prop_data_value = g_steal_pointer(&db_prop_data->prop_data_value);
i_prop = (db_prop_data - &db_iface_data->prop_datas[0]);
_obj_handle_dbus_prop_changes(self, dbobj, db_iface_data, i_prop, prop_data_value);
}
}
}
static void
_obj_handle_dbus_changes(NMClient *self, NMLDBusObject *dbobj)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NMLDBusObjIfaceData *db_iface_data;
NMLDBusObjIfaceData *db_iface_data_safe;
gs_unref_object GObject *nmobj_unregistering = NULL;
_ASSERT_dbobj(dbobj, self);
/* In a first step we only remember all the changes that a D-Bus message brings
* and queue the object to process them.
*
* Here (in step 2) we look at what changed on D-Bus and propagate those changes
* to the NMObject instance.
*
* Note that here we still must not emit any GObject signals. That follows later,
* and again if the object changes, we will just queue that we handle the changes
* later. */
c_list_for_each_entry_safe (db_iface_data,
db_iface_data_safe,
&dbobj->iface_lst_head,
iface_lst) {
if (!db_iface_data->iface_removed)
continue;
c_list_unlink(&db_iface_data->iface_lst);
if (db_iface_data->dbus_iface_is_wellknown && dbobj->nmobj)
_obj_handle_dbus_iface_changes(self, dbobj, db_iface_data);
nml_dbus_obj_iface_data_destroy(db_iface_data);
}
if (G_UNLIKELY(!dbobj->nmobj) && !c_list_is_empty(&dbobj->iface_lst_head)) {
/* Try to create a NMObject for this D-Bus object. Note that we detect the type
* based on the interfaces that it has, and if we make a choice once, we don't
* change. That means, one D-Bus object can only be of one type. */
if (NM_IN_SET(dbobj->dbus_path,
_dbus_path_nm,
_dbus_path_settings,
_dbus_path_dns_manager)) {
/* For the main types, we don't detect them based on the interfaces present,
* but on the path names. Of course, both should correspond anyway. */
NML_NMCLIENT_LOG_T(self,
"[%s]: register NMClient for D-Bus object",
dbobj->dbus_path->str);
dbobj->nmobj = G_OBJECT(self);
if (dbobj->dbus_path == _dbus_path_nm) {
nm_assert(!priv->dbobj_nm);
priv->dbobj_nm = dbobj;
} else if (dbobj->dbus_path == _dbus_path_settings) {
nm_assert(!priv->dbobj_settings);
priv->dbobj_settings = dbobj;
} else {
nm_assert(dbobj->dbus_path == _dbus_path_dns_manager);
nm_assert(!priv->dbobj_dns_manager);
priv->dbobj_dns_manager = dbobj;
}
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY, self);
} else {
GType gtype = G_TYPE_NONE;
NMLDBusMetaInteracePrio curr_prio = NML_DBUS_META_INTERFACE_PRIO_INSTANTIATE_10 - 1;
c_list_for_each_entry (db_iface_data, &dbobj->iface_lst_head, iface_lst) {
nm_assert(!db_iface_data->iface_removed);
if (!db_iface_data->dbus_iface_is_wellknown)
break;
if (db_iface_data->dbus_iface.meta->interface_prio <= curr_prio)
continue;
curr_prio = db_iface_data->dbus_iface.meta->interface_prio;
gtype = db_iface_data->dbus_iface.meta->get_type_fcn();
}
if (gtype != G_TYPE_NONE) {
dbobj->nmobj = g_object_new(gtype, NULL);
NML_NMCLIENT_LOG_T(self,
"[%s]: register new NMObject " NM_HASH_OBFUSCATE_PTR_FMT
" of type %s",
dbobj->dbus_path->str,
NM_HASH_OBFUSCATE_PTR(dbobj->nmobj),
g_type_name(gtype));
nm_assert(NM_IS_OBJECT(dbobj->nmobj));
NM_OBJECT_GET_CLASS(dbobj->nmobj)
->register_client(NM_OBJECT(dbobj->nmobj), self, dbobj);
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY, self);
}
}
}
c_list_for_each_entry (db_iface_data, &dbobj->iface_lst_head, iface_lst) {
nm_assert(!db_iface_data->iface_removed);
if (!db_iface_data->dbus_iface_is_wellknown)
break;
if (c_list_is_empty(&db_iface_data->changed_prop_lst_head))
continue;
if (dbobj->nmobj)
_obj_handle_dbus_iface_changes(self, dbobj, db_iface_data);
}
if (c_list_is_empty(&dbobj->iface_lst_head) && dbobj->nmobj) {
if (dbobj->nmobj == G_OBJECT(self)) {
dbobj->nmobj = NULL;
NML_NMCLIENT_LOG_T(self,
"[%s]: unregister NMClient from D-Bus object",
dbobj->dbus_path->str);
if (dbobj->dbus_path == _dbus_path_nm) {
nm_assert(priv->dbobj_nm == dbobj);
priv->dbobj_nm = NULL;
nml_dbus_property_o_clear_many(priv->nm.property_o,
G_N_ELEMENTS(priv->nm.property_o),
self);
nml_dbus_property_ao_clear_many(priv->nm.property_ao,
G_N_ELEMENTS(priv->nm.property_ao),
self);
} else if (dbobj->dbus_path == _dbus_path_settings) {
nm_assert(priv->dbobj_settings == dbobj);
priv->dbobj_settings = NULL;
nml_dbus_property_ao_clear(&priv->settings.connections, self);
} else {
nm_assert(dbobj->dbus_path == _dbus_path_dns_manager);
nm_assert(priv->dbobj_dns_manager == dbobj);
priv->dbobj_dns_manager = NULL;
}
} else {
nmobj_unregistering = g_steal_pointer(&dbobj->nmobj);
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_WATCHED_ONLY, self);
NML_NMCLIENT_LOG_T(self,
"[%s]: unregister NMObject " NM_HASH_OBFUSCATE_PTR_FMT " of type %s",
dbobj->dbus_path->str,
NM_HASH_OBFUSCATE_PTR(nmobj_unregistering),
g_type_name(G_OBJECT_TYPE(nmobj_unregistering)));
NM_OBJECT_GET_CLASS(nmobj_unregistering)
->unregister_client(NM_OBJECT(nmobj_unregistering), self, dbobj);
}
}
nml_dbus_object_obj_changed_link(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ);
}
/*****************************************************************************/
static void
_dbus_handle_obj_changed_nmobj(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NMLDBusObject *dbobj;
CList obj_changed_tmp_lst_head = C_LIST_INIT(obj_changed_tmp_lst_head);
nm_assert(!nml_dbus_object_obj_changed_any_linked(self, ~NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ));
/* First we notify all watchers that these objects changed. Note that we only do that
* here for the list before processing the changes below in a loop. That is, because
* processing changes can again enqueue changed objects, and we only want to want to
* notify watchers for the events that happened earlier (not repeatedly notify them). */
c_list_splice(&obj_changed_tmp_lst_head, &priv->obj_changed_lst_head);
while (
(dbobj = c_list_first_entry(&obj_changed_tmp_lst_head, NMLDBusObject, obj_changed_lst))) {
nm_c_list_move_tail(&priv->obj_changed_lst_head, &dbobj->obj_changed_lst);
_dbobjs_notify_watchers_for_dbobj(self, dbobj);
}
again:
nm_assert(!nml_dbus_object_obj_changed_any_linked(self, ~NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ));
c_list_splice(&obj_changed_tmp_lst_head, &priv->obj_changed_lst_head);
while (
(dbobj = c_list_first_entry(&obj_changed_tmp_lst_head, NMLDBusObject, obj_changed_lst))) {
if (!nml_dbus_object_obj_changed_consume(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ)) {
nm_assert_not_reached();
continue;
}
if (!dbobj->nmobj)
continue;
if (dbobj->nmobj == G_OBJECT(self)) {
if (dbobj == priv->dbobj_nm) {
nml_dbus_property_o_notify_changed_many(priv->nm.property_o,
G_N_ELEMENTS(priv->nm.property_o),
self);
nml_dbus_property_ao_notify_changed_many(priv->nm.property_ao,
G_N_ELEMENTS(priv->nm.property_ao),
self);
} else if (dbobj == priv->dbobj_settings)
nml_dbus_property_ao_notify_changed(&priv->settings.connections, self);
else
nm_assert(dbobj == priv->dbobj_dns_manager);
} else
NM_OBJECT_GET_CLASS(dbobj->nmobj)->obj_changed_notify(NM_OBJECT(dbobj->nmobj));
_dbobjs_check_dbobj_ready(self, dbobj);
}
if (!c_list_is_empty(&priv->obj_changed_lst_head)) {
nm_assert(nml_dbus_object_obj_changed_any_linked(self, NML_DBUS_OBJ_CHANGED_TYPE_NMOBJ));
/* we got new changes enqueued. Need to check again. */
goto again;
}
}
static void
_dbus_handle_obj_changed_dbus(NMClient *self, const char *log_context)
{
NMClientPrivate *priv;
NMLDBusObject *dbobj;
CList obj_changed_tmp_lst_head = C_LIST_INIT(obj_changed_tmp_lst_head);
priv = NM_CLIENT_GET_PRIVATE(self);
/* We move the changed list onto a temporary list and consume that.
* Note that nml_dbus_object_obj_changed_consume() will move the object
* back to the original list if there are changes of another type.
*
* This is done so that we can enqueue more changes while processing the
* change list. */
c_list_splice(&obj_changed_tmp_lst_head, &priv->obj_changed_lst_head);
while (
(dbobj = c_list_first_entry(&obj_changed_tmp_lst_head, NMLDBusObject, obj_changed_lst))) {
nm_auto_unref_nml_dbusobj NMLDBusObject *dbobj_unref = NULL;
if (!nml_dbus_object_obj_changed_consume(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_DBUS))
continue;
nm_assert(dbobj->obj_state >= NML_DBUS_OBJ_STATE_ON_DBUS);
dbobj_unref = nml_dbus_object_ref(dbobj);
_obj_handle_dbus_changes(self, dbobj);
if (dbobj->obj_state == NML_DBUS_OBJ_STATE_UNLINKED)
continue;
if (c_list_is_empty(&dbobj->iface_lst_head) && c_list_is_empty(&dbobj->watcher_lst_head)) {
NML_NMCLIENT_LOG_T(self, "[%s]: drop D-Bus instance", dbobj->dbus_path->str);
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_UNLINKED, self);
if (!g_hash_table_steal(priv->dbus_objects, dbobj))
nm_assert_not_reached();
nml_dbus_object_unref(dbobj);
}
}
/* D-Bus changes can only be enqueued in an earlier stage. We don't expect
* anymore changes of type D-Bus at this point. */
nm_assert(!nml_dbus_object_obj_changed_any_linked(self, NML_DBUS_OBJ_CHANGED_TYPE_DBUS));
}
static void
_dbus_handle_changes_commit(NMClient *self, gboolean allow_init_start_check_complete)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;
_dbus_handle_obj_changed_nmobj(self);
dbus_context = nm_g_main_context_push_thread_default_if_necessary(priv->main_context);
_nm_client_notify_event_emit(self);
_set_nm_running(self);
if (allow_init_start_check_complete)
_init_start_check_complete(self);
}
static void
_dbus_handle_changes(NMClient *self,
const char *log_context,
gboolean allow_init_start_check_complete)
{
_dbus_handle_obj_changed_dbus(self, log_context);
_dbus_handle_changes_commit(self, allow_init_start_check_complete);
}
static gboolean
_dbus_handle_properties_changed(NMClient *self,
const char *log_context,
const char *object_path,
const char *interface_name,
gboolean allow_add_iface,
GVariant *changed_properties,
NMLDBusObject **inout_dbobj)
{
NMLDBusObject *dbobj = NULL;
NMLDBusObjIfaceData *db_iface_data = NULL;
nm_auto_ref_string NMRefString *dbus_path = NULL;
nm_assert(!changed_properties
|| g_variant_is_of_type(changed_properties, G_VARIANT_TYPE("a{sv}")));
{
gs_free char *ss = NULL;
NML_NMCLIENT_LOG_T(self,
"[%s]: %s: properties changed for interface %s %s%s%s",
object_path,
log_context,
interface_name,
NM_PRINT_FMT_QUOTED(changed_properties,
"{ ",
(ss = g_variant_print(changed_properties, TRUE)),
" }",
"(no changed properties)"));
}
if (inout_dbobj) {
dbobj = *inout_dbobj;
nm_assert(!dbobj || nm_streq(object_path, dbobj->dbus_path->str));
}
if (!dbobj) {
dbus_path = nm_ref_string_new(object_path);
dbobj = _dbobjs_dbobj_get_r(self, dbus_path);
}
if (dbobj) {
nm_assert(dbobj->obj_state >= NML_DBUS_OBJ_STATE_WATCHED_ONLY);
db_iface_data = nml_dbus_object_iface_data_get(dbobj, interface_name, allow_add_iface);
if (db_iface_data && dbobj->obj_state == NML_DBUS_OBJ_STATE_WATCHED_ONLY)
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_ON_DBUS, self);
} else if (allow_add_iface) {
dbobj = _dbobjs_dbobj_create(self, g_steal_pointer(&dbus_path));
nml_dbus_object_set_obj_state(dbobj, NML_DBUS_OBJ_STATE_ON_DBUS, self);
db_iface_data = nml_dbus_object_iface_data_get(dbobj, interface_name, TRUE);
nm_assert(db_iface_data);
}
NM_SET_OUT(inout_dbobj, dbobj);
if (!db_iface_data) {
if (allow_add_iface)
NML_NMCLIENT_LOG_E(self,
"%s: [%s] too many interfaces on object. Something is very wrong",
log_context,
object_path);
else
NML_NMCLIENT_LOG_E(self,
"%s: [%s] property changed signal for non existing interface %s",
log_context,
object_path,
interface_name);
nm_assert(!dbobj || dbobj->obj_state != NML_DBUS_OBJ_STATE_UNLINKED);
return FALSE;
}
if (!db_iface_data->dbus_iface_is_wellknown)
NML_NMCLIENT_LOG_W(self,
"%s: [%s] ignore unknown interface %s",
log_context,
object_path,
interface_name);
else if (changed_properties) {
GVariantIter iter_prop;
const char *property_name;
GVariant *property_value_tmp;
g_variant_iter_init(&iter_prop, changed_properties);
while (g_variant_iter_next(&iter_prop, "{&sv}", &property_name, &property_value_tmp)) {
_nm_unused gs_unref_variant GVariant *property_value = property_value_tmp;
const NMLDBusMetaProperty *meta_property;
NMLDBusObjPropData *db_propdata;
guint property_idx;
meta_property = nml_dbus_meta_property_get(db_iface_data->dbus_iface.meta,
property_name,
&property_idx);
if (!meta_property) {
NML_NMCLIENT_LOG_W(self,
"%s: [%s]: ignore unknown property %s.%s",
log_context,
object_path,
interface_name,
property_name);
continue;
}
db_propdata = &db_iface_data->prop_datas[property_idx];
NML_NMCLIENT_LOG_T(self,
"[%s]: %s: %s property %s.%s",
object_path,
log_context,
db_propdata->prop_data_value ? "update" : "set",
interface_name,
property_name);
nm_g_variant_unref(db_propdata->prop_data_value);
db_propdata->prop_data_value = g_steal_pointer(&property_value);
nm_c_list_move_tail(&db_iface_data->changed_prop_lst_head,
&db_propdata->changed_prop_lst);
}
}
nml_dbus_object_obj_changed_link(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_DBUS);
return TRUE;
}
static gboolean
_dbus_handle_interface_added(NMClient *self,
const char *log_context,
const char *object_path,
GVariant *ifaces)
{
gboolean changed = FALSE;
const char *interface_name;
GVariant *changed_properties;
GVariantIter iter_ifaces;
NMLDBusObject *dbobj = NULL;
nm_assert(g_variant_is_of_type(ifaces, G_VARIANT_TYPE("a{sa{sv}}")));
g_variant_iter_init(&iter_ifaces, ifaces);
while (g_variant_iter_next(&iter_ifaces, "{&s@a{sv}}", &interface_name, &changed_properties)) {
_nm_unused gs_unref_variant GVariant *changed_properties_free = changed_properties;
if (_dbus_handle_properties_changed(self,
log_context,
object_path,
interface_name,
TRUE,
changed_properties,
&dbobj))
changed = TRUE;
}
return changed;
}
static gboolean
_dbus_handle_interface_removed(NMClient *self,
const char *log_context,
const char *object_path,
NMLDBusObject **inout_dbobj,
const char *const *removed_interfaces)
{
gboolean changed = FALSE;
NMLDBusObject *dbobj;
gsize i;
if (inout_dbobj && *inout_dbobj) {
dbobj = *inout_dbobj;
nm_assert(dbobj == _dbobjs_dbobj_get_s(self, object_path));
} else {
dbobj = _dbobjs_dbobj_get_s(self, object_path);
if (!dbobj) {
NML_NMCLIENT_LOG_E(self,
"%s: [%s]: receive interface removed event for non existing object",
log_context,
object_path);
return FALSE;
}
NM_SET_OUT(inout_dbobj, dbobj);
}
for (i = 0; removed_interfaces[i]; i++) {
NMLDBusObjIfaceData *db_iface_data;
const char *interface_name = removed_interfaces[i];
db_iface_data = nml_dbus_object_iface_data_get(dbobj, interface_name, FALSE);
if (!db_iface_data) {
NML_NMCLIENT_LOG_E(
self,
"%s: [%s] receive interface remove event for unexpected interface %s",
log_context,
object_path,
interface_name);
continue;
}
NML_NMCLIENT_LOG_T(self,
"%s: [%s] receive interface remove event for interface %s",
log_context,
object_path,
interface_name);
db_iface_data->iface_removed = TRUE;
changed = TRUE;
}
if (changed)
nml_dbus_object_obj_changed_link(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_DBUS);
return changed;
}
static void
_dbus_managed_objects_changed_cb(GDBusConnection *connection,
const char *sender_name,
const char *arg_object_path,
const char *interface_name,
const char *signal_name,
GVariant *parameters,
gpointer user_data)
{
NMClient *self = user_data;
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
const char *log_context;
gboolean changed;
nm_assert(nm_streq0(interface_name, DBUS_INTERFACE_OBJECT_MANAGER));
if (priv->get_managed_objects_cancellable) {
/* we still wait for the initial GetManagedObjects(). Ignore the event. */
return;
}
if (nm_streq(signal_name, "InterfacesAdded")) {
gs_unref_variant GVariant *interfaces_and_properties = NULL;
const char *object_path;
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oa{sa{sv}})")))
return;
g_variant_get(parameters, "(&o@a{sa{sv}})", &object_path, &interfaces_and_properties);
log_context = "interfaces-added";
changed =
_dbus_handle_interface_added(self, log_context, object_path, interfaces_and_properties);
goto out;
}
if (nm_streq(signal_name, "InterfacesRemoved")) {
gs_free const char **interfaces = NULL;
const char *object_path;
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(oas)")))
return;
g_variant_get(parameters, "(&o^a&s)", &object_path, &interfaces);
log_context = "interfaces-removed";
changed = _dbus_handle_interface_removed(self, log_context, object_path, NULL, interfaces);
goto out;
}
return;
out:
if (changed)
_dbus_handle_changes(self, log_context, TRUE);
}
static void
_dbus_properties_changed_cb(GDBusConnection *connection,
const char *sender_name,
const char *object_path,
const char *signal_interface_name,
const char *signal_name,
GVariant *parameters,
gpointer user_data)
{
NMClient *self = user_data;
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
const char *interface_name;
gs_unref_variant GVariant *changed_properties = NULL;
gs_free const char **invalidated_properties = NULL;
const char *log_context = "properties-changed";
if (priv->get_managed_objects_cancellable) {
/* we still wait for the initial GetManagedObjects(). Ignore the event. */
return;
}
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(sa{sv}as)")))
return;
g_variant_get(parameters,
"(&s@a{sv}^a&s)",
&interface_name,
&changed_properties,
&invalidated_properties);
if (invalidated_properties && invalidated_properties[0]) {
NML_NMCLIENT_LOG_W(self,
"%s: [%s] ignore invalidated properties on interface %s",
log_context,
object_path,
interface_name);
}
if (_dbus_handle_properties_changed(self,
log_context,
object_path,
interface_name,
FALSE,
changed_properties,
NULL))
_dbus_handle_changes(self, log_context, TRUE);
}
static void
_dbus_get_managed_objects_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
NMClient *self;
NMClientPrivate *priv;
gs_unref_variant GVariant *ret = NULL;
gs_unref_variant GVariant *managed_objects = NULL;
gs_free_error GError *error = NULL;
gs_unref_object GObject *context_busy_watcher = NULL;
nm_utils_user_data_unpack(user_data, &self, &context_busy_watcher);
ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error);
nm_assert((!!ret) != (!!error));
if (!ret && nm_utils_error_is_cancelled(error))
return;
priv = NM_CLIENT_GET_PRIVATE(self);
if (ret) {
nm_assert(g_variant_is_of_type(ret, G_VARIANT_TYPE("(a{oa{sa{sv}}})")));
managed_objects = g_variant_get_child_value(ret, 0);
}
g_clear_object(&priv->get_managed_objects_cancellable);
if (!managed_objects) {
NML_NMCLIENT_LOG_D(self, "GetManagedObjects() call failed: %s", error->message);
/* hm, now that's odd. Maybe NetworkManager just quit and we are about to get
* a name-owner changed signal soon. Treat this as if we got no managed objects at all. */
} else
NML_NMCLIENT_LOG_D(self, "GetManagedObjects() completed");
if (managed_objects) {
GVariantIter iter;
const char *object_path;
GVariant *ifaces_tmp;
g_variant_iter_init(&iter, managed_objects);
while (g_variant_iter_next(&iter, "{&o@a{sa{sv}}}", &object_path, &ifaces_tmp)) {
gs_unref_variant GVariant *ifaces = ifaces_tmp;
_dbus_handle_interface_added(self, "get-managed-objects", object_path, ifaces);
}
}
/* always call _dbus_handle_changes(), even if nothing changed. We need this to complete
* initialization. */
_dbus_handle_changes(self, "get-managed-objects", TRUE);
}
/*****************************************************************************/
static void
_nm_client_get_settings_call_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
NMRemoteConnection *remote_connection;
NMClient *self;
gs_unref_variant GVariant *ret = NULL;
gs_free_error GError *error = NULL;
gs_unref_variant GVariant *settings = NULL;
NMLDBusObject *dbobj;
ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error);
if (!ret && nm_utils_error_is_cancelled(error))
return;
remote_connection = user_data;
self = _nm_object_get_client(remote_connection);
dbobj = _nm_object_get_dbobj(remote_connection);
_ASSERT_dbobj(dbobj, self);
if (!ret) {
NML_NMCLIENT_LOG_T(self,
"[%s] GetSettings() completed with error: %s",
dbobj->dbus_path->str,
error->message);
} else {
NML_NMCLIENT_LOG_T(self,
"[%s] GetSettings() completed with success",
dbobj->dbus_path->str);
g_variant_get(ret, "(@a{sa{sv}})", &settings);
}
_nm_remote_settings_get_settings_commit(remote_connection, settings);
_dbus_handle_changes_commit(self, TRUE);
}
void
_nm_client_get_settings_call(NMClient *self, NMLDBusObject *dbobj)
{
GCancellable *cancellable;
cancellable = _nm_remote_settings_get_settings_prepare(NM_REMOTE_CONNECTION(dbobj->nmobj));
_nm_client_dbus_call_simple(self,
cancellable,
dbobj->dbus_path->str,
NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
"GetSettings",
g_variant_new("()"),
G_VARIANT_TYPE("(a{sa{sv}})"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_nm_client_get_settings_call_cb,
dbobj->nmobj);
}
static void
_dbus_settings_updated_cb(GDBusConnection *connection,
const char *sender_name,
const char *object_path,
const char *signal_interface_name,
const char *signal_name,
GVariant *parameters,
gpointer user_data)
{
NMClient *self = user_data;
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
const char *log_context = "settings-updated";
NMLDBusObject *dbobj;
if (priv->get_managed_objects_cancellable) {
/* we still wait for the initial GetManagedObjects(). Ignore the event. */
return;
}
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("()")))
return;
dbobj = _dbobjs_dbobj_get_s(self, object_path);
if (!dbobj || !NM_IS_REMOTE_CONNECTION(dbobj->nmobj)) {
NML_NMCLIENT_LOG_W(self,
"%s: [%s] ignore Updated signal for non-existing setting",
log_context,
object_path);
return;
}
NML_NMCLIENT_LOG_T(self, "%s: [%s] Updated signal received", log_context, object_path);
_nm_client_get_settings_call(self, dbobj);
}
/*****************************************************************************/
static void
_dbus_nm_connection_active_state_changed_cb(GDBusConnection *connection,
const char *sender_name,
const char *object_path,
const char *signal_interface_name,
const char *signal_name,
GVariant *parameters,
gpointer user_data)
{
NMClient *self = user_data;
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
const char *log_context = "active-connection-state-changed";
NMLDBusObject *dbobj;
guint32 state;
guint32 reason;
if (priv->get_managed_objects_cancellable) {
/* we still wait for the initial GetManagedObjects(). Ignore the event. */
return;
}
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(uu)"))) {
NML_NMCLIENT_LOG_E(self,
"%s: [%s] ignore StateChanged signal with unexpected signature",
log_context,
object_path);
return;
}
dbobj = _dbobjs_dbobj_get_s(self, object_path);
if (!dbobj || !NM_IS_ACTIVE_CONNECTION(dbobj->nmobj)) {
NML_NMCLIENT_LOG_E(self,
"%s: [%s] ignore StateChanged signal for non-existing active connection",
log_context,
object_path);
return;
}
g_variant_get(parameters, "(uu)", &state, &reason);
NML_NMCLIENT_LOG_T(self, "%s: [%s] StateChanged signal received", log_context, object_path);
_nm_active_connection_state_changed_commit(NM_ACTIVE_CONNECTION(dbobj->nmobj), state, reason);
_dbus_handle_changes_commit(self, TRUE);
}
/*****************************************************************************/
static void
_dbus_nm_vpn_connection_state_changed_cb(GDBusConnection *connection,
const char *sender_name,
const char *object_path,
const char *signal_interface_name,
const char *signal_name,
GVariant *parameters,
gpointer user_data)
{
NMClient *self = user_data;
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
const char *log_context = "vpn-connection-state-changed";
NMLDBusObject *dbobj;
guint32 state;
guint32 reason;
if (priv->get_managed_objects_cancellable) {
/* we still wait for the initial GetManagedObjects(). Ignore the event. */
return;
}
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(uu)"))) {
NML_NMCLIENT_LOG_E(self,
"%s: [%s] ignore VpnStateChanged signal with unexpected signature",
log_context,
object_path);
return;
}
dbobj = _dbobjs_dbobj_get_s(self, object_path);
if (!dbobj || !NM_IS_VPN_CONNECTION(dbobj->nmobj)) {
NML_NMCLIENT_LOG_E(self,
"%s: [%s] ignore VpnStateChanged signal for non-existing vpn connection",
log_context,
object_path);
return;
}
g_variant_get(parameters, "(uu)", &state, &reason);
NML_NMCLIENT_LOG_T(self, "%s: [%s] VpnStateChanged signal received", log_context, object_path);
_nm_vpn_connection_state_changed_commit(NM_VPN_CONNECTION(dbobj->nmobj), state, reason);
_dbus_handle_changes_commit(self, TRUE);
}
/*****************************************************************************/
static void
_emit_permissions_changed(NMClient *self, const guint8 *old_permissions, const guint8 *permissions)
{
int i;
if (self->obj_base.is_disposing)
return;
if (old_permissions == permissions)
return;
for (i = 0; i < (int) G_N_ELEMENTS(nm_auth_permission_sorted); i++) {
NMClientPermission perm = nm_auth_permission_sorted[i];
NMClientPermissionResult perm_result = NM_CLIENT_PERMISSION_RESULT_UNKNOWN;
NMClientPermissionResult perm_result_old = NM_CLIENT_PERMISSION_RESULT_UNKNOWN;
if (permissions)
perm_result = permissions[perm - 1];
if (old_permissions)
perm_result_old = old_permissions[perm - 1];
if (perm_result == perm_result_old)
continue;
g_signal_emit(self, signals[PERMISSION_CHANGED], 0, (guint) perm, (guint) perm_result);
}
}
static void
_dbus_check_permissions_start_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;
NMClient *self;
NMClientPrivate *priv;
gs_unref_variant GVariant *ret = NULL;
nm_auto_free_variant_iter GVariantIter *v_permissions = NULL;
gs_free guint8 *old_permissions = NULL;
gs_free_error GError *error = NULL;
const char *pkey;
const char *pvalue;
int i;
ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error);
if (!ret && nm_utils_error_is_cancelled(error))
return;
self = user_data;
priv = NM_CLIENT_GET_PRIVATE(self);
g_clear_object(&priv->permissions_cancellable);
old_permissions = g_steal_pointer(&priv->permissions);
if (!ret) {
/* when the call completes, we always pretend success. Even a failure means
* that we fetched the permissions, however they are all unknown. */
NML_NMCLIENT_LOG_T(self, "GetPermissions call failed: %s", error->message);
goto out;
}
NML_NMCLIENT_LOG_T(self, "GetPermissions call finished with success");
g_variant_get(ret, "(a{ss})", &v_permissions);
while (g_variant_iter_next(v_permissions, "{&s&s}", &pkey, &pvalue)) {
NMClientPermission perm;
NMClientPermissionResult perm_result;
perm = nm_auth_permission_from_string(pkey);
if (perm == NM_CLIENT_PERMISSION_NONE)
continue;
perm_result = nm_client_permission_result_from_string(pvalue);
if (!priv->permissions) {
if (perm_result == NM_CLIENT_PERMISSION_RESULT_UNKNOWN)
continue;
priv->permissions = g_new(guint8, G_N_ELEMENTS(nm_auth_permission_sorted));
for (i = 0; i < (int) G_N_ELEMENTS(nm_auth_permission_sorted); i++)
priv->permissions[i] = NM_CLIENT_PERMISSION_RESULT_UNKNOWN;
}
priv->permissions[perm - 1] = perm_result;
}
out:
priv->permissions_state = NM_TERNARY_TRUE;
dbus_context = nm_g_main_context_push_thread_default_if_necessary(priv->main_context);
_emit_permissions_changed(self, old_permissions, priv->permissions);
_notify(self, PROP_PERMISSIONS_STATE);
}
static void
_dbus_check_permissions_start(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
gboolean fetch;
fetch = !NM_FLAGS_HAS((NMClientInstanceFlags) priv->instance_flags,
NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS);
nm_clear_g_cancellable(&priv->permissions_cancellable);
if (fetch) {
NML_NMCLIENT_LOG_T(self, "GetPermissions() call started...");
priv->permissions_cancellable = g_cancellable_new();
_nm_client_dbus_call_simple(self,
priv->permissions_cancellable,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"GetPermissions",
g_variant_new("()"),
G_VARIANT_TYPE("(a{ss})"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_dbus_check_permissions_start_cb,
self);
}
}
static void
_dbus_nm_check_permissions_cb(GDBusConnection *connection,
const char *sender_name,
const char *object_path,
const char *signal_interface_name,
const char *signal_name,
GVariant *parameters,
gpointer user_data)
{
NMClient *self = user_data;
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("()"))) {
NML_NMCLIENT_LOG_E(self,
"ignore CheckPermissions signal with unexpected signature %s",
g_variant_get_type_string(parameters));
return;
}
_dbus_check_permissions_start(self);
if (priv->permissions_state == NM_TERNARY_TRUE)
priv->permissions_state = NM_TERNARY_FALSE;
_notify(self, PROP_PERMISSIONS_STATE);
}
/*****************************************************************************/
static void
_property_ao_notify_changed_connections_cb(NMLDBusPropertyAO *pr_ao,
NMClient *self,
NMObject *nmobj,
gboolean is_added /* or else removed */)
{
_nm_client_notify_event_queue_emit_obj_signal(self,
G_OBJECT(self),
nmobj,
is_added,
5,
is_added ? signals[CONNECTION_ADDED]
: signals[CONNECTION_REMOVED]);
}
static void
_property_ao_notify_changed_all_devices_cb(NMLDBusPropertyAO *pr_ao,
NMClient *self,
NMObject *nmobj,
gboolean is_added /* or else removed */)
{
_nm_client_notify_event_queue_emit_obj_signal(self,
G_OBJECT(self),
nmobj,
is_added,
6,
is_added ? signals[ANY_DEVICE_ADDED]
: signals[ANY_DEVICE_REMOVED]);
}
static void
_property_ao_notify_changed_devices_cb(NMLDBusPropertyAO *pr_ao,
NMClient *self,
NMObject *nmobj,
gboolean is_added /* or else removed */)
{
_nm_client_notify_event_queue_emit_obj_signal(self,
G_OBJECT(self),
nmobj,
is_added,
7,
is_added ? signals[DEVICE_ADDED]
: signals[DEVICE_REMOVED]);
}
static void
_property_ao_notify_changed_active_connections_cb(NMLDBusPropertyAO *pr_ao,
NMClient *self,
NMObject *nmobj,
gboolean is_added /* or else removed */)
{
_nm_client_notify_event_queue_emit_obj_signal(self,
G_OBJECT(self),
nmobj,
is_added,
8,
is_added ? signals[ACTIVE_CONNECTION_ADDED]
: signals[ACTIVE_CONNECTION_REMOVED]);
}
/*****************************************************************************/
typedef struct {
NMLDBusObjWatcherWithPtr *obj_watcher;
const char *op_name;
NMLDBusObject *dbobj;
GTask *task;
GVariant *extra_results;
gpointer result;
GType gtype;
gulong cancellable_id;
} RequestWaitData;
static void
_request_wait_data_free(RequestWaitData *request_data)
{
nm_assert(!request_data->obj_watcher);
nm_assert(request_data->cancellable_id == 0);
nm_assert(!request_data->task || G_IS_TASK(request_data->task));
nm_g_object_unref(request_data->task);
nm_g_object_unref(request_data->result);
nm_g_variant_unref(request_data->extra_results);
if (request_data->dbobj)
nml_dbus_object_unref(request_data->dbobj);
nm_g_slice_free(request_data);
}
static void
_request_wait_task_return(RequestWaitData *request_data)
{
gs_unref_object GTask *task = NULL;
nm_assert(request_data);
nm_assert(G_IS_TASK(request_data->task));
nm_assert(request_data->dbobj);
nm_assert(NM_IS_OBJECT(request_data->dbobj->nmobj));
nm_assert(!request_data->result);
task = g_steal_pointer(&request_data->task);
request_data->result = g_object_ref(request_data->dbobj->nmobj);
nm_clear_g_signal_handler(g_task_get_cancellable(task), &request_data->cancellable_id);
nm_clear_pointer(&request_data->dbobj, nml_dbus_object_unref);
g_task_return_pointer(task, request_data, (GDestroyNotify) _request_wait_data_free);
}
static gboolean
_request_wait_complete(NMClient *self, RequestWaitData *request_data, gboolean force_complete)
{
NMLDBusObject *dbobj;
nm_assert(request_data);
nm_assert(!request_data->result);
nm_assert(!request_data->obj_watcher);
nm_assert(request_data->dbobj);
dbobj = request_data->dbobj;
if (dbobj->obj_state == NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY) {
NML_NMCLIENT_LOG_D(self,
"%s() succeeded with %s",
request_data->op_name,
dbobj->dbus_path->str);
nm_assert(G_TYPE_CHECK_INSTANCE_TYPE(dbobj->nmobj, request_data->gtype));
_request_wait_task_return(request_data);
return TRUE;
}
if (force_complete || dbobj->obj_state != NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY) {
if (force_complete)
NML_NMCLIENT_LOG_D(self,
"%s() succeeded with %s but object is in an unsuitable state",
request_data->op_name,
dbobj->dbus_path->str);
else
NML_NMCLIENT_LOG_W(self,
"%s() succeeded with %s but object is in an unsuitable state",
request_data->op_name,
dbobj->dbus_path->str);
g_task_return_error(
request_data->task,
g_error_new(NM_CLIENT_ERROR,
NM_CLIENT_ERROR_OBJECT_CREATION_FAILED,
_("request succeeded with %s but object is in an unsuitable state"),
dbobj->dbus_path->str));
_request_wait_data_free(request_data);
return TRUE;
}
return FALSE;
}
static void
_request_wait_complete_cb(NMClient *self, NMClientNotifyEventWithPtr *notify_event)
{
_request_wait_complete(self, notify_event->user_data, TRUE);
}
static void
_request_wait_obj_watcher_cb(NMClient *self, gpointer obj_watcher_base)
{
NMLDBusObjWatcherWithPtr *obj_watcher = obj_watcher_base;
RequestWaitData *request_data = obj_watcher->user_data;
NMLDBusObject *dbobj;
dbobj = request_data->dbobj;
if (dbobj->obj_state == NML_DBUS_OBJ_STATE_WITH_NMOBJ_NOT_READY)
return;
nm_assert(NM_IN_SET((NMLDBusObjState) dbobj->obj_state,
NML_DBUS_OBJ_STATE_WATCHED_ONLY,
NML_DBUS_OBJ_STATE_ON_DBUS,
NML_DBUS_OBJ_STATE_WITH_NMOBJ_READY));
_dbobjs_obj_watcher_unregister(self, g_steal_pointer(&request_data->obj_watcher));
nm_clear_g_signal_handler(g_task_get_cancellable(request_data->task),
&request_data->cancellable_id);
_nm_client_notify_event_queue_with_ptr(self,
NM_CLIENT_NOTIFY_EVENT_PRIO_AFTER + 30,
_request_wait_complete_cb,
request_data);
}
static void
_request_wait_cancelled_cb(GCancellable *cancellable, gpointer user_data)
{
RequestWaitData *request_data = user_data;
NMClient *self;
GError *error = NULL;
nm_assert(cancellable == g_task_get_cancellable(request_data->task));
nm_utils_error_set_cancelled(&error, FALSE, NULL);
self = g_task_get_source_object(request_data->task);
nm_clear_g_signal_handler(cancellable, &request_data->cancellable_id);
_dbobjs_obj_watcher_unregister(self, g_steal_pointer(&request_data->obj_watcher));
g_task_return_error(request_data->task, error);
_request_wait_data_free(request_data);
}
static void
_request_wait_start(GTask *task_take,
const char *op_name,
GType gtype,
const char *dbus_path,
GVariant *extra_results_take)
{
NMClient *self;
gs_unref_object GTask *task = g_steal_pointer(&task_take);
RequestWaitData *request_data;
GCancellable *cancellable;
NMLDBusObject *dbobj;
nm_assert(G_IS_TASK(task));
self = g_task_get_source_object(task);
dbobj = _dbobjs_get_nmobj(self, dbus_path, gtype);
if (!dbobj) {
NML_NMCLIENT_LOG_E(self,
"%s() succeeded with %s but object does not exist",
op_name,
dbus_path);
g_task_return_error(task,
g_error_new(NM_CLIENT_ERROR,
NM_CLIENT_ERROR_FAILED,
_("operation succeeded but object %s does not exist"),
dbus_path));
return;
}
request_data = g_slice_new(RequestWaitData);
*request_data = (RequestWaitData){
.task = g_steal_pointer(&task),
.op_name = op_name,
.gtype = gtype,
.dbobj = nml_dbus_object_ref(dbobj),
.obj_watcher = NULL,
.extra_results = g_steal_pointer(&extra_results_take),
.result = NULL,
.cancellable_id = 0,
};
if (_request_wait_complete(self, request_data, FALSE))
return;
NML_NMCLIENT_LOG_T(self,
"%s() succeeded with %s. Wait for object to become ready",
op_name,
dbobj->dbus_path->str);
request_data->obj_watcher = _dbobjs_obj_watcher_register_o(self,
dbobj,
_request_wait_obj_watcher_cb,
sizeof(NMLDBusObjWatcherWithPtr));
request_data->obj_watcher->user_data = request_data;
cancellable = g_task_get_cancellable(request_data->task);
if (cancellable) {
gulong id;
id = g_cancellable_connect(cancellable,
G_CALLBACK(_request_wait_cancelled_cb),
request_data,
NULL);
if (id == 0) {
/* the callback was invoked synchronously, which destroyed @request_data.
* We must not touch @info anymore. */
} else
request_data->cancellable_id = id;
}
}
static gpointer
_request_wait_finish(NMClient *client,
GAsyncResult *result,
gpointer source_tag,
GVariant **out_result,
GError **error)
{
RequestWaitData *request_data = NULL;
gpointer r;
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
g_return_val_if_fail(nm_g_task_is_valid(result, client, source_tag), NULL);
request_data = g_task_propagate_pointer(G_TASK(result), error);
if (!request_data) {
NM_SET_OUT(out_result, NULL);
return NULL;
}
nm_assert(NM_IS_OBJECT(request_data->result));
NM_SET_OUT(out_result, g_steal_pointer(&request_data->extra_results));
r = g_steal_pointer(&request_data->result);
nm_assert(NM_IS_OBJECT(r));
_request_wait_data_free(request_data);
return r;
}
/*****************************************************************************/
/**
* nm_client_get_instance_flags:
* @self: the #NMClient instance.
*
* Returns: the #NMClientInstanceFlags flags.
*
* Since: 1.24
*/
NMClientInstanceFlags
nm_client_get_instance_flags(NMClient *self)
{
g_return_val_if_fail(NM_IS_CLIENT(self), NM_CLIENT_INSTANCE_FLAGS_NONE);
return NM_CLIENT_GET_PRIVATE(self)->instance_flags;
}
/**
* nm_client_get_dbus_connection:
* @client: a #NMClient
*
* Gets the %GDBusConnection of the instance. This can be either passed when
* constructing the instance (as "dbus-connection" property), or it will be
* automatically initialized during async/sync init.
*
* Returns: (transfer none): the D-Bus connection of the client, or %NULL if none is set.
*
* Since: 1.22
**/
GDBusConnection *
nm_client_get_dbus_connection(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return NM_CLIENT_GET_PRIVATE(client)->dbus_connection;
}
/**
* nm_client_get_dbus_name_owner:
* @client: a #NMClient
*
* Returns: (transfer none): the current name owner of the D-Bus service of NetworkManager.
*
* Since: 1.22
**/
const char *
nm_client_get_dbus_name_owner(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return NM_CLIENT_GET_PRIVATE(client)->name_owner;
}
/**
* nm_client_get_version:
* @client: a #NMClient
*
* Gets NetworkManager version.
*
* Returns: string with the version (or %NULL if NetworkManager is not running)
**/
const char *
nm_client_get_version(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return NM_CLIENT_GET_PRIVATE(client)->nm.version;
}
/**
* nm_client_get_state:
* @client: a #NMClient
*
* Gets the current daemon state.
*
* Returns: the current %NMState
**/
NMState
nm_client_get_state(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NM_STATE_UNKNOWN);
return NM_CLIENT_GET_PRIVATE(client)->nm.state;
}
/**
* nm_client_get_startup:
* @client: a #NMClient
*
* Tests whether the daemon is still in the process of activating
* connections at startup.
*
* Returns: whether the daemon is still starting up
**/
gboolean
nm_client_get_startup(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm.startup;
}
static void
_set_nm_running(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
gboolean nm_running;
nm_running = priv->name_owner && !priv->get_managed_objects_cancellable;
if (priv->nm_running != nm_running) {
priv->nm_running = nm_running;
_notify(self, PROP_NM_RUNNING);
}
}
/**
* nm_client_get_nm_running:
* @client: a #NMClient
*
* Determines whether the daemon is running.
*
* Returns: %TRUE if the daemon is running
**/
gboolean
nm_client_get_nm_running(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm_running;
}
/**
* nm_client_get_object_by_path:
* @client: the #NMClient instance
* @dbus_path: the D-Bus path of the object to look up
*
* Returns: (transfer none): the #NMObject instance that is
* cached under @dbus_path, or %NULL if no such object exists.
*
* Since: 1.24
*/
NMObject *
nm_client_get_object_by_path(NMClient *client, const char *dbus_path)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
g_return_val_if_fail(dbus_path, NULL);
return _dbobjs_get_nmobj_unpack_visible(client, dbus_path, G_TYPE_NONE);
}
/**
* nm_client_get_metered:
* @client: a #NMClient
*
* Returns: whether the default route is metered.
*
* Since: 1.22
*/
NMMetered
nm_client_get_metered(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NM_METERED_UNKNOWN);
return NM_CLIENT_GET_PRIVATE(client)->nm.metered;
}
/**
* nm_client_networking_get_enabled:
* @client: a #NMClient
*
* Whether networking is enabled or disabled.
*
* Returns: %TRUE if networking is enabled, %FALSE if networking is disabled
**/
gboolean
nm_client_networking_get_enabled(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm.networking_enabled;
}
/**
* nm_client_networking_set_enabled:
* @client: a #NMClient
* @enabled: %TRUE to set networking enabled, %FALSE to set networking disabled
* @error: (allow-none): return location for a #GError, or %NULL
*
* Enables or disables networking. When networking is disabled, all controlled
* interfaces are disconnected and deactivated. When networking is enabled,
* all controlled interfaces are available for activation.
*
* Returns: %TRUE on success, %FALSE otherwise
*
* Deprecated: 1.22: Use the async command nm_client_dbus_call() on %NM_DBUS_PATH,
* %NM_DBUS_INTERFACE to call "Enable" with "(b)" arguments and no return value.
**/
gboolean
nm_client_networking_set_enabled(NMClient *client, gboolean enable, GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return _nm_client_dbus_call_sync_void(client,
NULL,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"Enable",
g_variant_new("(b)", enable),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
TRUE,
error);
}
/**
* nm_client_wireless_get_enabled:
* @client: a #NMClient
*
* Determines whether the wireless is enabled.
*
* Returns: %TRUE if wireless is enabled
**/
gboolean
nm_client_wireless_get_enabled(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm.wireless_enabled;
}
/**
* nm_client_wireless_set_enabled:
* @client: a #NMClient
* @enabled: %TRUE to enable wireless
*
* Enables or disables wireless devices.
*
* Deprecated: 1.22: Use the async command nm_client_dbus_set_property() on %NM_DBUS_PATH,
* %NM_DBUS_INTERFACE to set "WirelessEnabled" property to a "(b)" value.
*/
void
nm_client_wireless_set_enabled(NMClient *client, gboolean enabled)
{
g_return_if_fail(NM_IS_CLIENT(client));
_nm_client_set_property_sync_legacy(client,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"WirelessEnabled",
"b",
enabled);
}
/**
* nm_client_wireless_hardware_get_enabled:
* @client: a #NMClient
*
* Determines whether the wireless hardware is enabled.
*
* Returns: %TRUE if the wireless hardware is enabled
**/
gboolean
nm_client_wireless_hardware_get_enabled(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm.wireless_hardware_enabled;
}
/**
* nm_client_get_radio_flags:
* @client: a #NMClient
*
* Get radio flags.
*
* Returns: the #NMRadioFlags.
*
* Since: 1.38
**/
NMRadioFlags
nm_client_get_radio_flags(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NM_RADIO_FLAG_NONE);
return NM_CLIENT_GET_PRIVATE(client)->nm.radio_flags;
}
/**
* nm_client_wwan_get_enabled:
* @client: a #NMClient
*
* Determines whether WWAN is enabled.
*
* Returns: %TRUE if WWAN is enabled
**/
gboolean
nm_client_wwan_get_enabled(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm.wwan_enabled;
}
/**
* nm_client_wwan_set_enabled:
* @client: a #NMClient
* @enabled: %TRUE to enable WWAN
*
* Enables or disables WWAN devices.
*
* Deprecated: 1.22: Use the async command nm_client_dbus_set_property() on %NM_DBUS_PATH,
* %NM_DBUS_INTERFACE to set "WwanEnabled" property to a "(b)" value.
**/
void
nm_client_wwan_set_enabled(NMClient *client, gboolean enabled)
{
g_return_if_fail(NM_IS_CLIENT(client));
_nm_client_set_property_sync_legacy(client,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"WwanEnabled",
"b",
enabled);
}
/**
* nm_client_wwan_hardware_get_enabled:
* @client: a #NMClient
*
* Determines whether the WWAN hardware is enabled.
*
* Returns: %TRUE if the WWAN hardware is enabled
**/
gboolean
nm_client_wwan_hardware_get_enabled(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm.wwan_hardware_enabled;
}
/**
* nm_client_wimax_get_enabled:
* @client: a #NMClient
*
* Determines whether WiMAX is enabled.
*
* Returns: %TRUE if WiMAX is enabled
*
* Deprecated: 1.22: This function always returns FALSE because WiMax is no longer supported.
**/
gboolean
nm_client_wimax_get_enabled(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return FALSE;
}
/**
* nm_client_wimax_set_enabled:
* @client: a #NMClient
* @enabled: %TRUE to enable WiMAX
*
* Enables or disables WiMAX devices.
*
* Deprecated: 1.22: This function does nothing because WiMax is no longer supported.
**/
void
nm_client_wimax_set_enabled(NMClient *client, gboolean enabled)
{
g_return_if_fail(NM_IS_CLIENT(client));
}
/**
* nm_client_wimax_hardware_get_enabled:
* @client: a #NMClient
*
* Determines whether the WiMAX hardware is enabled.
*
* Returns: %TRUE if the WiMAX hardware is enabled
*
* Deprecated: 1.22: This function always returns FALSE because WiMax is no longer supported.
**/
gboolean
nm_client_wimax_hardware_get_enabled(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return FALSE;
}
/**
* nm_client_connectivity_check_get_available:
* @client: a #NMClient
*
* Determine whether connectivity checking is available. This
* requires that the URI of a connectivity service has been set in the
* configuration file.
*
* Returns: %TRUE if connectivity checking is available.
*
* Since: 1.10
*/
gboolean
nm_client_connectivity_check_get_available(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm.connectivity_check_available;
}
/**
* nm_client_connectivity_check_get_enabled:
* @client: a #NMClient
*
* Determine whether connectivity checking is enabled.
*
* Returns: %TRUE if connectivity checking is enabled.
*
* Since: 1.10
*/
gboolean
nm_client_connectivity_check_get_enabled(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
return NM_CLIENT_GET_PRIVATE(client)->nm.connectivity_check_enabled;
}
/**
* nm_client_connectivity_check_set_enabled:
* @client: a #NMClient
* @enabled: %TRUE to enable connectivity checking
*
* Enable or disable connectivity checking. Note that if a
* connectivity checking URI has not been configured, this will not
* have any effect.
*
* Since: 1.10
*
* Deprecated: 1.22: Use the async command nm_client_dbus_set_property() on %NM_DBUS_PATH,
* %NM_DBUS_INTERFACE to set "ConnectivityCheckEnabled" property to a "(b)" value.
*/
void
nm_client_connectivity_check_set_enabled(NMClient *client, gboolean enabled)
{
g_return_if_fail(NM_IS_CLIENT(client));
_nm_client_set_property_sync_legacy(client,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"ConnectivityCheckEnabled",
"b",
enabled);
}
/**
* nm_client_connectivity_check_get_uri:
* @client: a #NMClient
*
* Get the URI that will be queried to determine if there is internet
* connectivity.
*
* Returns: (transfer none): the connectivity URI in use
*
* Since: 1.20
*/
const char *
nm_client_connectivity_check_get_uri(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return NM_CLIENT_GET_PRIVATE(client)->nm.connectivity_check_uri;
}
/**
* nm_client_get_logging:
* @client: a #NMClient
* @level: (allow-none): return location for logging level string
* @domains: (allow-none): return location for log domains string. The string is
* a list of domains separated by ","
* @error: (allow-none): return location for a #GError, or %NULL
*
* Gets NetworkManager current logging level and domains.
*
* Returns: %TRUE on success, %FALSE otherwise
*
* Deprecated: 1.22: Use the async command nm_client_dbus_call() on %NM_DBUS_PATH,
* %NM_DBUS_INTERFACE to call "GetLogging" with no arguments to get "(ss)" for level
* and domains.
**/
gboolean
nm_client_get_logging(NMClient *client, char **level, char **domains, GError **error)
{
gs_unref_variant GVariant *ret = NULL;
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(level == NULL || *level == NULL, FALSE);
g_return_val_if_fail(domains == NULL || *domains == NULL, FALSE);
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
ret = _nm_client_dbus_call_sync(client,
NULL,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"GetLogging",
g_variant_new("()"),
G_VARIANT_TYPE("(ss)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
TRUE,
error);
if (!ret)
return FALSE;
g_variant_get(ret, "(ss)", level, domains);
return TRUE;
}
/**
* nm_client_set_logging:
* @client: a #NMClient
* @level: (allow-none): logging level to set (%NULL or an empty string for no change)
* @domains: (allow-none): logging domains to set. The string should be a list of log
* domains separated by ",". (%NULL or an empty string for no change)
* @error: (allow-none): return location for a #GError, or %NULL
*
* Sets NetworkManager logging level and/or domains.
*
* Returns: %TRUE on success, %FALSE otherwise
*
* Deprecated: 1.22: Use the async command nm_client_dbus_call() on %NM_DBUS_PATH,
* %NM_DBUS_INTERFACE to call "SetLogging" with "(ss)" arguments for level and domains.
**/
gboolean
nm_client_set_logging(NMClient *client, const char *level, const char *domains, GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
return _nm_client_dbus_call_sync_void(client,
NULL,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"SetLogging",
g_variant_new("(ss)", level ?: "", domains ?: ""),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
TRUE,
error);
}
/**
* nm_client_get_permission_result:
* @client: a #NMClient
* @permission: the permission for which to return the result, one of #NMClientPermission
*
* Requests the result of a specific permission, which indicates whether the
* client can or cannot perform the action the permission represents
*
* Returns: the permission's result, one of #NMClientPermissionResult
**/
NMClientPermissionResult
nm_client_get_permission_result(NMClient *client, NMClientPermission permission)
{
NMClientPrivate *priv;
NMClientPermissionResult result = NM_CLIENT_PERMISSION_RESULT_UNKNOWN;
g_return_val_if_fail(NM_IS_CLIENT(client), NM_CLIENT_PERMISSION_RESULT_UNKNOWN);
if (permission > NM_CLIENT_PERMISSION_NONE && permission <= NM_CLIENT_PERMISSION_LAST) {
priv = NM_CLIENT_GET_PRIVATE(client);
if (priv->permissions)
result = priv->permissions[permission - 1];
}
return result;
}
/**
* nm_client_get_permissions_state:
* @self: the #NMClient instance
*
* Returns: the state of the cached permissions. %NM_TERNARY_DEFAULT
* means that no permissions result was yet received. All permissions
* are unknown. %NM_TERNARY_TRUE means that the permissions got received
* and are cached. %%NM_TERNARY_FALSE means that permissions are cached,
* but they are invalided as "CheckPermissions" signal was received
* in the meantime.
*
* Since: 1.24
*/
NMTernary
nm_client_get_permissions_state(NMClient *self)
{
g_return_val_if_fail(NM_IS_CLIENT(self), NM_TERNARY_DEFAULT);
return NM_CLIENT_GET_PRIVATE(self)->permissions_state;
}
/**
* nm_client_get_connectivity:
* @client: an #NMClient
*
* Gets the current network connectivity state. Contrast
* nm_client_check_connectivity() and
* nm_client_check_connectivity_async(), which re-check the
* connectivity state first before returning any information.
*
* Returns: the current connectivity state
*/
NMConnectivityState
nm_client_get_connectivity(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NM_CONNECTIVITY_UNKNOWN);
return NM_CLIENT_GET_PRIVATE(client)->nm.connectivity;
}
/**
* nm_client_check_connectivity:
* @client: an #NMClient
* @cancellable: a #GCancellable
* @error: return location for a #GError
*
* Updates the network connectivity state and returns the (new)
* current state. Contrast nm_client_get_connectivity(), which returns
* the most recent known state without re-checking.
*
* This is a blocking call; use nm_client_check_connectivity_async()
* if you do not want to block.
*
* Returns: the (new) current connectivity state
*
* Deprecated: 1.22: Use nm_client_check_connectivity_async() or GDBusConnection.
*/
NMConnectivityState
nm_client_check_connectivity(NMClient *client, GCancellable *cancellable, GError **error)
{
NMClientPrivate *priv;
gs_unref_variant GVariant *ret = NULL;
guint32 connectivity;
g_return_val_if_fail(NM_IS_CLIENT(client), NM_CONNECTIVITY_UNKNOWN);
ret = _nm_client_dbus_call_sync(client,
cancellable,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"CheckConnectivity",
g_variant_new("()"),
G_VARIANT_TYPE("(u)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
TRUE,
error);
if (!ret)
return NM_CONNECTIVITY_UNKNOWN;
g_variant_get(ret, "(u)", &connectivity);
/* upon receiving the synchronous response, we hack the NMClient state
* and update the property outside the ordered D-Bus messages (like
* "PropertiesChanged" signals).
*
* This is really ugly, we shouldn't do this. */
priv = NM_CLIENT_GET_PRIVATE(client);
if (priv->nm.connectivity != connectivity) {
priv->nm.connectivity = connectivity;
_notify(client, PROP_CONNECTIVITY);
}
return connectivity;
}
/**
* nm_client_check_connectivity_async:
* @client: an #NMClient
* @cancellable: a #GCancellable
* @callback: callback to call with the result
* @user_data: data for @callback.
*
* Asynchronously updates the network connectivity state and invokes
* @callback when complete. Contrast nm_client_get_connectivity(),
* which (immediately) returns the most recent known state without
* re-checking, and nm_client_check_connectivity(), which blocks.
*/
void
nm_client_check_connectivity_async(NMClient *client,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
_nm_client_dbus_call(client,
client,
nm_client_check_connectivity_async,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"CheckConnectivity",
g_variant_new("()"),
G_VARIANT_TYPE("(u)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
}
/**
* nm_client_check_connectivity_finish:
* @client: an #NMClient
* @result: the #GAsyncResult
* @error: return location for a #GError
*
* Retrieves the result of an nm_client_check_connectivity_async()
* call.
*
* Returns: the (new) current connectivity state
*/
NMConnectivityState
nm_client_check_connectivity_finish(NMClient *client, GAsyncResult *result, GError **error)
{
gs_unref_variant GVariant *ret = NULL;
guint32 connectivity;
g_return_val_if_fail(NM_IS_CLIENT(client), NM_CONNECTIVITY_UNKNOWN);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_check_connectivity_async),
NM_CONNECTIVITY_UNKNOWN);
ret = g_task_propagate_pointer(G_TASK(result), error);
if (!ret)
return NM_CONNECTIVITY_UNKNOWN;
g_variant_get(ret, "(u)", &connectivity);
return connectivity;
}
/**
* nm_client_save_hostname:
* @client: the %NMClient
* @hostname: (allow-none): the new persistent hostname to set, or %NULL to
* clear any existing persistent hostname
* @cancellable: a #GCancellable, or %NULL
* @error: return location for #GError
*
* Requests that the machine's persistent hostname be set to the specified value
* or cleared.
*
* Returns: %TRUE if the request was successful, %FALSE if it failed
*
* Deprecated: 1.22: Use nm_client_save_hostname_async() or GDBusConnection.
**/
gboolean
nm_client_save_hostname(NMClient *client,
const char *hostname,
GCancellable *cancellable,
GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable), FALSE);
return _nm_client_dbus_call_sync_void(client,
cancellable,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"SaveHostname",
g_variant_new("(s)", hostname ?: ""),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
TRUE,
error);
}
/**
* nm_client_save_hostname_async:
* @client: the %NMClient
* @hostname: (allow-none): the new persistent hostname to set, or %NULL to
* clear any existing persistent hostname
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Requests that the machine's persistent hostname be set to the specified value
* or cleared.
**/
void
nm_client_save_hostname_async(NMClient *client,
const char *hostname,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
_nm_client_dbus_call(client,
client,
nm_client_save_hostname_async,
cancellable,
callback,
user_data,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"SaveHostname",
g_variant_new("(s)", hostname ?: ""),
G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
}
/**
* nm_client_save_hostname_finish:
* @client: the %NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: return location for #GError
*
* Gets the result of an nm_client_save_hostname_async() call.
*
* Returns: %TRUE if the request was successful, %FALSE if it failed
**/
gboolean
nm_client_save_hostname_finish(NMClient *client, GAsyncResult *result, GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_save_hostname_async), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/*****************************************************************************/
/* Devices */
/*****************************************************************************/
/**
* nm_client_get_devices:
* @client: a #NMClient
*
* Gets all the known network devices. Use nm_device_get_type() or the
* <literal>NM_IS_DEVICE_XXXX</literal> functions to determine what kind of
* device member of the returned array is, and then you may use device-specific
* methods such as nm_device_ethernet_get_hw_address().
*
* Returns: (transfer none) (element-type NMDevice): a #GPtrArray
* containing all the #NMDevices. The returned array is owned by the
* #NMClient object and should not be modified.
**/
const GPtrArray *
nm_client_get_devices(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return nml_dbus_property_ao_get_objs_as_ptrarray(
&NM_CLIENT_GET_PRIVATE(client)->nm.property_ao[PROPERTY_AO_IDX_DEVICES]);
}
/**
* nm_client_get_all_devices:
* @client: a #NMClient
*
* Gets both real devices and device placeholders (eg, software devices which
* do not currently exist, but could be created automatically by NetworkManager
* if one of their NMDevice::ActivatableConnections was activated). Use
* nm_device_is_real() to determine whether each device is a real device or
* a placeholder.
*
* Use nm_device_get_type() or the NM_IS_DEVICE_XXXX() functions to determine
* what kind of device each member of the returned array is, and then you may
* use device-specific methods such as nm_device_ethernet_get_hw_address().
*
* Returns: (transfer none) (element-type NMDevice): a #GPtrArray
* containing all the #NMDevices. The returned array is owned by the
* #NMClient object and should not be modified.
*
* Since: 1.2
**/
const GPtrArray *
nm_client_get_all_devices(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return nml_dbus_property_ao_get_objs_as_ptrarray(
&NM_CLIENT_GET_PRIVATE(client)->nm.property_ao[PROPERTY_AO_IDX_ALL_DEVICES]);
}
/**
* nm_client_get_device_by_path:
* @client: a #NMClient
* @object_path: the object path to search for
*
* Gets a #NMDevice from a #NMClient.
*
* Returns: (transfer none): the #NMDevice for the given @object_path or %NULL if none is found.
**/
NMDevice *
nm_client_get_device_by_path(NMClient *client, const char *object_path)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
g_return_val_if_fail(object_path, NULL);
return _dbobjs_get_nmobj_unpack_visible(client, object_path, NM_TYPE_DEVICE);
}
/**
* nm_client_get_device_by_iface:
* @client: a #NMClient
* @iface: the interface name to search for
*
* Gets a #NMDevice from a #NMClient.
*
* Returns: (transfer none): the #NMDevice for the given @iface or %NULL if none is found.
**/
NMDevice *
nm_client_get_device_by_iface(NMClient *client, const char *iface)
{
const GPtrArray *devices;
guint i;
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
g_return_val_if_fail(iface, NULL);
devices = nm_client_get_devices(client);
for (i = 0; i < devices->len; i++) {
NMDevice *candidate = g_ptr_array_index(devices, i);
if (nm_streq0(nm_device_get_iface(candidate), iface))
return candidate;
}
return NULL;
}
/*****************************************************************************/
/* Active Connections */
/*****************************************************************************/
/**
* nm_client_get_active_connections:
* @client: a #NMClient
*
* Gets the active connections.
*
* Returns: (transfer none) (element-type NMActiveConnection): a #GPtrArray
* containing all the active #NMActiveConnections.
* The returned array is owned by the client and should not be modified.
**/
const GPtrArray *
nm_client_get_active_connections(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return nml_dbus_property_ao_get_objs_as_ptrarray(
&NM_CLIENT_GET_PRIVATE(client)->nm.property_ao[PROPERTY_AO_IDX_ACTIVE_CONNECTIONS]);
}
/**
* nm_client_get_primary_connection:
* @client: an #NMClient
*
* Gets the #NMActiveConnection corresponding to the primary active
* network device.
*
* In particular, when there is no VPN active, or the VPN does not
* have the default route, this returns the active connection that has
* the default route. If there is a VPN active with the default route,
* then this function returns the active connection that contains the
* route to the VPN endpoint.
*
* If there is no default route, or the default route is over a
* non-NetworkManager-recognized device, this will return %NULL.
*
* Returns: (transfer none): the appropriate #NMActiveConnection, if
* any
*/
NMActiveConnection *
nm_client_get_primary_connection(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return nml_dbus_property_o_get_obj(
&NM_CLIENT_GET_PRIVATE(client)->nm.property_o[PROPERTY_O_IDX_NM_PRIMAY_CONNECTION]);
}
/**
* nm_client_get_activating_connection:
* @client: an #NMClient
*
* Gets the #NMActiveConnection corresponding to a
* currently-activating connection that is expected to become the new
* #NMClient:primary-connection upon successful activation.
*
* Returns: (transfer none): the appropriate #NMActiveConnection, if
* any.
*/
NMActiveConnection *
nm_client_get_activating_connection(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return nml_dbus_property_o_get_obj(
&NM_CLIENT_GET_PRIVATE(client)->nm.property_o[PROPERTY_O_IDX_NM_ACTIVATING_CONNECTION]);
}
/*****************************************************************************/
static void
activate_connection_cb(GObject *object, GAsyncResult *result, gpointer user_data)
{
gs_unref_object GTask *task = user_data;
gs_unref_variant GVariant *ret = NULL;
const char *v_active_connection;
GError *error = NULL;
ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(object), result, &error);
if (!ret) {
if (!nm_utils_error_is_cancelled(error))
g_dbus_error_strip_remote_error(error);
g_task_return_error(task, error);
return;
}
g_variant_get(ret, "(&o)", &v_active_connection);
_request_wait_start(g_steal_pointer(&task),
"ActivateConnection",
NM_TYPE_ACTIVE_CONNECTION,
v_active_connection,
NULL);
}
/**
* nm_client_activate_connection_async:
* @client: a #NMClient
* @connection: (allow-none): an #NMConnection
* @device: (allow-none): the #NMDevice
* @specific_object: (allow-none): the object path of a connection-type-specific
* object this activation should use. This parameter is currently ignored for
* wired and mobile broadband connections, and the value of %NULL should be used
* (ie, no specific object). For Wi-Fi or WiMAX connections, pass the object
* path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can
* get using nm_object_get_path(), and which will be used to complete the
* details of the newly added connection.
* @cancellable: a #GCancellable, or %NULL
* @callback: callback to be called when the activation has started
* @user_data: caller-specific data passed to @callback
*
* Asynchronously starts a connection to a particular network using the
* configuration settings from @connection and the network device @device.
* Certain connection types also take a "specific object" which is the object
* path of a connection- specific object, like an #NMAccessPoint for Wi-Fi
* connections, or an #NMWimaxNsp for WiMAX connections, to which you wish to
* connect. If the specific object is not given, NetworkManager can, in some
* cases, automatically determine which network to connect to given the settings
* in @connection.
*
* If @connection is not given for a device-based activation, NetworkManager
* picks the best available connection for the device and activates it.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can use the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
**/
void
nm_client_activate_connection_async(NMClient *client,
NMConnection *connection,
NMDevice *device,
const char *specific_object,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
const char *arg_connection = NULL;
const char *arg_device = NULL;
g_return_if_fail(NM_IS_CLIENT(client));
if (connection) {
g_return_if_fail(NM_IS_CONNECTION(connection));
arg_connection = nm_connection_get_path(connection);
g_return_if_fail(arg_connection);
}
if (device) {
g_return_if_fail(NM_IS_DEVICE(device));
arg_device = nm_object_get_path(NM_OBJECT(device));
g_return_if_fail(arg_device);
}
NML_NMCLIENT_LOG_T(
client,
"ActivateConnection() for connection \"%s\", device \"%s\", specific_object \"%s",
arg_connection ?: "/",
arg_device ?: "/",
specific_object ?: "/");
_nm_client_dbus_call(
client,
client,
nm_client_activate_connection_async,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"ActivateConnection",
g_variant_new("(ooo)", arg_connection ?: "/", arg_device ?: "/", specific_object ?: "/"),
G_VARIANT_TYPE("(o)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
activate_connection_cb);
}
/**
* nm_client_activate_connection_finish:
* @client: an #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_activate_connection_async().
*
* Returns: (transfer full): the new #NMActiveConnection on success, %NULL on
* failure, in which case @error will be set.
**/
NMActiveConnection *
nm_client_activate_connection_finish(NMClient *client, GAsyncResult *result, GError **error)
{
return NM_ACTIVE_CONNECTION(
_request_wait_finish(client, result, nm_client_activate_connection_async, NULL, error));
}
/*****************************************************************************/
static void
_add_and_activate_connection_done(GObject *object,
GAsyncResult *result,
gboolean use_add_and_activate_v2,
GTask *task_take)
{
_nm_unused gs_unref_object GTask *task = task_take;
gs_unref_variant GVariant *ret = NULL;
GError *error = NULL;
gs_unref_variant GVariant *v_result = NULL;
const char *v_active_connection;
const char *v_path;
ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(object), result, &error);
if (!ret) {
if (!nm_utils_error_is_cancelled(error))
g_dbus_error_strip_remote_error(error);
g_task_return_error(task, error);
return;
}
if (use_add_and_activate_v2) {
g_variant_get(ret, "(&o&o@a{sv})", &v_path, &v_active_connection, &v_result);
} else {
g_variant_get(ret, "(&o&o)", &v_path, &v_active_connection);
}
_request_wait_start(g_steal_pointer(&task),
"AddAndActivateConnection",
NM_TYPE_ACTIVE_CONNECTION,
v_active_connection,
g_steal_pointer(&v_result));
}
static void
_add_and_activate_connection_v1_cb(GObject *object, GAsyncResult *result, gpointer user_data)
{
_add_and_activate_connection_done(object, result, FALSE, user_data);
}
static void
_add_and_activate_connection_v2_cb(GObject *object, GAsyncResult *result, gpointer user_data)
{
_add_and_activate_connection_done(object, result, TRUE, user_data);
}
static void
_add_and_activate_connection(NMClient *self,
gboolean is_v2,
NMConnection *partial,
NMDevice *device,
const char *specific_object,
GVariant *options,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GVariant *arg_connection = NULL;
gboolean use_add_and_activate_v2 = FALSE;
const char *arg_device = NULL;
gpointer source_tag;
g_return_if_fail(NM_IS_CLIENT(self));
g_return_if_fail(!partial || NM_IS_CONNECTION(partial));
if (device) {
g_return_if_fail(NM_IS_DEVICE(device));
arg_device = nm_object_get_path(NM_OBJECT(device));
g_return_if_fail(arg_device);
}
if (partial)
arg_connection = nm_connection_to_dbus(partial, NM_CONNECTION_SERIALIZE_ALL);
if (!arg_connection)
arg_connection = nm_g_variant_singleton_aLsaLsvII();
if (is_v2) {
if (!options)
options = nm_g_variant_singleton_aLsvI();
use_add_and_activate_v2 = TRUE;
source_tag = nm_client_add_and_activate_connection2;
} else {
if (options) {
if (g_variant_n_children(options) > 0)
use_add_and_activate_v2 = TRUE;
else
nm_clear_pointer(&options, nm_g_variant_unref_floating);
}
source_tag = nm_client_add_and_activate_connection_async;
}
NML_NMCLIENT_LOG_D(self, "AddAndActivateConnection() started...");
if (use_add_and_activate_v2) {
_nm_client_dbus_call(self,
self,
source_tag,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"AddAndActivateConnection2",
g_variant_new("(@a{sa{sv}}oo@a{sv})",
arg_connection,
arg_device ?: "/",
specific_object ?: "/",
options),
G_VARIANT_TYPE("(ooa{sv})"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_add_and_activate_connection_v2_cb);
} else {
_nm_client_dbus_call(self,
self,
source_tag,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"AddAndActivateConnection",
g_variant_new("(@a{sa{sv}}oo)",
arg_connection,
arg_device ?: "/",
specific_object ?: "/"),
G_VARIANT_TYPE("(oo)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_add_and_activate_connection_v1_cb);
}
}
/**
* nm_client_add_and_activate_connection_async:
* @client: a #NMClient
* @partial: (allow-none): an #NMConnection to add; the connection may be
* partially filled (or even %NULL) and will be completed by NetworkManager
* using the given @device and @specific_object before being added
* @device: (allow-none): the #NMDevice
* @specific_object: (allow-none): the object path of a connection-type-specific
* object this activation should use. This parameter is currently ignored for
* wired and mobile broadband connections, and the value of %NULL should be used
* (ie, no specific object). For Wi-Fi or WiMAX connections, pass the object
* path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can
* get using nm_object_get_path(), and which will be used to complete the
* details of the newly added connection.
* If the variant is floating, it will be consumed.
* @cancellable: a #GCancellable, or %NULL
* @callback: callback to be called when the activation has started
* @user_data: caller-specific data passed to @callback
*
* Adds a new connection using the given details (if any) as a template,
* automatically filling in missing settings with the capabilities of the given
* device and specific object. The new connection is then asynchronously
* activated as with nm_client_activate_connection_async(). Cannot be used for
* VPN connections at this time.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can used the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
**/
void
nm_client_add_and_activate_connection_async(NMClient *client,
NMConnection *partial,
NMDevice *device,
const char *specific_object,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
_add_and_activate_connection(client,
FALSE,
partial,
device,
specific_object,
NULL,
cancellable,
callback,
user_data);
}
/**
* nm_client_add_and_activate_connection_finish:
* @client: an #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_add_and_activate_connection_async().
*
* You can call nm_active_connection_get_connection() on the returned
* #NMActiveConnection to find the path of the created #NMConnection.
*
* Returns: (transfer full): the new #NMActiveConnection on success, %NULL on
* failure, in which case @error will be set.
**/
NMActiveConnection *
nm_client_add_and_activate_connection_finish(NMClient *client, GAsyncResult *result, GError **error)
{
return NM_ACTIVE_CONNECTION(_request_wait_finish(client,
result,
nm_client_add_and_activate_connection_async,
NULL,
error));
}
/**
* nm_client_add_and_activate_connection2:
* @client: a #NMClient
* @partial: (allow-none): an #NMConnection to add; the connection may be
* partially filled (or even %NULL) and will be completed by NetworkManager
* using the given @device and @specific_object before being added
* @device: (allow-none): the #NMDevice
* @specific_object: (allow-none): the object path of a connection-type-specific
* object this activation should use. This parameter is currently ignored for
* wired and mobile broadband connections, and the value of %NULL should be used
* (i.e., no specific object). For Wi-Fi or WiMAX connections, pass the object
* path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can
* get using nm_object_get_path(), and which will be used to complete the
* details of the newly added connection.
* @options: a #GVariant containing a dictionary with options, or %NULL
* @cancellable: a #GCancellable, or %NULL
* @callback: callback to be called when the activation has started
* @user_data: caller-specific data passed to @callback
*
* Adds a new connection using the given details (if any) as a template,
* automatically filling in missing settings with the capabilities of the given
* device and specific object. The new connection is then asynchronously
* activated as with nm_client_activate_connection_async(). Cannot be used for
* VPN connections at this time.
*
* Note that the callback is invoked when NetworkManager has started activating
* the new connection, not when it finishes. You can used the returned
* #NMActiveConnection object (in particular, #NMActiveConnection:state) to
* track the activation to its completion.
*
* This is identical to nm_client_add_and_activate_connection_async() but takes
* a further @options parameter. Currently, the following options are supported
* by the daemon:
* * "persist": A string describing how the connection should be stored.
* The default is "disk", but it can be modified to "memory" (until
* the daemon quits) or "volatile" (will be deleted on disconnect).
* * "bind-activation": Bind the connection lifetime to something. The default is "none",
* meaning an explicit disconnect is needed. The value "dbus-client"
* means the connection will automatically be deactivated when the calling
* D-Bus client disappears from the system bus.
*
* Since: 1.16
**/
void
nm_client_add_and_activate_connection2(NMClient *client,
NMConnection *partial,
NMDevice *device,
const char *specific_object,
GVariant *options,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
_add_and_activate_connection(client,
TRUE,
partial,
device,
specific_object,
options,
cancellable,
callback,
user_data);
}
/**
* nm_client_add_and_activate_connection2_finish:
* @client: an #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
* @out_result: (allow-none) (transfer full) (out): the output result
* of type "a{sv}" returned by D-Bus' AddAndActivate2 call. Currently, no
* output is implemented yet.
*
* Gets the result of a call to nm_client_add_and_activate_connection2().
*
* You can call nm_active_connection_get_connection() on the returned
* #NMActiveConnection to find the path of the created #NMConnection.
*
* Returns: (transfer full): the new #NMActiveConnection on success, %NULL on
* failure, in which case @error will be set.
*
* Since: 1.16
**/
NMActiveConnection *
nm_client_add_and_activate_connection2_finish(NMClient *client,
GAsyncResult *result,
GVariant **out_result,
GError **error)
{
return NM_ACTIVE_CONNECTION(_request_wait_finish(client,
result,
nm_client_add_and_activate_connection2,
out_result,
error));
}
/*****************************************************************************/
/**
* nm_client_deactivate_connection:
* @client: a #NMClient
* @active: the #NMActiveConnection to deactivate
* @cancellable: a #GCancellable, or %NULL
* @error: location for a #GError, or %NULL
*
* Deactivates an active #NMActiveConnection.
*
* Returns: success or failure
*
* Deprecated: 1.22: Use nm_client_deactivate_connection_async() or GDBusConnection.
**/
gboolean
nm_client_deactivate_connection(NMClient *client,
NMActiveConnection *active,
GCancellable *cancellable,
GError **error)
{
const char *active_path;
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(active), FALSE);
active_path = nm_object_get_path(NM_OBJECT(active));
g_return_val_if_fail(active_path, FALSE);
return _nm_client_dbus_call_sync_void(client,
cancellable,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"DeactivateConnection",
g_variant_new("(o)", active_path),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
TRUE,
error);
}
/**
* nm_client_deactivate_connection_async:
* @client: a #NMClient
* @active: the #NMActiveConnection to deactivate
* @cancellable: a #GCancellable, or %NULL
* @callback: callback to be called when the deactivation has completed
* @user_data: caller-specific data passed to @callback
*
* Asynchronously deactivates an active #NMActiveConnection.
**/
void
nm_client_deactivate_connection_async(NMClient *client,
NMActiveConnection *active,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
const char *active_path;
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(NM_IS_ACTIVE_CONNECTION(active));
active_path = nm_object_get_path(NM_OBJECT(active));
g_return_if_fail(active_path);
_nm_client_dbus_call(client,
client,
nm_client_deactivate_connection_async,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"DeactivateConnection",
g_variant_new("(o)", active_path),
G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
}
/**
* nm_client_deactivate_connection_finish:
* @client: a #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_deactivate_connection_async().
*
* Returns: success or failure
**/
gboolean
nm_client_deactivate_connection_finish(NMClient *client, GAsyncResult *result, GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_deactivate_connection_async),
FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/*****************************************************************************/
/* Connections */
/*****************************************************************************/
/**
* nm_client_get_connections:
* @client: the %NMClient
*
* Returns: (transfer none) (element-type NMRemoteConnection): an array
* containing all connections provided by the remote settings service. The
* returned array is owned by the #NMClient object and should not be modified.
*
* The connections are as received from D-Bus and might not validate according
* to nm_connection_verify().
**/
const GPtrArray *
nm_client_get_connections(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return nml_dbus_property_ao_get_objs_as_ptrarray(
&NM_CLIENT_GET_PRIVATE(client)->settings.connections);
}
/**
* nm_client_get_connection_by_id:
* @client: the %NMClient
* @id: the id of the remote connection
*
* Returns the first matching %NMRemoteConnection matching a given @id.
*
* Returns: (transfer none): the remote connection object on success, or %NULL if no
* matching object was found.
*
* The connection is as received from D-Bus and might not validate according
* to nm_connection_verify().
**/
NMRemoteConnection *
nm_client_get_connection_by_id(NMClient *client, const char *id)
{
const GPtrArray *arr;
guint i;
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
g_return_val_if_fail(id, NULL);
arr = nm_client_get_connections(client);
for (i = 0; i < arr->len; i++) {
NMRemoteConnection *c = NM_REMOTE_CONNECTION(arr->pdata[i]);
if (nm_streq0(id, nm_connection_get_id(NM_CONNECTION(c))))
return c;
}
return NULL;
}
/**
* nm_client_get_connection_by_path:
* @client: the %NMClient
* @path: the D-Bus object path of the remote connection
*
* Returns the %NMRemoteConnection representing the connection at @path.
*
* Returns: (transfer none): the remote connection object on success, or %NULL if the object was
* not known
*
* The connection is as received from D-Bus and might not validate according
* to nm_connection_verify().
**/
NMRemoteConnection *
nm_client_get_connection_by_path(NMClient *client, const char *path)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
g_return_val_if_fail(path != NULL, NULL);
return _dbobjs_get_nmobj_unpack_visible(client, path, NM_TYPE_REMOTE_CONNECTION);
}
/**
* nm_client_get_connection_by_uuid:
* @client: the %NMClient
* @uuid: the UUID of the remote connection
*
* Returns the %NMRemoteConnection identified by @uuid.
*
* Returns: (transfer none): the remote connection object on success, or %NULL if the object was
* not known
*
* The connection is as received from D-Bus and might not validate according
* to nm_connection_verify().
**/
NMRemoteConnection *
nm_client_get_connection_by_uuid(NMClient *client, const char *uuid)
{
const GPtrArray *arr;
guint i;
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
g_return_val_if_fail(uuid, NULL);
arr = nm_client_get_connections(client);
for (i = 0; i < arr->len; i++) {
NMRemoteConnection *c = NM_REMOTE_CONNECTION(arr->pdata[i]);
if (nm_streq0(uuid, nm_connection_get_uuid(NM_CONNECTION(c))))
return c;
}
return NULL;
}
/*****************************************************************************/
static void
_add_connection_cb(GObject *source,
GAsyncResult *result,
gboolean with_extra_arg,
gpointer user_data)
{
gs_unref_variant GVariant *ret = NULL;
gs_unref_object GTask *task = user_data;
gs_unref_variant GVariant *v_result = NULL;
const char *v_path;
GError *error = NULL;
ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error);
if (!ret) {
if (!nm_utils_error_is_cancelled(error))
g_dbus_error_strip_remote_error(error);
g_task_return_error(task, error);
return;
}
if (with_extra_arg) {
g_variant_get(ret, "(&o@a{sv})", &v_path, &v_result);
} else {
g_variant_get(ret, "(&o)", &v_path);
}
_request_wait_start(g_steal_pointer(&task),
"AddConnection",
NM_TYPE_REMOTE_CONNECTION,
v_path,
g_steal_pointer(&v_result));
}
static void
_add_connection_cb_without_extra_result(GObject *object, GAsyncResult *result, gpointer user_data)
{
_add_connection_cb(object, result, FALSE, user_data);
}
static void
_add_connection_cb_with_extra_result(GObject *object, GAsyncResult *result, gpointer user_data)
{
_add_connection_cb(object, result, TRUE, user_data);
}
static void
_add_connection_call(NMClient *self,
gpointer source_tag,
gboolean ignore_out_result,
GVariant *settings,
NMSettingsAddConnection2Flags flags,
GVariant *args,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(self));
g_return_if_fail(!settings || g_variant_is_of_type(settings, G_VARIANT_TYPE("a{sa{sv}}")));
g_return_if_fail(!args || g_variant_is_of_type(args, G_VARIANT_TYPE("a{sv}")));
NML_NMCLIENT_LOG_D(self, "AddConnection() started...");
if (!settings)
settings = nm_g_variant_singleton_aLsaLsvII();
/* Although AddConnection2() being capable to handle also AddConnection() and
* AddConnectionUnsaved() variants, we prefer to use the old D-Bus methods when
* they are sufficient. The reason is that libnm should avoid hard dependencies
* on 1.20 API whenever possible. */
if (ignore_out_result && flags == NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK) {
_nm_client_dbus_call(self,
self,
source_tag,
cancellable,
callback,
user_data,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"AddConnection",
g_variant_new("(@a{sa{sv}})", settings),
G_VARIANT_TYPE("(o)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_add_connection_cb_without_extra_result);
} else if (ignore_out_result && flags == NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY) {
_nm_client_dbus_call(self,
self,
source_tag,
cancellable,
callback,
user_data,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"AddConnectionUnsaved",
g_variant_new("(@a{sa{sv}})", settings),
G_VARIANT_TYPE("(o)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_add_connection_cb_without_extra_result);
} else {
_nm_client_dbus_call(self,
self,
source_tag,
cancellable,
callback,
user_data,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"AddConnection2",
g_variant_new("(@a{sa{sv}}u@a{sv})",
settings,
(guint32) flags,
args ?: nm_g_variant_singleton_aLsvI()),
G_VARIANT_TYPE("(oa{sv})"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
_add_connection_cb_with_extra_result);
}
}
/**
* nm_client_add_connection_async:
* @client: the %NMClient
* @connection: the connection to add. Note that this object's settings will be
* added, not the object itself
* @save_to_disk: whether to immediately save the connection to disk
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Requests that the remote settings service add the given settings to a new
* connection. If @save_to_disk is %TRUE, the connection is immediately written
* to disk; otherwise it is initially only stored in memory, but may be saved
* later by calling the connection's nm_remote_connection_commit_changes()
* method.
*
* @connection is untouched by this function and only serves as a template of
* the settings to add. The #NMRemoteConnection object that represents what
* NetworkManager actually added is returned to @callback when the addition
* operation is complete.
*
* Note that the #NMRemoteConnection returned in @callback may not contain
* identical settings to @connection as NetworkManager may perform automatic
* completion and/or normalization of connection properties.
**/
void
nm_client_add_connection_async(NMClient *client,
NMConnection *connection,
gboolean save_to_disk,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CONNECTION(connection));
_add_connection_call(client,
nm_client_add_connection_async,
TRUE,
nm_connection_to_dbus(connection, NM_CONNECTION_SERIALIZE_ALL),
save_to_disk ? NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK
: NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY,
NULL,
cancellable,
callback,
user_data);
}
/**
* nm_client_add_connection_finish:
* @client: an #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_add_connection_async().
*
* Returns: (transfer full): the new #NMRemoteConnection on success, %NULL on
* failure, in which case @error will be set.
**/
NMRemoteConnection *
nm_client_add_connection_finish(NMClient *client, GAsyncResult *result, GError **error)
{
return NM_REMOTE_CONNECTION(
_request_wait_finish(client, result, nm_client_add_connection_async, NULL, error));
}
/**
* nm_client_add_connection2:
* @client: the %NMClient
* @settings: the "a{sa{sv}}" #GVariant with the content of the setting.
* @flags: the %NMSettingsAddConnection2Flags argument.
* @args: (allow-none): the "a{sv}" #GVariant with extra argument or %NULL
* for no extra arguments.
* @ignore_out_result: this function wraps AddConnection2(), which has an
* additional result "a{sv}" output parameter. By setting this to %TRUE,
* you signal that you are not interested in that output parameter.
* This allows the function to fall back to AddConnection() and AddConnectionUnsaved(),
* which is interesting if you run against an older server version that does
* not yet provide AddConnection2(). By setting this to %FALSE, the function
* under the hood always calls AddConnection2().
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Call AddConnection2() D-Bus API asynchronously.
*
* Since: 1.20
**/
void
nm_client_add_connection2(NMClient *client,
GVariant *settings,
NMSettingsAddConnection2Flags flags,
GVariant *args,
gboolean ignore_out_result,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
_add_connection_call(client,
nm_client_add_connection2,
ignore_out_result,
settings,
flags,
args,
cancellable,
callback,
user_data);
}
/**
* nm_client_add_connection2_finish:
* @client: the #NMClient
* @result: the #GAsyncResult
* @out_result: (allow-none) (transfer full) (out): the output #GVariant
* from AddConnection2().
* If you care about the output result, then the "ignore_out_result"
* parameter of nm_client_add_connection2() must not be set to %TRUE.
* @error: (allow-none): the error argument.
*
* Returns: (transfer full): on success, a pointer to the added
* #NMRemoteConnection.
*
* Since: 1.20
*/
NMRemoteConnection *
nm_client_add_connection2_finish(NMClient *client,
GAsyncResult *result,
GVariant **out_result,
GError **error)
{
return NM_REMOTE_CONNECTION(
_request_wait_finish(client, result, nm_client_add_connection2, out_result, error));
}
/*****************************************************************************/
/**
* nm_client_load_connections:
* @client: the %NMClient
* @filenames: (array zero-terminated=1): %NULL-terminated array of filenames to load
* @failures: (out) (transfer full): on return, a %NULL-terminated array of
* filenames that failed to load
* @cancellable: a #GCancellable, or %NULL
* @error: return location for #GError
*
* Requests that the remote settings service load or reload the given files,
* adding or updating the connections described within.
*
* The changes to the indicated files will not yet be reflected in
* @client's connections array when the function returns.
*
* If all of the indicated files were successfully loaded, the
* function will return %TRUE, and @failures will be set to %NULL. If
* NetworkManager tried to load the files, but some (or all) failed,
* then @failures will be set to a %NULL-terminated array of the
* filenames that failed to load.
*
* Returns: %TRUE on success.
*
* Warning: before libnm 1.22, the boolean return value was inconsistent.
* That is made worse, because when running against certain server versions
* before 1.20, the server would return wrong values for success/failure.
* This means, if you use this function in libnm before 1.22, you are advised
* to ignore the boolean return value and only look at @failures and @error.
* With libnm >= 1.22, the boolean return value corresponds to whether @error was
* set. Note that even in the success case, you might have individual @failures.
* With 1.22, the return value is consistent with nm_client_load_connections_finish().
*
* Deprecated: 1.22: Use nm_client_load_connections_async() or GDBusConnection.
**/
gboolean
nm_client_load_connections(NMClient *client,
char **filenames,
char ***failures,
GCancellable *cancellable,
GError **error)
{
gs_unref_variant GVariant *ret = NULL;
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable), FALSE);
ret = _nm_client_dbus_call_sync(client,
cancellable,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"LoadConnections",
g_variant_new("(^as)", filenames ?: NM_PTRARRAY_EMPTY(char *)),
G_VARIANT_TYPE("(bas)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
TRUE,
error);
if (!ret) {
*failures = NULL;
return FALSE;
}
g_variant_get(ret, "(b^as)", NULL, failures);
return TRUE;
}
/**
* nm_client_load_connections_async:
* @client: the %NMClient
* @filenames: (array zero-terminated=1): %NULL-terminated array of filenames to load
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Requests that the remote settings service asynchronously load or reload the
* given files, adding or updating the connections described within.
*
* See nm_client_load_connections() for more details.
**/
void
nm_client_load_connections_async(NMClient *client,
char **filenames,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
_nm_client_dbus_call(client,
client,
nm_client_load_connections_async,
cancellable,
callback,
user_data,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"LoadConnections",
g_variant_new("(^as)", filenames ?: NM_PTRARRAY_EMPTY(char *)),
G_VARIANT_TYPE("(bas)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
}
/**
* nm_client_load_connections_finish:
* @client: the %NMClient
* @failures: (out) (transfer full) (array zero-terminated=1): on return, a
* %NULL-terminated array of filenames that failed to load
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of an nm_client_load_connections_async() call.
* See nm_client_load_connections() for more details.
*
* Returns: %TRUE on success.
* Note that even in the success case, you might have individual @failures.
**/
gboolean
nm_client_load_connections_finish(NMClient *client,
char ***failures,
GAsyncResult *result,
GError **error)
{
gs_unref_variant GVariant *ret = NULL;
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_load_connections_async),
FALSE);
ret = g_task_propagate_pointer(G_TASK(result), error);
if (!ret) {
*failures = NULL;
return FALSE;
}
g_variant_get(ret, "(b^as)", NULL, &failures);
return TRUE;
}
/**
* nm_client_reload_connections:
* @client: the #NMClient
* @cancellable: a #GCancellable, or %NULL
* @error: return location for #GError
*
* Requests that the remote settings service reload all connection
* files from disk, adding, updating, and removing connections until
* the in-memory state matches the on-disk state.
*
* Return value: %TRUE on success, %FALSE on failure
*
* Deprecated: 1.22: Use nm_client_reload_connections_async() or GDBusConnection.
**/
gboolean
nm_client_reload_connections(NMClient *client, GCancellable *cancellable, GError **error)
{
gs_unref_variant GVariant *ret = NULL;
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable), FALSE);
ret = _nm_client_dbus_call_sync(client,
cancellable,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"ReloadConnections",
g_variant_new("()"),
G_VARIANT_TYPE("(b)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
TRUE,
error);
if (!ret)
return FALSE;
return TRUE;
}
/**
* nm_client_reload_connections_async:
* @client: the #NMClient
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the reload operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Requests that the remote settings service begin reloading all connection
* files from disk, adding, updating, and removing connections until the
* in-memory state matches the on-disk state.
**/
void
nm_client_reload_connections_async(NMClient *client,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
_nm_client_dbus_call(client,
client,
nm_client_reload_connections_async,
cancellable,
callback,
user_data,
NM_DBUS_PATH_SETTINGS,
NM_DBUS_INTERFACE_SETTINGS,
"ReloadConnections",
g_variant_new("()"),
G_VARIANT_TYPE("(b)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
}
/**
* nm_client_reload_connections_finish:
* @client: the #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: return location for #GError
*
* Gets the result of an nm_client_reload_connections_async() call.
*
* Return value: %TRUE on success, %FALSE on failure
**/
gboolean
nm_client_reload_connections_finish(NMClient *client, GAsyncResult *result, GError **error)
{
gs_unref_variant GVariant *ret = NULL;
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_reload_connections_async),
FALSE);
ret = g_task_propagate_pointer(G_TASK(result), error);
if (!ret)
return FALSE;
return TRUE;
}
/*****************************************************************************/
/**
* nm_client_get_dns_mode:
* @client: the #NMClient
*
* Gets the current DNS processing mode.
*
* Return value: the DNS processing mode, or %NULL in case the
* value is not available.
*
* Since: 1.6
**/
const char *
nm_client_get_dns_mode(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return NM_CLIENT_GET_PRIVATE(client)->dns_manager.mode;
}
/**
* nm_client_get_dns_rc_manager:
* @client: the #NMClient
*
* Gets the current DNS resolv.conf manager.
*
* Return value: the resolv.conf manager or %NULL in case the
* value is not available.
*
* Since: 1.6
**/
const char *
nm_client_get_dns_rc_manager(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return NM_CLIENT_GET_PRIVATE(client)->dns_manager.rc_manager;
}
/**
* nm_client_get_dns_configuration:
* @client: a #NMClient
*
* Gets the current DNS configuration
*
* Returns: (transfer none) (element-type NMDnsEntry): a #GPtrArray
* containing #NMDnsEntry elements or %NULL in case the value is not
* available. The returned array is owned by the #NMClient object
* and should not be modified.
*
* Since: 1.6
**/
const GPtrArray *
nm_client_get_dns_configuration(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return NM_CLIENT_GET_PRIVATE(client)->dns_manager.configuration;
}
static NMLDBusNotifyUpdatePropFlags
_notify_update_prop_dns_manager_configuration(NMClient *self,
NMLDBusObject *dbobj,
const NMLDBusMetaIface *meta_iface,
guint dbus_property_idx,
GVariant *value)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
gs_unref_ptrarray GPtrArray *configuration_old = NULL;
gs_unref_ptrarray GPtrArray *configuration_new = NULL;
nm_assert(G_OBJECT(self) == dbobj->nmobj);
if (value) {
GVariant *entry_var_tmp;
GVariantIter iter;
GPtrArray *array;
configuration_new = g_ptr_array_new_with_free_func((GDestroyNotify) nm_dns_entry_unref);
g_variant_iter_init(&iter, value);
while (g_variant_iter_next(&iter, "@a{sv}", &entry_var_tmp)) {
gs_unref_variant GVariant *entry_var = entry_var_tmp;
nm_auto_free_variant_iter GVariantIter *iterp_nameservers = NULL;
nm_auto_free_variant_iter GVariantIter *iterp_domains = NULL;
gs_free char **nameservers = NULL;
gs_free char **domains = NULL;
gboolean vpn = FALSE;
NMDnsEntry *entry;
char *interface = NULL;
char *str;
gint32 priority = 0;
if (!g_variant_lookup(entry_var, "nameservers", "as", &iterp_nameservers)
|| !g_variant_lookup(entry_var, "priority", "i", &priority)) {
g_warning("Ignoring invalid DNS configuration");
continue;
}
array = g_ptr_array_new();
while (g_variant_iter_next(iterp_nameservers, "&s", &str))
g_ptr_array_add(array, str);
g_ptr_array_add(array, NULL);
nameservers = (char **) g_ptr_array_free(array, FALSE);
if (g_variant_lookup(entry_var, "domains", "as", &iterp_domains)) {
array = g_ptr_array_new();
while (g_variant_iter_next(iterp_domains, "&s", &str))
g_ptr_array_add(array, str);
g_ptr_array_add(array, NULL);
domains = (char **) g_ptr_array_free(array, FALSE);
}
g_variant_lookup(entry_var, "interface", "&s", &interface);
g_variant_lookup(entry_var, "vpn", "b", &vpn);
entry = nm_dns_entry_new(interface,
(const char *const *) nameservers,
(const char *const *) domains,
priority,
vpn);
if (!entry) {
g_warning("Ignoring invalid DNS entry");
continue;
}
g_ptr_array_add(configuration_new, entry);
}
}
configuration_old = priv->dns_manager.configuration;
priv->dns_manager.configuration = g_steal_pointer(&configuration_new);
return NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NOTIFY;
}
/**
* nm_client_get_capabilities:
* @client: the #NMClient instance
* @length: (out) (allow-none): the number of returned capabilities.
*
* Returns: (transfer none) (array length=length): the
* list of capabilities reported by the server or %NULL
* if the capabilities are unknown.
* The numeric values correspond to #NMCapability enum.
* The array is terminated by a numeric zero sentinel
* at position @length.
*
* Since: 1.24
*/
const guint32 *
nm_client_get_capabilities(NMClient *client, gsize *length)
{
NMClientPrivate *priv;
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
priv = NM_CLIENT_GET_PRIVATE(client);
NM_SET_OUT(length, priv->nm.capabilities_len);
return priv->nm.capabilities_arr;
}
static NMLDBusNotifyUpdatePropFlags
_notify_update_prop_nm_capabilities(NMClient *self,
NMLDBusObject *dbobj,
const NMLDBusMetaIface *meta_iface,
guint dbus_property_idx,
GVariant *value)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
nm_assert(G_OBJECT(self) == dbobj->nmobj);
nm_clear_g_free(&priv->nm.capabilities_arr);
priv->nm.capabilities_len = 0;
if (value) {
const guint32 *arr;
gsize len;
arr = g_variant_get_fixed_array(value, &len, sizeof(guint32));
priv->nm.capabilities_len = len;
priv->nm.capabilities_arr = g_new(guint32, len + 1);
if (len > 0)
memcpy(priv->nm.capabilities_arr, arr, len * sizeof(guint32));
priv->nm.capabilities_arr[len] = 0;
}
return NML_DBUS_NOTIFY_UPDATE_PROP_FLAGS_NOTIFY;
}
/*****************************************************************************/
/**
* nm_client_get_checkpoints:
* @client: a #NMClient
*
* Gets all the active checkpoints.
*
* Returns: (transfer none) (element-type NMCheckpoint): a #GPtrArray
* containing all the #NMCheckpoint. The returned array is owned by the
* #NMClient object and should not be modified.
*
* Since: 1.12
**/
const GPtrArray *
nm_client_get_checkpoints(NMClient *client)
{
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
return nml_dbus_property_ao_get_objs_as_ptrarray(
&NM_CLIENT_GET_PRIVATE(client)->nm.property_ao[PROPERTY_AO_IDX_CHECKPOINTS]);
}
static void
checkpoint_create_cb(GObject *object, GAsyncResult *result, gpointer user_data)
{
gs_unref_object GTask *task = user_data;
gs_unref_variant GVariant *ret = NULL;
const char *v_checkpoint_path;
GError *error = NULL;
ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(object), result, &error);
if (!ret) {
if (!nm_utils_error_is_cancelled(error))
g_dbus_error_strip_remote_error(error);
g_task_return_error(task, error);
return;
}
g_variant_get(ret, "(&o)", &v_checkpoint_path);
_request_wait_start(g_steal_pointer(&task),
"CheckpointCreate",
NM_TYPE_CHECKPOINT,
v_checkpoint_path,
NULL);
}
/**
* nm_client_checkpoint_create:
* @client: the %NMClient
* @devices: (element-type NMDevice): a list of devices for which a
* checkpoint should be created.
* @rollback_timeout: the rollback timeout in seconds
* @flags: creation flags
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Creates a checkpoint of the current networking configuration
* for given interfaces. An empty @devices argument means all
* devices. If @rollback_timeout is not zero, a rollback is
* automatically performed after the given timeout.
*
* Since: 1.12
**/
void
nm_client_checkpoint_create(NMClient *client,
const GPtrArray *devices,
guint32 rollback_timeout,
NMCheckpointCreateFlags flags,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
gs_free const char **paths = NULL;
guint i;
g_return_if_fail(NM_IS_CLIENT(client));
if (devices && devices->len > 0) {
paths = g_new(const char *, devices->len + 1);
for (i = 0; i < devices->len; i++)
paths[i] = nm_object_get_path(NM_OBJECT(devices->pdata[i]));
paths[i] = NULL;
}
_nm_client_dbus_call(
client,
client,
nm_client_checkpoint_create,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"CheckpointCreate",
g_variant_new("(^aouu)", paths ?: NM_PTRARRAY_EMPTY(const char *), rollback_timeout, flags),
G_VARIANT_TYPE("(o)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
checkpoint_create_cb);
}
/**
* nm_client_checkpoint_create_finish:
* @client: the #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_checkpoint_create().
*
* Returns: (transfer full): the new #NMCheckpoint on success, %NULL on
* failure, in which case @error will be set.
*
* Since: 1.12
**/
NMCheckpoint *
nm_client_checkpoint_create_finish(NMClient *client, GAsyncResult *result, GError **error)
{
return NM_CHECKPOINT(
_request_wait_finish(client, result, nm_client_checkpoint_create, NULL, error));
}
/**
* nm_client_checkpoint_destroy:
* @client: the %NMClient
* @checkpoint_path: the D-Bus path for the checkpoint
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Destroys an existing checkpoint without performing a rollback.
*
* Since: 1.12
**/
void
nm_client_checkpoint_destroy(NMClient *client,
const char *checkpoint_path,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(checkpoint_path && checkpoint_path[0] == '/');
_nm_client_dbus_call(client,
client,
nm_client_checkpoint_destroy,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"CheckpointDestroy",
g_variant_new("(o)", checkpoint_path),
G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
}
/**
* nm_client_checkpoint_destroy_finish:
* @client: an #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_checkpoint_destroy().
*
* Returns: %TRUE on success or %FALSE on failure, in which case
* @error will be set.
*
* Since: 1.12
**/
gboolean
nm_client_checkpoint_destroy_finish(NMClient *client, GAsyncResult *result, GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_checkpoint_destroy), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/**
* nm_client_checkpoint_rollback:
* @client: the %NMClient
* @checkpoint_path: the D-Bus path to the checkpoint
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Performs the rollback of a checkpoint before the timeout is reached.
*
* Since: 1.12
**/
void
nm_client_checkpoint_rollback(NMClient *client,
const char *checkpoint_path,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(checkpoint_path && checkpoint_path[0] == '/');
_nm_client_dbus_call(client,
client,
nm_client_checkpoint_rollback,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"CheckpointRollback",
g_variant_new("(o)", checkpoint_path),
G_VARIANT_TYPE("(a{su})"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
}
/**
* nm_client_checkpoint_rollback_finish:
* @client: an #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_checkpoint_rollback().
*
* Returns: (transfer full) (element-type utf8 guint32): an hash table of
* devices and results. Devices are represented by their original
* D-Bus path; each result is a #NMRollbackResult.
*
* Since: 1.12
**/
GHashTable *
nm_client_checkpoint_rollback_finish(NMClient *client, GAsyncResult *result, GError **error)
{
gs_unref_variant GVariant *ret = NULL;
gs_unref_variant GVariant *v_result = NULL;
GVariantIter iter;
GHashTable *hash;
const char *path;
guint32 r;
g_return_val_if_fail(NM_IS_CLIENT(client), NULL);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_checkpoint_rollback), NULL);
ret = g_task_propagate_pointer(G_TASK(result), error);
if (!ret)
return NULL;
g_variant_get(ret, "(@a{su})", &v_result);
hash = g_hash_table_new_full(nm_str_hash, g_str_equal, g_free, NULL);
g_variant_iter_init(&iter, v_result);
while (g_variant_iter_next(&iter, "{&su}", &path, &r))
g_hash_table_insert(hash, g_strdup(path), GUINT_TO_POINTER(r));
return hash;
}
/**
* nm_client_checkpoint_adjust_rollback_timeout:
* @client: the %NMClient
* @checkpoint_path: a D-Bus path to a checkpoint
* @add_timeout: the timeout in seconds counting from now.
* Set to zero, to disable the timeout.
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Resets the timeout for the checkpoint with path @checkpoint_path
* to @timeout_add.
*
* Since: 1.12
**/
void
nm_client_checkpoint_adjust_rollback_timeout(NMClient *client,
const char *checkpoint_path,
guint32 add_timeout,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(checkpoint_path && checkpoint_path[0] == '/');
_nm_client_dbus_call(client,
client,
nm_client_checkpoint_adjust_rollback_timeout,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"CheckpointAdjustRollbackTimeout",
g_variant_new("(ou)", checkpoint_path, add_timeout),
G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
}
/**
* nm_client_checkpoint_adjust_rollback_timeout_finish:
* @client: an #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_checkpoint_adjust_rollback_timeout().
*
* Returns: %TRUE on success or %FALSE on failure.
*
* Since: 1.12
**/
gboolean
nm_client_checkpoint_adjust_rollback_timeout_finish(NMClient *client,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(
nm_g_task_is_valid(result, client, nm_client_checkpoint_adjust_rollback_timeout),
FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/**
* nm_client_reload:
* @client: the %NMClient
* @flags: flags indicating what to reload.
* @cancellable: a #GCancellable, or %NULL
* @callback: (scope async): callback to be called when the add operation completes
* @user_data: (closure): caller-specific data passed to @callback
*
* Reload NetworkManager's configuration and perform certain updates, like
* flushing caches or rewriting external state to disk. This is similar to
* sending SIGHUP to NetworkManager but it allows for more fine-grained control
* over what to reload (see @flags). It also allows non-root access via
* PolicyKit and contrary to signals it is synchronous.
*
* Since: 1.22
**/
void
nm_client_reload(NMClient *client,
NMManagerReloadFlags flags,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
_nm_client_dbus_call(client,
client,
nm_client_reload,
cancellable,
callback,
user_data,
NM_DBUS_PATH,
NM_DBUS_INTERFACE,
"Reload",
g_variant_new("(u)", (guint32) flags),
G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
}
/**
* nm_client_reload_finish:
* @client: an #NMClient
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_reload().
*
* Returns: %TRUE on success or %FALSE on failure.
*
* Since: 1.22
**/
gboolean
nm_client_reload_finish(NMClient *client, GAsyncResult *result, GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_reload), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/*****************************************************************************/
/**
* nm_client_dbus_call:
* @client: the #NMClient
* @object_path: path of remote object
* @interface_name: D-Bus interface to invoke method on
* @method_name: the name of the method to invoke
* @parameters: (nullable): a #GVariant tuple with parameters for the method
* or %NULL if not passing parameters
* @reply_type: (nullable): the expected type of the reply (which will be a
* tuple), or %NULL
* @timeout_msec: the timeout in milliseconds, -1 to use the default
* timeout or %G_MAXINT for no timeout
* @cancellable: (nullable): a #GCancellable or %NULL
* @callback: (nullable): a #GAsyncReadyCallback to call when the request
* is satisfied or %NULL if you don't care about the result of the
* method invocation
* @user_data: the data to pass to @callback
*
* Call g_dbus_connection_call() on the current name owner with the specified
* arguments. Most importantly, this invokes g_dbus_connection_call() with the
* client's #GMainContext, so that the response is always in order with other
* events D-Bus events. Of course, the call uses #GTask and will invoke the
* callback on the current g_main_context_get_thread_default().
*
* This API is merely a convenient wrapper for g_dbus_connection_call(). You can
* also use g_dbus_connection_call() directly, with the same effect.
*
* Since: 1.24
**/
void
nm_client_dbus_call(NMClient *client,
const char *object_path,
const char *interface_name,
const char *method_name,
GVariant *parameters,
const GVariantType *reply_type,
int timeout_msec,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
_nm_client_dbus_call(client,
client,
nm_client_dbus_call,
cancellable,
callback,
user_data,
object_path,
interface_name,
method_name,
parameters,
reply_type,
G_DBUS_CALL_FLAGS_NONE,
timeout_msec == -1 ? NM_DBUS_DEFAULT_TIMEOUT_MSEC : timeout_msec,
nm_dbus_connection_call_finish_variant_cb);
}
/**
* nm_client_dbus_call_finish:
* @client: the #NMClient instance
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_dbus_call().
*
* Returns: (transfer full): the result #GVariant or %NULL on error.
*
* Since: 1.24
**/
GVariant *
nm_client_dbus_call_finish(NMClient *client, GAsyncResult *result, GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_dbus_call), FALSE);
return g_task_propagate_pointer(G_TASK(result), error);
}
/*****************************************************************************/
/**
* nm_client_dbus_set_property:
* @client: the #NMClient
* @object_path: path of remote object
* @interface_name: D-Bus interface for the property to set.
* @property_name: the name of the property to set
* @value: a #GVariant with the value to set.
* @timeout_msec: the timeout in milliseconds, -1 to use the default
* timeout or %G_MAXINT for no timeout
* @cancellable: (nullable): a #GCancellable or %NULL
* @callback: (nullable): a #GAsyncReadyCallback to call when the request
* is satisfied or %NULL if you don't care about the result of the
* method invocation
* @user_data: the data to pass to @callback
*
* Like nm_client_dbus_call() but calls "Set" on the standard "org.freedesktop.DBus.Properties"
* D-Bus interface.
*
* Since: 1.24
**/
void
nm_client_dbus_set_property(NMClient *client,
const char *object_path,
const char *interface_name,
const char *property_name,
GVariant *value,
int timeout_msec,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(interface_name);
g_return_if_fail(property_name);
g_return_if_fail(value);
_nm_client_dbus_call(client,
client,
nm_client_dbus_set_property,
cancellable,
callback,
user_data,
object_path,
DBUS_INTERFACE_PROPERTIES,
"Set",
g_variant_new("(ssv)", interface_name, property_name, value),
G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE,
timeout_msec == -1 ? NM_DBUS_DEFAULT_TIMEOUT_MSEC : timeout_msec,
nm_dbus_connection_call_finish_void_cb);
}
/**
* nm_client_dbus_set_property_finish:
* @client: the #NMClient instance
* @result: the result passed to the #GAsyncReadyCallback
* @error: location for a #GError, or %NULL
*
* Gets the result of a call to nm_client_dbus_set_property().
*
* Returns: %TRUE on success or %FALSE on failure.
*
* Since: 1.24
**/
gboolean
nm_client_dbus_set_property_finish(NMClient *client, GAsyncResult *result, GError **error)
{
g_return_val_if_fail(NM_IS_CLIENT(client), FALSE);
g_return_val_if_fail(nm_g_task_is_valid(result, client, nm_client_dbus_set_property), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/*****************************************************************************/
static void
_init_fetch_all(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_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);
NML_NMCLIENT_LOG_D(self, "fetch all");
nm_assert(!priv->get_managed_objects_cancellable);
priv->get_managed_objects_cancellable = g_cancellable_new();
priv->dbsid_nm_object_manager =
nm_dbus_connection_signal_subscribe_object_manager(priv->dbus_connection,
priv->name_owner,
"/org/freedesktop",
NULL,
_dbus_managed_objects_changed_cb,
self,
NULL);
priv->dbsid_dbus_properties_properties_changed =
nm_dbus_connection_signal_subscribe_properties_changed(priv->dbus_connection,
priv->name_owner,
NULL,
NULL,
_dbus_properties_changed_cb,
self,
NULL);
priv->dbsid_nm_settings_connection_updated =
g_dbus_connection_signal_subscribe(priv->dbus_connection,
priv->name_owner,
NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
"Updated",
NULL,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
_dbus_settings_updated_cb,
self,
NULL);
priv->dbsid_nm_connection_active_state_changed =
g_dbus_connection_signal_subscribe(priv->dbus_connection,
priv->name_owner,
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
"StateChanged",
NULL,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
_dbus_nm_connection_active_state_changed_cb,
self,
NULL);
priv->dbsid_nm_vpn_connection_state_changed =
g_dbus_connection_signal_subscribe(priv->dbus_connection,
priv->name_owner,
NM_DBUS_INTERFACE_VPN_CONNECTION,
"VpnStateChanged",
NULL,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
_dbus_nm_vpn_connection_state_changed_cb,
self,
NULL);
priv->dbsid_nm_check_permissions =
g_dbus_connection_signal_subscribe(priv->dbus_connection,
priv->name_owner,
NM_DBUS_INTERFACE,
"CheckPermissions",
NULL,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
_dbus_nm_check_permissions_cb,
self,
NULL);
g_dbus_connection_call(priv->dbus_connection,
priv->name_owner,
"/org/freedesktop",
DBUS_INTERFACE_OBJECT_MANAGER,
"GetManagedObjects",
NULL,
G_VARIANT_TYPE("(a{oa{sa{sv}}})"),
G_DBUS_CALL_FLAGS_NO_AUTO_START,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
priv->get_managed_objects_cancellable,
_dbus_get_managed_objects_cb,
nm_utils_user_data_pack(self, g_object_ref(priv->context_busy_watcher)));
_dbus_check_permissions_start(self);
}
static void
_init_release_all(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
CList **dbus_objects_lst_heads;
NMLDBusObject *dbobj;
int i;
gboolean permissions_state_changed = FALSE;
NML_NMCLIENT_LOG_D(self, "release all");
nm_clear_g_cancellable(&priv->permissions_cancellable);
nm_clear_g_cancellable(&priv->get_managed_objects_cancellable);
nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->dbsid_nm_object_manager);
nm_clear_g_dbus_connection_signal(priv->dbus_connection,
&priv->dbsid_dbus_properties_properties_changed);
nm_clear_g_dbus_connection_signal(priv->dbus_connection,
&priv->dbsid_nm_settings_connection_updated);
nm_clear_g_dbus_connection_signal(priv->dbus_connection,
&priv->dbsid_nm_connection_active_state_changed);
nm_clear_g_dbus_connection_signal(priv->dbus_connection,
&priv->dbsid_nm_vpn_connection_state_changed);
nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->dbsid_nm_check_permissions);
if (priv->permissions_state != NM_TERNARY_DEFAULT) {
priv->permissions_state = NM_TERNARY_DEFAULT;
permissions_state_changed = TRUE;
}
if (priv->permissions) {
gs_free guint8 *old_permissions = g_steal_pointer(&priv->permissions);
_emit_permissions_changed(self, old_permissions, NULL);
}
if (permissions_state_changed)
_notify(self, PROP_PERMISSIONS_STATE);
nm_assert(c_list_is_empty(&priv->obj_changed_lst_head));
dbus_objects_lst_heads = ((CList *[]){
&priv->dbus_objects_lst_head_on_dbus,
&priv->dbus_objects_lst_head_with_nmobj_not_ready,
&priv->dbus_objects_lst_head_with_nmobj_ready,
NULL,
});
for (i = 0; dbus_objects_lst_heads[i]; i++) {
c_list_for_each_entry (dbobj, dbus_objects_lst_heads[i], dbus_objects_lst) {
NMLDBusObjIfaceData *db_iface_data;
nm_assert(c_list_is_empty(&dbobj->obj_changed_lst));
c_list_for_each_entry (db_iface_data, &dbobj->iface_lst_head, iface_lst)
db_iface_data->iface_removed = TRUE;
nml_dbus_object_obj_changed_link(self, dbobj, NML_DBUS_OBJ_CHANGED_TYPE_DBUS);
}
}
_dbus_handle_changes(self, "release-all", FALSE);
/* We require that when we remove all D-Bus interfaces, that all object will go
* away. Note that a NMLDBusObject can be alive due to a NMLDBusObjWatcher, but
* even those should be all cleaned up. */
nm_assert(c_list_is_empty(&priv->obj_changed_lst_head));
nm_assert(c_list_is_empty(&priv->dbus_objects_lst_head_watched_only));
nm_assert(c_list_is_empty(&priv->dbus_objects_lst_head_on_dbus));
nm_assert(c_list_is_empty(&priv->dbus_objects_lst_head_with_nmobj_not_ready));
nm_assert(c_list_is_empty(&priv->dbus_objects_lst_head_with_nmobj_ready));
nm_assert(nm_g_hash_table_size(priv->dbus_objects) == 0);
}
/*****************************************************************************/
static void
name_owner_changed(NMClient *self, const char *name_owner)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
gboolean changed;
gs_free char *old_name_owner_free = NULL;
const char *old_name_owner;
nm_auto_pop_gmaincontext GMainContext *dbus_context = NULL;
name_owner = nm_str_not_empty(name_owner);
changed = !nm_streq0(priv->name_owner, name_owner);
if (!name_owner && priv->main_context != priv->dbus_context) {
gs_unref_object GObject *old_context_busy_watcher = NULL;
NML_NMCLIENT_LOG_D(self, "resync main context as we have no name owner");
nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->name_owner_changed_id);
/* Our instance was initialized synchronously. Usually we must henceforth
* stick to a internal main context. But now we have no name-owner...
* at this point, we anyway are going to do a full resync. Swap the main
* contexts again. */
old_context_busy_watcher = g_steal_pointer(&priv->context_busy_watcher);
priv->context_busy_watcher = g_object_ref(
g_object_get_qdata(old_context_busy_watcher, nm_context_busy_watcher_quark()));
g_main_context_ref(priv->main_context);
g_main_context_unref(priv->dbus_context);
priv->dbus_context = priv->main_context;
dbus_context = nm_g_main_context_push_thread_default_if_necessary(priv->dbus_context);
/* we need to sync again... */
_assert_main_context_is_current_thread_default(self, dbus_context);
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);
name_owner_get_call(self);
} else
dbus_context = nm_g_main_context_push_thread_default_if_necessary(priv->dbus_context);
if (changed) {
NML_NMCLIENT_LOG_D(self,
"name owner changed: %s%s%s -> %s%s%s",
NM_PRINT_FMT_QUOTE_STRING(priv->name_owner),
NM_PRINT_FMT_QUOTE_STRING(name_owner));
old_name_owner_free = priv->name_owner;
priv->name_owner = g_strdup(name_owner);
old_name_owner = old_name_owner_free;
} else
old_name_owner = priv->name_owner;
if (changed)
_notify(self, PROP_DBUS_NAME_OWNER);
if (changed && old_name_owner)
_init_release_all(self);
if (changed && priv->name_owner)
_init_fetch_all(self);
_set_nm_running(self);
if (priv->init_data) {
nm_auto_pop_gmaincontext GMainContext *main_context = NULL;
if (priv->main_context != priv->dbus_context)
main_context = nm_g_main_context_push_thread_default_if_necessary(priv->main_context);
_init_start_check_complete(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)
{
NMClient *self = user_data;
NMClientPrivate *priv;
const char *new_owner;
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(sss)")))
return;
priv = NM_CLIENT_GET_PRIVATE(self);
if (priv->name_owner_get_cancellable)
return;
g_variant_get(parameters, "(&s&s&s)", NULL, NULL, &new_owner);
name_owner_changed(self, new_owner);
}
static void
name_owner_get_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
NMClient *self;
NMClientPrivate *priv;
gs_unref_object GObject *context_busy_watcher = NULL;
gs_unref_variant GVariant *ret = NULL;
gs_free_error GError *error = NULL;
const char *name_owner = NULL;
nm_utils_user_data_unpack(user_data, &self, &context_busy_watcher);
ret = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), result, &error);
if (!ret && nm_utils_error_is_cancelled(error))
return;
priv = NM_CLIENT_GET_PRIVATE(self);
g_clear_object(&priv->name_owner_get_cancellable);
if (ret)
g_variant_get(ret, "(&s)", &name_owner);
name_owner_changed(self, name_owner);
}
static void
name_owner_get_call(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
nm_assert(!priv->name_owner_get_cancellable);
priv->name_owner_get_cancellable = g_cancellable_new();
g_dbus_connection_call(priv->dbus_connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS,
"GetNameOwner",
g_variant_new("(s)", NM_DBUS_SERVICE),
G_VARIANT_TYPE("(s)"),
G_DBUS_CALL_FLAGS_NONE,
NM_DBUS_DEFAULT_TIMEOUT_MSEC,
priv->name_owner_get_cancellable,
name_owner_get_cb,
nm_utils_user_data_pack(self, g_object_ref(priv->context_busy_watcher)));
}
/*****************************************************************************/
static inline gboolean
_nml_cleanup_context_busy_watcher_on_idle_cb(gpointer user_data)
{
nm_auto_unref_gmaincontext GMainContext *context = NULL;
gs_unref_object GObject *context_busy_watcher = NULL;
nm_utils_user_data_unpack(user_data, &context, &context_busy_watcher);
nm_assert(context);
nm_assert(G_IS_OBJECT(context_busy_watcher));
return G_SOURCE_REMOVE;
}
void
nml_cleanup_context_busy_watcher_on_idle(GObject *context_busy_watcher_take, GMainContext *context)
{
gs_unref_object GObject *context_busy_watcher = g_steal_pointer(&context_busy_watcher_take);
GSource *cleanup_source;
nm_assert(G_IS_OBJECT(context_busy_watcher));
nm_assert(context);
/* Technically, we cancelled all pending actions (and these actions
* (GTask) keep the context_busy_watcher object alive). Also, we passed
* no destroy notify to g_dbus_connection_signal_subscribe().
* That means, there should be no other unaccounted GSource'es left.
*
* Another reason is g_dbus_connection_signal_unsubscribe() which does
* not guarantee that everything was unsubscribed right away. Instead,
* there might still be idle actions queued (which will be thrown away
* once processed). Still, that means, the caller must continue to iterate
* the main context afterwards. Maybe we should pass a GDestroyNotify to
* g_dbus_connection_signal_subscribe() which handles an additional reference
* to the context_busy_watcher object. That would be the proper way to handle
* this. We don't do that, so in practice at this point there might still
* be some idle actions (with G_PRIORITY_DEFAULT) pending. As we schedule here
* another idle action with lower priority, we handle those cases without
* using a GDestroyNotify.
*
* However, we really need to be sure that the context_busy_watcher's
* lifetime matches the time that the context is busy. That is especially
* important with synchronous initialization, where the context-busy-watcher
* keeps the inner GMainContext integrated in the caller's.
* We must not g_source_destroy() that integration too early.
*
* So to be really sure all this is given, always schedule one last
* cleanup idle action with low priority. This should be the last
* thing related to this instance that keeps the context busy.
*
* Note that we could also *not* take a reference on @context
* and unref @context_busy_watcher via the GDestroyNotify. That would
* allow for the context to be wrapped up early, and when the last user
* gives up the reference to the context, the destroy notify could complete
* without even invoke the idle handler. However, that destroy notify may
* not be called in the right thread. So, we want to be sure that we unref
* the context-busy-watcher in the right context. Hence, we always take an
* additional reference and always cleanup in the idle handler. This means:
* the user *MUST* always keep iterating the context after NMClient got destroyed.
* But that is not a severe limitation, because the user anyway must be prepared
* to do that. That is because in many cases it is necessary anyway (and the user
* wouldn't know a priory when not). This way, it is just always necessary.
*
* It might be nice to use G_DEFAULT_PRIORITY here to minimize how long the
* instance stays alive. Probably that would be fine, even without passing
* a GDestroyNotify to g_dbus_connection_signal_subscribe(). But to be extra
* careful, use a low priority.
**/
cleanup_source =
nm_g_idle_source_new(G_PRIORITY_LOW + 10,
_nml_cleanup_context_busy_watcher_on_idle_cb,
nm_utils_user_data_pack(g_main_context_ref(context),
g_steal_pointer(&context_busy_watcher)),
NULL);
g_source_attach(cleanup_source, context);
g_source_unref(cleanup_source);
}
/*****************************************************************************/
static void
_init_start_complete(NMClient *self, GError *error_take)
{
gs_unref_object NMClient *self_keep_alive = g_object_ref(self);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NML_NMCLIENT_LOG_D(
self,
"%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"));
priv->instance_flags |= (error_take ? NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_BAD
: NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD);
_notify(self, PROP_INSTANCE_FLAGS);
nml_init_data_return(g_steal_pointer(&priv->init_data), error_take);
}
static void
_init_start_check_complete(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
_assert_main_context_is_current_thread_default(self, main_context);
if (!priv->init_data)
return;
if (priv->get_managed_objects_cancellable) {
/* still initializing. Wait. */
return;
}
#if NM_MORE_ASSERTS > 10
{
NMLDBusObject *dbobj;
c_list_for_each_entry (dbobj,
&priv->dbus_objects_lst_head_with_nmobj_not_ready,
dbus_objects_lst) {
NML_NMCLIENT_LOG_T(self, "init-start waiting for %s", dbobj->dbus_path->str);
break;
}
}
#endif
if (!c_list_is_empty(&priv->dbus_objects_lst_head_with_nmobj_not_ready))
return;
_init_start_complete(self, NULL);
}
static void
_init_start_cancelled_cb(GCancellable *cancellable, gpointer user_data)
{
NMClient *self = user_data;
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
GError *error = NULL;
nm_assert(NM_IS_CLIENT(self));
nm_assert(priv->init_data);
nm_assert(priv->init_data->cancellable == cancellable);
if (priv->init_data->cancelled_id == 0) {
/* this only can happen if the cancellable was already cancelled initially.
* In this case we are called synchronously. Do nothing, and let the caller
* handle it. */
return;
}
nm_utils_error_set_cancelled(&error, FALSE, NULL);
_init_start_complete(self, error);
}
static gboolean
_init_start_cancel_on_idle_cb(gpointer user_data)
{
NMClient *self = user_data;
GError *error = NULL;
nm_utils_error_set_cancelled(&error, FALSE, NULL);
_init_start_complete(self, error);
return G_SOURCE_CONTINUE;
}
static void
_init_start_with_bus(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
if (priv->init_data->cancellable) {
gulong id;
id = g_cancellable_connect(priv->init_data->cancellable,
G_CALLBACK(_init_start_cancelled_cb),
self,
NULL);
if (id == 0) {
priv->init_data->cancel_on_idle_source =
nm_g_idle_source_new(G_PRIORITY_DEFAULT_IDLE,
_init_start_cancel_on_idle_cb,
self,
NULL);
g_source_attach(priv->init_data->cancel_on_idle_source, priv->main_context);
return;
}
priv->init_data->cancelled_id = id;
}
_assert_main_context_is_current_thread_default(self, dbus_context);
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);
name_owner_get_call(self);
}
static void
_init_start_bus_get_cb(GObject *source, GAsyncResult *result, gpointer user_data)
{
NMClient *self = user_data;
NMClientPrivate *priv;
GDBusConnection *dbus_connection;
GError *error = NULL;
nm_assert(NM_IS_CLIENT(self));
dbus_connection = g_bus_get_finish(result, &error);
if (!dbus_connection) {
_init_start_complete(self, error);
return;
}
priv = NM_CLIENT_GET_PRIVATE(self);
priv->dbus_connection = dbus_connection;
_init_start_with_bus(self);
_notify(self, PROP_DBUS_CONNECTION);
}
static void
_init_start(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
NML_NMCLIENT_LOG_D(self,
"starting %s initialization...",
priv->init_data->is_sync ? "sync" : "async");
if (!priv->dbus_connection) {
g_bus_get(_nm_dbus_bus_type(), priv->init_data->cancellable, _init_start_bus_get_cb, self);
return;
}
_init_start_with_bus(self);
}
/*****************************************************************************/
static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
NMClient *self = NM_CLIENT(object);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(object);
switch (prop_id) {
case PROP_INSTANCE_FLAGS:
g_value_set_uint(value, priv->instance_flags);
break;
case PROP_DBUS_CONNECTION:
g_value_set_object(value, priv->dbus_connection);
break;
case PROP_DBUS_NAME_OWNER:
g_value_set_string(value, nm_client_get_dbus_name_owner(self));
break;
case PROP_NM_RUNNING:
g_value_set_boolean(value, nm_client_get_nm_running(self));
break;
/* Manager properties. */
case PROP_VERSION:
g_value_set_string(value, nm_client_get_version(self));
break;
case PROP_STATE:
g_value_set_enum(value, nm_client_get_state(self));
break;
case PROP_STARTUP:
g_value_set_boolean(value, nm_client_get_startup(self));
break;
case PROP_NETWORKING_ENABLED:
g_value_set_boolean(value, nm_client_networking_get_enabled(self));
break;
case PROP_WIRELESS_ENABLED:
g_value_set_boolean(value, nm_client_wireless_get_enabled(self));
break;
case PROP_WIRELESS_HARDWARE_ENABLED:
g_value_set_boolean(value, nm_client_wireless_hardware_get_enabled(self));
break;
case PROP_RADIO_FLAGS:
g_value_set_uint(value, priv->nm.radio_flags);
break;
case PROP_WWAN_ENABLED:
g_value_set_boolean(value, nm_client_wwan_get_enabled(self));
break;
case PROP_WWAN_HARDWARE_ENABLED:
g_value_set_boolean(value, nm_client_wwan_hardware_get_enabled(self));
break;
case PROP_WIMAX_ENABLED:
g_value_set_boolean(value, FALSE);
break;
case PROP_WIMAX_HARDWARE_ENABLED:
g_value_set_boolean(value, FALSE);
break;
case PROP_ACTIVE_CONNECTIONS:
g_value_take_boxed(value,
_nm_utils_copy_object_array(nm_client_get_active_connections(self)));
break;
case PROP_CONNECTIVITY:
g_value_set_enum(value, nm_client_get_connectivity(self));
break;
case PROP_CONNECTIVITY_CHECK_AVAILABLE:
g_value_set_boolean(value, nm_client_connectivity_check_get_available(self));
break;
case PROP_CONNECTIVITY_CHECK_ENABLED:
g_value_set_boolean(value, nm_client_connectivity_check_get_enabled(self));
break;
case PROP_CONNECTIVITY_CHECK_URI:
g_value_set_string(value, nm_client_connectivity_check_get_uri(self));
break;
case PROP_PRIMARY_CONNECTION:
g_value_set_object(value, nm_client_get_primary_connection(self));
break;
case PROP_ACTIVATING_CONNECTION:
g_value_set_object(value, nm_client_get_activating_connection(self));
break;
case PROP_DEVICES:
g_value_take_boxed(value, _nm_utils_copy_object_array(nm_client_get_devices(self)));
break;
case PROP_METERED:
g_value_set_uint(value, nm_client_get_metered(self));
break;
case PROP_ALL_DEVICES:
g_value_take_boxed(value, _nm_utils_copy_object_array(nm_client_get_all_devices(self)));
break;
case PROP_CHECKPOINTS:
g_value_take_boxed(value, _nm_utils_copy_object_array(nm_client_get_checkpoints(self)));
break;
case PROP_CAPABILITIES:
{
const guint32 *arr;
GArray *out;
gsize len;
arr = nm_client_get_capabilities(self, &len);
if (arr) {
out = g_array_new(TRUE, FALSE, sizeof(guint32));
g_array_append_vals(out, arr, len);
} else
out = NULL;
g_value_take_boxed(value, out);
} break;
case PROP_PERMISSIONS_STATE:
g_value_set_enum(value, priv->permissions_state);
break;
/* Settings properties. */
case PROP_CONNECTIONS:
g_value_take_boxed(value, _nm_utils_copy_object_array(nm_client_get_connections(self)));
break;
case PROP_HOSTNAME:
g_value_set_string(value, priv->settings.hostname);
break;
case PROP_CAN_MODIFY:
g_value_set_boolean(value, priv->settings.can_modify);
break;
/* DNS properties */
case PROP_DNS_MODE:
g_value_set_string(value, nm_client_get_dns_mode(self));
break;
case PROP_DNS_RC_MANAGER:
g_value_set_string(value, nm_client_get_dns_rc_manager(self));
break;
case PROP_DNS_CONFIGURATION:
g_value_take_boxed(value,
_nm_utils_copy_array(nm_client_get_dns_configuration(self),
(NMUtilsCopyFunc) nm_dns_entry_dup,
(GDestroyNotify) nm_dns_entry_unref));
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)
{
NMClient *self = NM_CLIENT(object);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
gboolean b;
guint v_uint;
switch (prop_id) {
case PROP_INSTANCE_FLAGS:
/* construct */
v_uint = g_value_get_uint(value);
/* Silently ignore "initialized-{good,bad}" flags. They are only set internally
* and cannot be change by the user. However, accept the caller to set them,
* so that
* nmc.props.instance_flags = nmc.props.instance_flags | NM.ClientInstanceFlags.NO_AUTO_FETCH_PERMISSIONS
* works. */
v_uint &= ~((guint) (NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD
| NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_BAD));
g_return_if_fail(!NM_FLAGS_ANY(v_uint, ~((guint) NM_CLIENT_INSTANCE_FLAGS_ALL_WRITABLE)));
v_uint &= ((guint) NM_CLIENT_INSTANCE_FLAGS_ALL_WRITABLE);
if (!priv->instance_flags_constructed) {
priv->instance_flags_constructed = TRUE;
priv->instance_flags = v_uint;
nm_assert((guint) priv->instance_flags == v_uint);
} else {
NMClientInstanceFlags flags = v_uint;
/* After object construction, we only allow to toggle certain flags and
* ignore all other flags. */
if ((priv->instance_flags ^ flags)
& NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS) {
if (NM_FLAGS_HAS(flags, NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS))
priv->instance_flags |= NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS;
else
priv->instance_flags &= ~NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS;
if (priv->dbsid_nm_check_permissions != 0)
_dbus_check_permissions_start(self);
}
}
break;
case PROP_DBUS_CONNECTION:
/* construct-only */
priv->dbus_connection = g_value_dup_object(value);
break;
case PROP_NETWORKING_ENABLED:
b = g_value_get_boolean(value);
if (priv->nm.networking_enabled != b) {
nm_client_networking_set_enabled(self, b, NULL);
/* Let the property value flip when we get the change signal from NM */
}
break;
case PROP_WIRELESS_ENABLED:
b = g_value_get_boolean(value);
if (priv->nm.wireless_enabled != b) {
nm_client_wireless_set_enabled(self, b);
/* Let the property value flip when we get the change signal from NM */
}
break;
case PROP_WWAN_ENABLED:
b = g_value_get_boolean(value);
if (priv->nm.wwan_enabled != b) {
nm_client_wwan_set_enabled(self, b);
/* Let the property value flip when we get the change signal from NM */
}
break;
case PROP_CONNECTIVITY_CHECK_ENABLED:
b = g_value_get_boolean(value);
if (priv->nm.connectivity_check_enabled != b) {
nm_client_connectivity_check_set_enabled(self, b);
/* Let the property value flip when we get the change signal from NM */
}
break;
case PROP_WIMAX_ENABLED:
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
/*****************************************************************************/
static gboolean
init_sync(GInitable *initable, GCancellable *cancellable, GError **error)
{
gs_unref_object NMClient *self = NULL;
NMClientPrivate *priv;
GMainContext *dbus_context;
GError *local_error = NULL;
GMainLoop *main_loop;
GObject *parent_context_busy_watcher;
g_return_val_if_fail(NM_IS_CLIENT(initable), FALSE);
self = g_object_ref(NM_CLIENT(initable)); /* keep instance alive. */
priv = NM_CLIENT_GET_PRIVATE(self);
g_return_val_if_fail(!priv->dbus_context, FALSE);
/* when using init_sync(), we use a separate internal GMainContext for
* all D-Bus operations and use our regular async-init code. That means,
* also in sync-init, we don't actually block waiting for our D-Bus requests,
* instead, we only block (g_main_loop_run()) for the overall result.
*
* Doing this has a performance overhead. Also, we cannot ever fall back
* to the regular main-context (not unless we lose the main-owner and
* need to re-initialize). The reason is that we receive events on our
* dbus_context, and this cannot be brought in sync -- short of full
* reinitalizing. Therefor, using sync init not only is slower during
* construction of the object, but NMClient will stick to the dual GMainContext
* mode.
*
* Aside from this downside, the solution is good:
*
* - we don't duplicate the implementation of async-init.
* - we don't iterate the main-context of the caller while waiting for
* initialization to happen
* - we still invoke all changes under the main_context of the caller.
* - all D-Bus events strictly go through dbus_context and are in order.
*/
dbus_context = g_main_context_new();
priv->dbus_context = g_main_context_ref(dbus_context);
/* We have an inner context. Note that if we loose the name owner, we have a chance
* to resync and drop the inner context. That means, requests made against the inner
* context have a different lifetime. Hence, we create a separate tracking
* object. This "wraps" the outer context-busy-watcher and references it, so
* that the work together. Grep for nm_context_busy_watcher_quark() to
* see how this works. */
parent_context_busy_watcher = g_steal_pointer(&priv->context_busy_watcher);
priv->context_busy_watcher = g_object_new(G_TYPE_OBJECT, NULL);
g_object_set_qdata_full(priv->context_busy_watcher,
nm_context_busy_watcher_quark(),
parent_context_busy_watcher,
g_object_unref);
g_main_context_push_thread_default(dbus_context);
main_loop = g_main_loop_new(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(dbus_context);
if (priv->main_context != priv->dbus_context) {
nm_context_busy_watcher_integrate_source(priv->main_context,
priv->dbus_context,
priv->context_busy_watcher);
}
g_main_context_unref(dbus_context);
if (local_error) {
g_propagate_error(error, local_error);
return FALSE;
}
return TRUE;
}
/*****************************************************************************/
static void
init_async(GAsyncInitable *initable,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMClientPrivate *priv;
NMClient *self;
nm_auto_pop_gmaincontext GMainContext *context = NULL;
GTask *task;
g_return_if_fail(NM_IS_CLIENT(initable));
self = NM_CLIENT(initable);
priv = NM_CLIENT_GET_PRIVATE(self);
g_return_if_fail(!priv->dbus_context);
priv->dbus_context = g_main_context_ref(priv->main_context);
context = nm_g_main_context_push_thread_default_if_necessary(priv->main_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_CLIENT(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 void
nm_client_init(NMClient *self)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
priv->permissions_state = NM_TERNARY_DEFAULT;
priv->context_busy_watcher = g_object_new(G_TYPE_OBJECT, NULL);
c_list_init(&self->obj_base.queue_notify_lst);
c_list_init(&priv->queue_notify_lst_head);
c_list_init(&priv->notify_event_lst_head);
priv->dbus_objects = g_hash_table_new(nm_pdirect_hash, nm_pdirect_equal);
c_list_init(&priv->dbus_objects_lst_head_watched_only);
c_list_init(&priv->dbus_objects_lst_head_on_dbus);
c_list_init(&priv->dbus_objects_lst_head_with_nmobj_not_ready);
c_list_init(&priv->dbus_objects_lst_head_with_nmobj_ready);
c_list_init(&priv->obj_changed_lst_head);
}
/**
* nm_client_new:
* @cancellable: a #GCancellable, or %NULL
* @error: location for a #GError, or %NULL
*
* Creates a new #NMClient synchronously.
*
* Note that this will block until a NMClient instance is fully initialized.
* This does nothing beside calling g_initable_new(). You are free to call
* g_initable_new() or g_object_new()/g_initable_init() directly for more
* control, to set GObject properties or get access to the NMClient instance
* while it is still initializing.
*
* Using the synchronous initialization creates an #NMClient instance
* that uses an internal #GMainContext. This context is invisible to the
* user. This introduces an additional overhead that is payed not
* only during object initialization, but for the entire lifetime of
* this object.
* Also, due to this internal #GMainContext, the events are no longer
* in sync with other messages from #GDBusConnection (but all events
* of the NMClient will themselves still be ordered).
* For a serious program, you should therefore avoid these problems by
* using g_async_initable_init_async() or nm_client_new_async() instead.
* The sync initialization is still useful for simple scripts or interactive
* testing for example via pygobject.
*
* Creating an #NMClient instance can only fail for two reasons. First, if you didn't
* provide a %NM_CLIENT_DBUS_CONNECTION and the call to g_bus_get()
* fails. You can avoid that by using g_initable_new() directly and
* set a D-Bus connection.
* Second, if you cancelled the creation. If you do that, then note
* that after the failure there might still be idle actions pending
* which keep nm_client_get_main_context() alive. That means,
* in that case you must continue iterating the context to avoid
* leaks. See nm_client_get_context_busy_watcher().
*
* Creating an #NMClient instance when NetworkManager is not running
* does not cause a failure.
*
* Returns: a new #NMClient or NULL on an error
**/
NMClient *
nm_client_new(GCancellable *cancellable, GError **error)
{
return g_initable_new(NM_TYPE_CLIENT, cancellable, error, NULL);
}
/**
* nm_client_new_async:
* @cancellable: a #GCancellable, or %NULL
* @callback: callback to call when the client is created
* @user_data: data for @callback
*
* Creates a new #NMClient asynchronously.
* @callback will be called when it is done. Use
* nm_client_new_finish() to get the result.
*
* This does nothing beside calling g_async_initable_new_async(). You are free to
* call g_async_initable_new_async() or g_object_new()/g_async_initable_init_async()
* directly for more control, to set GObject properties or get access to the NMClient
* instance while it is still initializing.
*
* Creating an #NMClient instance can only fail for two reasons. First, if you didn't
* provide a %NM_CLIENT_DBUS_CONNECTION and the call to g_bus_get()
* fails. You can avoid that by using g_async_initable_new_async() directly and
* set a D-Bus connection.
* Second, if you cancelled the creation. If you do that, then note
* that after the failure there might still be idle actions pending
* which keep nm_client_get_main_context() alive. That means,
* in that case you must continue iterating the context to avoid
* leaks. See nm_client_get_context_busy_watcher().
*
* Creating an #NMClient instance when NetworkManager is not running
* does not cause a failure.
**/
void
nm_client_new_async(GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data)
{
g_async_initable_new_async(NM_TYPE_CLIENT,
G_PRIORITY_DEFAULT,
cancellable,
callback,
user_data,
NULL);
}
/**
* nm_client_new_finish:
* @result: a #GAsyncResult
* @error: location for a #GError, or %NULL
*
* Gets the result of an nm_client_new_async() call.
*
* Returns: a new #NMClient, or %NULL on error
**/
NMClient *
nm_client_new_finish(GAsyncResult *result, GError **error)
{
gs_unref_object GObject *source_object = NULL;
GObject *object;
source_object = g_async_result_get_source_object(result);
g_return_val_if_fail(source_object, NULL);
object = g_async_initable_new_finish(G_ASYNC_INITABLE(source_object), result, error);
g_return_val_if_fail(!object || NM_IS_CLIENT(object), FALSE);
return NM_CLIENT(object);
}
static void
constructed(GObject *object)
{
NMClient *self = NM_CLIENT(object);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
priv->main_context = g_main_context_ref_thread_default();
G_OBJECT_CLASS(nm_client_parent_class)->constructed(object);
NML_NMCLIENT_LOG_D(self, "new NMClient instance");
}
static void
dispose(GObject *object)
{
NMClient *self = NM_CLIENT(object);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE(self);
nm_assert(!priv->init_data);
self->obj_base.is_disposing = TRUE;
nm_clear_g_cancellable(&priv->name_owner_get_cancellable);
nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->name_owner_changed_id);
nm_clear_g_free(&priv->name_owner);
_init_release_all(self);
nm_assert(c_list_is_empty(&priv->dbus_objects_lst_head_watched_only));
nm_assert(c_list_is_empty(&priv->dbus_objects_lst_head_on_dbus));
nm_assert(c_list_is_empty(&priv->dbus_objects_lst_head_with_nmobj_not_ready));
nm_assert(c_list_is_empty(&priv->dbus_objects_lst_head_with_nmobj_ready));
nm_assert(c_list_is_empty(&priv->queue_notify_lst_head));
nm_assert(c_list_is_empty(&priv->notify_event_lst_head));
nm_assert(c_list_is_empty(&self->obj_base.queue_notify_lst));
nm_assert(nm_g_hash_table_size(priv->dbus_objects) == 0);
nml_dbus_property_o_clear_many(priv->nm.property_o, G_N_ELEMENTS(priv->nm.property_o), NULL);
nml_dbus_property_ao_clear_many(priv->nm.property_ao, G_N_ELEMENTS(priv->nm.property_ao), NULL);
nm_clear_g_free(&priv->nm.connectivity_check_uri);
nm_clear_g_free(&priv->nm.version);
nml_dbus_property_ao_clear(&priv->settings.connections, NULL);
nm_clear_g_free(&priv->settings.hostname);
nm_clear_pointer(&priv->dns_manager.configuration, g_ptr_array_unref);
nm_clear_g_free(&priv->dns_manager.mode);
nm_clear_g_free(&priv->dns_manager.rc_manager);
nm_clear_pointer(&priv->dbus_objects, g_hash_table_destroy);
G_OBJECT_CLASS(nm_client_parent_class)->dispose(object);
nm_clear_pointer(&priv->udev, udev_unref);
if (priv->context_busy_watcher && priv->dbus_context) {
nml_cleanup_context_busy_watcher_on_idle(g_steal_pointer(&priv->context_busy_watcher),
priv->dbus_context);
}
nm_clear_pointer(&priv->dbus_context, g_main_context_unref);
nm_clear_pointer(&priv->main_context, g_main_context_unref);
nm_clear_g_free(&priv->permissions);
g_clear_object(&priv->dbus_connection);
g_clear_object(&priv->context_busy_watcher);
nm_clear_g_free(&priv->name_owner);
priv->nm.capabilities_len = 0;
nm_clear_g_free(&priv->nm.capabilities_arr);
NML_NMCLIENT_LOG_D(self, "disposed");
}
const NMLDBusMetaIface _nml_dbus_meta_iface_nm_agentmanager =
NML_DBUS_META_IFACE_INIT(NM_DBUS_INTERFACE_AGENT_MANAGER,
NULL,
NML_DBUS_META_INTERFACE_PRIO_NONE, );
const NMLDBusMetaIface _nml_dbus_meta_iface_nm = NML_DBUS_META_IFACE_INIT_PROP(
NM_DBUS_INTERFACE,
nm_client_get_type,
NML_DBUS_META_INTERFACE_PRIO_NMCLIENT,
NML_DBUS_META_IFACE_DBUS_PROPERTIES(
NML_DBUS_META_PROPERTY_INIT_O_PROP(
"ActivatingConnection",
PROP_ACTIVATING_CONNECTION,
NMClient,
_priv.nm.property_o[PROPERTY_O_IDX_NM_ACTIVATING_CONNECTION],
nm_active_connection_get_type),
NML_DBUS_META_PROPERTY_INIT_AO_PROP(
"ActiveConnections",
PROP_ACTIVE_CONNECTIONS,
NMClient,
_priv.nm.property_ao[PROPERTY_AO_IDX_ACTIVE_CONNECTIONS],
nm_active_connection_get_type,
.notify_changed_ao = _property_ao_notify_changed_active_connections_cb),
NML_DBUS_META_PROPERTY_INIT_AO_PROP("AllDevices",
PROP_ALL_DEVICES,
NMClient,
_priv.nm.property_ao[PROPERTY_AO_IDX_ALL_DEVICES],
nm_device_get_type,
.notify_changed_ao =
_property_ao_notify_changed_all_devices_cb),
NML_DBUS_META_PROPERTY_INIT_FCN("Capabilities",
PROP_CAPABILITIES,
"au",
_notify_update_prop_nm_capabilities, ),
NML_DBUS_META_PROPERTY_INIT_AO_PROP("Checkpoints",
PROP_CHECKPOINTS,
NMClient,
_priv.nm.property_ao[PROPERTY_AO_IDX_CHECKPOINTS],
nm_checkpoint_get_type),
NML_DBUS_META_PROPERTY_INIT_U("Connectivity",
PROP_CONNECTIVITY,
NMClient,
_priv.nm.connectivity),
NML_DBUS_META_PROPERTY_INIT_B("ConnectivityCheckAvailable",
PROP_CONNECTIVITY_CHECK_AVAILABLE,
NMClient,
_priv.nm.connectivity_check_available),
NML_DBUS_META_PROPERTY_INIT_B("ConnectivityCheckEnabled",
PROP_CONNECTIVITY_CHECK_ENABLED,
NMClient,
_priv.nm.connectivity_check_enabled),
NML_DBUS_META_PROPERTY_INIT_S("ConnectivityCheckUri",
PROP_CONNECTIVITY_CHECK_URI,
NMClient,
_priv.nm.connectivity_check_uri),
NML_DBUS_META_PROPERTY_INIT_AO_PROP("Devices",
PROP_DEVICES,
NMClient,
_priv.nm.property_ao[PROPERTY_AO_IDX_DEVICES],
nm_device_get_type,
.notify_changed_ao =
_property_ao_notify_changed_devices_cb),
NML_DBUS_META_PROPERTY_INIT_IGNORE("GlobalDnsConfiguration", "a{sv}"),
NML_DBUS_META_PROPERTY_INIT_U("Metered", PROP_METERED, NMClient, _priv.nm.metered),
NML_DBUS_META_PROPERTY_INIT_B("NetworkingEnabled",
PROP_NETWORKING_ENABLED,
NMClient,
_priv.nm.networking_enabled),
NML_DBUS_META_PROPERTY_INIT_O_PROP("PrimaryConnection",
PROP_PRIMARY_CONNECTION,
NMClient,
_priv.nm.property_o[PROPERTY_O_IDX_NM_PRIMAY_CONNECTION],
nm_active_connection_get_type),
NML_DBUS_META_PROPERTY_INIT_IGNORE("PrimaryConnectionType", "s"),
NML_DBUS_META_PROPERTY_INIT_U("RadioFlags",
PROP_RADIO_FLAGS,
NMClient,
_priv.nm.radio_flags),
NML_DBUS_META_PROPERTY_INIT_B("Startup", PROP_STARTUP, NMClient, _priv.nm.startup),
NML_DBUS_META_PROPERTY_INIT_U("State", PROP_STATE, NMClient, _priv.nm.state),
NML_DBUS_META_PROPERTY_INIT_S("Version", PROP_VERSION, NMClient, _priv.nm.version),
NML_DBUS_META_PROPERTY_INIT_IGNORE("WimaxEnabled", "b"),
NML_DBUS_META_PROPERTY_INIT_IGNORE("WimaxHardwareEnabled", "b"),
NML_DBUS_META_PROPERTY_INIT_B("WirelessEnabled",
PROP_WIRELESS_ENABLED,
NMClient,
_priv.nm.wireless_enabled),
NML_DBUS_META_PROPERTY_INIT_B("WirelessHardwareEnabled",
PROP_WIRELESS_HARDWARE_ENABLED,
NMClient,
_priv.nm.wireless_hardware_enabled),
NML_DBUS_META_PROPERTY_INIT_B("WwanEnabled",
PROP_WWAN_ENABLED,
NMClient,
_priv.nm.wwan_enabled),
NML_DBUS_META_PROPERTY_INIT_B("WwanHardwareEnabled",
PROP_WWAN_HARDWARE_ENABLED,
NMClient,
_priv.nm.wwan_hardware_enabled), ), );
const NMLDBusMetaIface _nml_dbus_meta_iface_nm_settings = NML_DBUS_META_IFACE_INIT_PROP(
NM_DBUS_INTERFACE_SETTINGS,
nm_client_get_type,
NML_DBUS_META_INTERFACE_PRIO_NMCLIENT,
NML_DBUS_META_IFACE_DBUS_PROPERTIES(
NML_DBUS_META_PROPERTY_INIT_B("CanModify",
PROP_CAN_MODIFY,
NMClient,
_priv.settings.can_modify),
NML_DBUS_META_PROPERTY_INIT_AO_PROP(
"Connections",
PROP_CONNECTIONS,
NMClient,
_priv.settings.connections,
nm_remote_connection_get_type,
.notify_changed_ao = _property_ao_notify_changed_connections_cb,
.check_nmobj_visible_fcn = (gboolean(*)(GObject *)) nm_remote_connection_get_visible),
NML_DBUS_META_PROPERTY_INIT_S("Hostname",
PROP_HOSTNAME,
NMClient,
_priv.settings.hostname), ), );
const NMLDBusMetaIface _nml_dbus_meta_iface_nm_dnsmanager = NML_DBUS_META_IFACE_INIT_PROP(
NM_DBUS_INTERFACE_DNS_MANAGER,
nm_client_get_type,
NML_DBUS_META_INTERFACE_PRIO_NMCLIENT,
NML_DBUS_META_IFACE_DBUS_PROPERTIES(
NML_DBUS_META_PROPERTY_INIT_FCN("Configuration",
PROP_DNS_CONFIGURATION,
"aa{sv}",
_notify_update_prop_dns_manager_configuration),
NML_DBUS_META_PROPERTY_INIT_S("Mode", PROP_DNS_MODE, NMClient, _priv.dns_manager.mode),
NML_DBUS_META_PROPERTY_INIT_S("RcManager",
PROP_DNS_RC_MANAGER,
NMClient,
_priv.dns_manager.rc_manager), ), );
static void
nm_client_class_init(NMClientClass *client_class)
{
GObjectClass *object_class = G_OBJECT_CLASS(client_class);
_dbus_path_nm = nm_ref_string_new(NM_DBUS_PATH);
_dbus_path_settings = nm_ref_string_new(NM_DBUS_PATH_SETTINGS);
_dbus_path_dns_manager = nm_ref_string_new(NM_DBUS_PATH_DNS_MANAGER);
object_class->get_property = get_property;
object_class->set_property = set_property;
object_class->constructed = constructed;
object_class->dispose = dispose;
/**
* NMClient:dbus-connection:
*
* The #GDBusConnection to use.
*
* If this is not set during object construction, the D-Bus connection will
* automatically be chosen during async/sync initalization via g_bus_get().
*
* Since: 1.22
*/
obj_properties[PROP_DBUS_CONNECTION] = g_param_spec_object(
NM_CLIENT_DBUS_CONNECTION,
"",
"",
G_TYPE_DBUS_CONNECTION,
G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
/**
* NMClient:instance-flags:
*
* #NMClientInstanceFlags for the instance. These affect behavior of #NMClient.
* This is a construct property and you may only set most flags only during
* construction.
*
* The flag %NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS can be toggled any time,
* even after constructing the instance. Note that you may want to watch NMClient:permissions-state
* property to know whether permissions are ready. Note that permissions are only fetched
* when NMClient has a D-Bus name owner.
*
* The flags %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD and %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_BAD
* cannot be set, however they will be returned by the getter after initialization completes.
*
* Since: 1.24
*/
obj_properties[PROP_INSTANCE_FLAGS] = g_param_spec_uint(
NM_CLIENT_INSTANCE_FLAGS,
"",
"",
0,
G_MAXUINT32,
0,
G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
/**
* NMClient:dbus-name-owner:
*
* The name owner of the NetworkManager D-Bus service.
*
* Since: 1.22
**/
obj_properties[PROP_DBUS_NAME_OWNER] =
g_param_spec_string(NM_CLIENT_DBUS_NAME_OWNER,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:version:
*
* The NetworkManager version.
**/
obj_properties[PROP_VERSION] = g_param_spec_string(NM_CLIENT_VERSION,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:state:
*
* The current daemon state.
**/
obj_properties[PROP_STATE] = g_param_spec_enum(NM_CLIENT_STATE,
"",
"",
NM_TYPE_STATE,
NM_STATE_UNKNOWN,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:startup:
*
* Whether the daemon is still starting up.
**/
obj_properties[PROP_STARTUP] = g_param_spec_boolean(NM_CLIENT_STARTUP,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:nm-running:
*
* Whether the daemon is running.
**/
obj_properties[PROP_NM_RUNNING] =
g_param_spec_boolean(NM_CLIENT_NM_RUNNING,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:networking-enabled:
*
* Whether networking is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
obj_properties[PROP_NETWORKING_ENABLED] =
g_param_spec_boolean(NM_CLIENT_NETWORKING_ENABLED,
"",
"",
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:wireless-enabled:
*
* Whether wireless is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
**/
obj_properties[PROP_WIRELESS_ENABLED] =
g_param_spec_boolean(NM_CLIENT_WIRELESS_ENABLED,
"",
"",
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:wireless-hardware-enabled:
*
* Whether the wireless hardware is enabled.
**/
obj_properties[PROP_WIRELESS_HARDWARE_ENABLED] =
g_param_spec_boolean(NM_CLIENT_WIRELESS_HARDWARE_ENABLED,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:wwan-enabled:
*
* Whether WWAN functionality is enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*/
obj_properties[PROP_WWAN_ENABLED] =
g_param_spec_boolean(NM_CLIENT_WWAN_ENABLED,
"",
"",
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:wwan-hardware-enabled:
*
* Whether the WWAN hardware is enabled.
**/
obj_properties[PROP_WWAN_HARDWARE_ENABLED] =
g_param_spec_boolean(NM_CLIENT_WWAN_HARDWARE_ENABLED,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:wimax-enabled:
*
* Whether WiMAX functionality is enabled.
*
* Deprecated: 1.22: WiMAX is no longer supported and this always returns FALSE. The setter has no effect.
*/
obj_properties[PROP_WIMAX_ENABLED] =
g_param_spec_boolean(NM_CLIENT_WIMAX_ENABLED,
"",
"",
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:wimax-hardware-enabled:
*
* Whether the WiMAX hardware is enabled.
*
* Deprecated: 1.22: WiMAX is no longer supported and this always returns FALSE.
**/
obj_properties[PROP_WIMAX_HARDWARE_ENABLED] =
g_param_spec_boolean(NM_CLIENT_WIMAX_HARDWARE_ENABLED,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:radio-flags:
*
* Flags for radio interfaces. See #NMRadioFlags.
*
* Since: 1.38
**/
obj_properties[PROP_RADIO_FLAGS] = g_param_spec_uint(NM_CLIENT_RADIO_FLAGS,
"",
"",
0,
G_MAXUINT32,
NM_RADIO_FLAG_NONE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:active-connections: (type GPtrArray(NMActiveConnection))
*
* The active connections.
**/
obj_properties[PROP_ACTIVE_CONNECTIONS] =
g_param_spec_boxed(NM_CLIENT_ACTIVE_CONNECTIONS,
"",
"",
G_TYPE_PTR_ARRAY,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:connectivity:
*
* The network connectivity state.
*/
obj_properties[PROP_CONNECTIVITY] =
g_param_spec_enum(NM_CLIENT_CONNECTIVITY,
"",
"",
NM_TYPE_CONNECTIVITY_STATE,
NM_CONNECTIVITY_UNKNOWN,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient::connectivity-check-available
*
* Whether a connectivity checking service has been configured.
*
* Since: 1.10
*/
obj_properties[PROP_CONNECTIVITY_CHECK_AVAILABLE] =
g_param_spec_boolean(NM_CLIENT_CONNECTIVITY_CHECK_AVAILABLE,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient::connectivity-check-enabled
*
* Whether a connectivity checking service has been enabled.
*
* The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
*
* Since: 1.10
*/
obj_properties[PROP_CONNECTIVITY_CHECK_ENABLED] =
g_param_spec_boolean(NM_CLIENT_CONNECTIVITY_CHECK_ENABLED,
"",
"",
FALSE,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:connectivity-check-uri:
*
* The used URI for connectivity checking.
*
* Since: 1.22
**/
obj_properties[PROP_CONNECTIVITY_CHECK_URI] =
g_param_spec_string(NM_CLIENT_CONNECTIVITY_CHECK_URI,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:primary-connection:
*
* The #NMActiveConnection of the device with the default route;
* see nm_client_get_primary_connection() for more details.
**/
obj_properties[PROP_PRIMARY_CONNECTION] =
g_param_spec_object(NM_CLIENT_PRIMARY_CONNECTION,
"",
"",
NM_TYPE_ACTIVE_CONNECTION,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:activating-connection:
*
* The #NMActiveConnection of the activating connection that is
* likely to become the new #NMClient:primary-connection.
**/
obj_properties[PROP_ACTIVATING_CONNECTION] =
g_param_spec_object(NM_CLIENT_ACTIVATING_CONNECTION,
"",
"",
NM_TYPE_ACTIVE_CONNECTION,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:devices: (type GPtrArray(NMDevice))
*
* List of real network devices. Does not include placeholder devices.
**/
obj_properties[PROP_DEVICES] = g_param_spec_boxed(NM_CLIENT_DEVICES,
"",
"",
G_TYPE_PTR_ARRAY,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:all-devices: (type GPtrArray(NMDevice))
*
* List of both real devices and device placeholders.
* Since: 1.2
**/
obj_properties[PROP_ALL_DEVICES] =
g_param_spec_boxed(NM_CLIENT_ALL_DEVICES,
"",
"",
G_TYPE_PTR_ARRAY,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:connections: (type GPtrArray(NMRemoteConnection))
*
* The list of configured connections that are available to the user. (Note
* that this differs from the underlying D-Bus property, which may also
* contain the object paths of connections that the user does not have
* permission to read the details of.)
*/
obj_properties[PROP_CONNECTIONS] =
g_param_spec_boxed(NM_CLIENT_CONNECTIONS,
"",
"",
G_TYPE_PTR_ARRAY,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:hostname:
*
* The machine hostname stored in persistent configuration. This can be
* modified by calling nm_client_save_hostname().
*/
obj_properties[PROP_HOSTNAME] = g_param_spec_string(NM_CLIENT_HOSTNAME,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:can-modify:
*
* If %TRUE, adding and modifying connections is supported.
*/
obj_properties[PROP_CAN_MODIFY] =
g_param_spec_boolean(NM_CLIENT_CAN_MODIFY,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:metered:
*
* Whether the connectivity is metered.
*
* Since: 1.2
**/
obj_properties[PROP_METERED] = g_param_spec_uint(NM_CLIENT_METERED,
"",
"",
0,
G_MAXUINT32,
NM_METERED_UNKNOWN,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:dns-mode:
*
* The current DNS processing mode.
*
* Since: 1.6
**/
obj_properties[PROP_DNS_MODE] = g_param_spec_string(NM_CLIENT_DNS_MODE,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:dns-rc-manager:
*
* The current resolv.conf management mode.
*
* Since: 1.6
**/
obj_properties[PROP_DNS_RC_MANAGER] =
g_param_spec_string(NM_CLIENT_DNS_RC_MANAGER,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:dns-configuration: (type GPtrArray(NMDnsEntry))
*
* The current DNS configuration, represented as an array
* of #NMDnsEntry objects.
*
* Since: 1.6
**/
obj_properties[PROP_DNS_CONFIGURATION] =
g_param_spec_boxed(NM_CLIENT_DNS_CONFIGURATION,
"",
"",
G_TYPE_PTR_ARRAY,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:checkpoints: (type GPtrArray(NMCheckpoint))
*
* The list of active checkpoints.
*
* Since: 1.12
*/
obj_properties[PROP_CHECKPOINTS] =
g_param_spec_boxed(NM_CLIENT_CHECKPOINTS,
"",
"",
G_TYPE_PTR_ARRAY,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:capabilities: (type GArray(guint32))
*
* The list of capabilities numbers as guint32 or %NULL if
* there are no capabilities. The numeric value correspond
* to %NMCapability enum.
*
* Since: 1.24
*/
obj_properties[PROP_CAPABILITIES] =
g_param_spec_boxed(NM_CLIENT_CAPABILITIES,
"",
"",
G_TYPE_ARRAY,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMClient:permissions-state:
*
* The state of the cached permissions. The value %NM_TERNARY_DEFAULT
* means that no permissions are yet received (or not yet requested).
* %NM_TERNARY_TRUE means that permissions are received, cached and up
* to date. %NM_TERNARY_FALSE means that permissions were received and are
* cached, but in the meantime a "CheckPermissions" signal was received
* that invalidated the cached permissions.
* Note that NMClient will always emit a notify::permissions-state signal
* when a "CheckPermissions" signal got received or after new permissions
* got received (that is regardless whether the value of the permission state
* actually changed). With this you can watch the permissions-state property
* to know whether the permissions are ready. Note that while NMClient has
* no D-Bus name owner, no permissions are fetched (and this property won't
* change).
*
* Since: 1.24
*/
obj_properties[PROP_PERMISSIONS_STATE] =
g_param_spec_enum(NM_CLIENT_PERMISSIONS_STATE,
"",
"",
NM_TYPE_TERNARY,
NM_TERNARY_DEFAULT,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
_nml_dbus_meta_class_init_with_properties(object_class,
&_nml_dbus_meta_iface_nm,
&_nml_dbus_meta_iface_nm_settings,
&_nml_dbus_meta_iface_nm_dnsmanager);
/**
* NMClient::device-added:
* @client: the client that received the signal
* @device: (type NMDevice): the new device
*
* Notifies that a #NMDevice is added. This signal is not emitted for
* placeholder devices.
**/
signals[DEVICE_ADDED] = g_signal_new(NM_CLIENT_DEVICE_ADDED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
1,
G_TYPE_OBJECT);
/**
* NMClient::device-removed:
* @client: the client that received the signal
* @device: (type NMDevice): the removed device
*
* Notifies that a #NMDevice is removed. This signal is not emitted for
* placeholder devices.
**/
signals[DEVICE_REMOVED] = g_signal_new(NM_CLIENT_DEVICE_REMOVED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
1,
G_TYPE_OBJECT);
/**
* NMClient::any-device-added:
* @client: the client that received the signal
* @device: (type NMDevice): the new device
*
* Notifies that a #NMDevice is added. This signal is emitted for both
* regular devices and placeholder devices.
**/
signals[ANY_DEVICE_ADDED] = g_signal_new(NM_CLIENT_ANY_DEVICE_ADDED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
1,
G_TYPE_OBJECT);
/**
* NMClient::any-device-removed:
* @client: the client that received the signal
* @device: (type NMDevice): the removed device
*
* Notifies that a #NMDevice is removed. This signal is emitted for both
* regular devices and placeholder devices.
**/
signals[ANY_DEVICE_REMOVED] = g_signal_new(NM_CLIENT_ANY_DEVICE_REMOVED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
1,
G_TYPE_OBJECT);
/**
* NMClient::permission-changed:
* @client: the client that received the signal
* @permission: a permission from #NMClientPermission
* @result: the permission's result, one of #NMClientPermissionResult
*
* Notifies that a permission has changed
**/
signals[PERMISSION_CHANGED] = g_signal_new(NM_CLIENT_PERMISSION_CHANGED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
2,
G_TYPE_UINT,
G_TYPE_UINT);
/**
* NMClient::connection-added:
* @client: the client that received the signal
* @connection: the new connection
*
* Notifies that a #NMConnection has been added.
**/
signals[CONNECTION_ADDED] = g_signal_new(NM_CLIENT_CONNECTION_ADDED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
1,
NM_TYPE_REMOTE_CONNECTION);
/**
* NMClient::connection-removed:
* @client: the client that received the signal
* @connection: the removed connection
*
* Notifies that a #NMConnection has been removed.
**/
signals[CONNECTION_REMOVED] = g_signal_new(NM_CLIENT_CONNECTION_REMOVED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
1,
NM_TYPE_REMOTE_CONNECTION);
/**
* NMClient::active-connection-added:
* @client: the client that received the signal
* @active_connection: the new active connection
*
* Notifies that a #NMActiveConnection has been added.
**/
signals[ACTIVE_CONNECTION_ADDED] = g_signal_new(NM_CLIENT_ACTIVE_CONNECTION_ADDED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
1,
NM_TYPE_ACTIVE_CONNECTION);
/**
* NMClient::active-connection-removed:
* @client: the client that received the signal
* @active_connection: the removed active connection
*
* Notifies that a #NMActiveConnection has been removed.
**/
signals[ACTIVE_CONNECTION_REMOVED] = g_signal_new(NM_CLIENT_ACTIVE_CONNECTION_REMOVED,
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
1,
NM_TYPE_ACTIVE_CONNECTION);
}
static void
nm_client_initable_iface_init(GInitableIface *iface)
{
iface->init = init_sync;
}
static void
nm_client_async_initable_iface_init(GAsyncInitableIface *iface)
{
iface->init_async = init_async;
iface->init_finish = init_finish;
}
/*****************************************************************************/
typedef struct {
GCancellable *cancellable;
GSource *integration_source;
GTask *task;
GSource *idle_source;
/* A weakref to nm_client_get_context_busy_watcher() */
GWeakRef weak_ref;
gulong cancellable_id;
guint64 log_ptr;
int result;
} WaitShutdownData;
G_LOCK_DEFINE_STATIC(wait_shutdown_mutex);
static NM_CACHED_QUARK_FCN("nm.client.wait-shutdown", _wait_shutdown_get_quark);
static void
_wait_shutdown_data_free(gpointer user_data)
{
WaitShutdownData *data = user_data;
nm_g_slice_free(data);
}
static gboolean
_wait_shutdown_idle_cb(gpointer user_data)
{
WaitShutdownData *data = user_data;
gs_unref_object GTask *task = NULL;
int result;
nm_clear_g_source_inst(&data->idle_source);
task = g_steal_pointer(&data->task);
result = g_atomic_int_get(&data->result);
nm_assert(NM_IN_SET(result, 0, 1));
NML_DBUS_LOG(_NML_NMCLIENT_LOG_LEVEL_COERCE(NML_DBUS_LOG_LEVEL_TRACE),
"nmclient[" NM_HASH_OBFUSCATE_PTR_FMT
"]: wait-shutdown (" NM_HASH_OBFUSCATE_PTR_FMT ")"
"%s",
data->log_ptr,
NM_HASH_OBFUSCATE_PTR(data),
!result ? " cancelled" : " completed");
if (!result) {
GError *error = NULL;
nm_utils_error_set_cancelled(&error, FALSE, NULL);
g_task_return_error(task, error);
} else
g_task_return_boolean(task, TRUE);
return G_SOURCE_CONTINUE;
}
static void
_wait_shutdown_data_clear(WaitShutdownData *data, gboolean result)
{
gs_unref_object GObject *context_busy_watcher = NULL;
if (!g_atomic_int_compare_and_exchange(&data->result, -1, !!result)) {
/* There was a race and the result is already provided. Nothing to
* do, except, if "result" indicates cancellation (FALSE), set data->result
* to FALSE to. Aside that, the completion is already in progress. */
if (!result)
g_atomic_int_compare_and_exchange(&data->result, TRUE, FALSE);
return;
}
nm_clear_g_signal_handler(data->cancellable, &data->cancellable_id);
nm_clear_g_source_inst(&data->integration_source);
g_clear_object(&data->cancellable);
if (!result) {
/* This was a cancellation. We likely still have the qdata tracked.
* We need to remove it. */
context_busy_watcher = g_weak_ref_get(&data->weak_ref);
if (context_busy_watcher) {
GPtrArray *qdata_arr;
G_LOCK(wait_shutdown_mutex);
qdata_arr = g_object_get_qdata(context_busy_watcher, _wait_shutdown_get_quark());
if (qdata_arr && g_ptr_array_remove_fast(qdata_arr, data)) {
/* data->task had an additional reference, we return it now. */
g_object_unref(data->task);
}
G_UNLOCK(wait_shutdown_mutex);
}
}
g_weak_ref_clear(&data->weak_ref);
/* We don't complete right away, instead always schedule an idle action
* on the caller's context. */
data->idle_source = nm_g_source_attach(
nm_g_idle_source_new(G_PRIORITY_DEFAULT_IDLE, _wait_shutdown_idle_cb, data, NULL),
g_task_get_context(data->task));
}
static void
_wait_shutdown_qdata_cb(gpointer user_data)
{
gs_unref_ptrarray GPtrArray *qdata_arr = user_data;
while (qdata_arr->len > 0) {
WaitShutdownData *data;
data = g_ptr_array_remove_index_fast(qdata_arr, qdata_arr->len - 1);
_wait_shutdown_data_clear(data, TRUE);
/* data->task had an additional reference, we return it now. */
g_object_unref(data->task);
}
}
static void
_wait_shutdown_cancelled_cb(GCancellable *cancellable, gpointer user_data)
{
_wait_shutdown_data_clear(g_task_get_task_data(user_data), FALSE);
}
/**
* nm_client_wait_shutdown:
* @client: the #NMClient to shutdown.
* @integrate_maincontext: whether to hook the client's maincontext
* in the current thread default. Otherwise, you must ensure
* that the client's maincontext gets iterated so that it can complete.
* By integrating the maincontext in the current thread default, you
* may instead only iterate the latter.
* @cancellable: (allow-none): the #GCancellable to abort the shutdown.
* @callback: (nullable): a #GAsyncReadyCallback to call when the request
* is satisfied or %NULL if you don't care about the result of the
* method invocation.
* @user_data: the data to pass to @callback
*
* The way to stop #NMClient is by unrefing it. That will cancel all
* internally pending async operations. However, as async operations in
* NMClient use GTask, hence they cannot complete right away. Instead,
* their (internal) result callback still needs to be dispatched by iterating
* the client's main context.
*
* You thus cannot stop iterating the client's main context until
* everything is wrapped up. nm_client_get_context_busy_watcher()
* helps to watch how long that will be.
*
* This function automates that waiting. Like all glib async operations
* this honors the current g_main_context_get_thread_default().
*
* In any case, to complete the shutdown, nm_client_get_main_context()
* must be iterated. If the current g_main_context_get_thread_default() is
* the same as nm_client_get_main_context(), then @integrate_maincontext
* is ignored. In that case, the caller is required to iterate the context
* for shutdown to complete. Otherwise, if g_main_context_get_thread_default()
* differs from nm_client_get_main_context() and @integrate_maincontext
* is %FALSE, the caller must make sure that both contexts are iterated
* until completion. Otherwise, if @integrate_maincontext is %TRUE, then
* nm_client_get_main_context() will be integrated in g_main_context_get_thread_default().
* This means, the caller gives nm_client_get_main_context() up until the waiting
* completes, the function will acquire the context and hook it into
* g_main_context_get_thread_default().
* It is a bug to request @integrate_maincontext while having nm_client_get_main_context()
* acquired or iterated otherwise because a context can only be acquired once
* at a time.
*
* Shutdown can only complete after all references to @client were released.
*
* It is possible to call this function multiple times for the same client.
* But note that with @integrate_maincontext the client's context is acquired,
* which can only be done once at a time.
*
* It is permissible to start waiting before the objects is fully initialized.
*
* The function really allows two separate things. To get a notification (callback) when
* shutdown is complete, and to integrate the client's context in another context.
* The latter case is useful if the client has a separate context and you hand it
* over to another GMainContext to wrap up.
*
* The main use is to have a NMClient and a separate GMainContext on a worker
* thread. When being done, you can hand over the cleanup of the context
* to g_main_context_default(), assuming that the main thread iterates
* the default context. In that case, you don't need to care about passing
* a callback to know when shutdown completed.
*
* Since: 1.42
*/
void
nm_client_wait_shutdown(NMClient *client,
gboolean integrate_maincontext,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
NMClientPrivate *priv;
WaitShutdownData *data;
gs_unref_object GTask *task = NULL;
GQuark quark = _wait_shutdown_get_quark();
GPtrArray *qdata_arr;
GSource *integration_source = NULL;
g_return_if_fail(NM_IS_CLIENT(client));
g_return_if_fail(!cancellable || G_IS_CANCELLABLE(cancellable));
priv = NM_CLIENT_GET_PRIVATE(client);
task = nm_g_task_new(NULL, cancellable, nm_client_wait_shutdown, callback, user_data);
if (integrate_maincontext && g_task_get_context(task) != priv->main_context) {
integration_source = nm_utils_g_main_context_create_integrate_source(priv->main_context);
g_return_if_fail(integration_source);
g_source_attach(integration_source, g_task_get_context(task));
}
data = g_slice_new(WaitShutdownData);
*data = (WaitShutdownData){
.cancellable = nm_g_object_ref(cancellable),
.task = g_object_ref(task),
.result = -1,
.integration_source = integration_source,
.log_ptr = NM_HASH_OBFUSCATE_PTR(client),
};
/* The "data" itself stays alive as long as the task lives. That's important, because
* the callbacks _wait_shutdown_weak_ref_cb and _wait_shutdown_cancelled_cb
* rely on accessing "data", which must live long enough. */
g_task_set_task_data(task, data, _wait_shutdown_data_free);
g_weak_ref_init(&data->weak_ref, priv->context_busy_watcher);
NML_DBUS_LOG(_NML_NMCLIENT_LOG_LEVEL_COERCE(NML_DBUS_LOG_LEVEL_TRACE),
"nmclient[" NM_HASH_OBFUSCATE_PTR_FMT
"]: wait-shutdown (" NM_HASH_OBFUSCATE_PTR_FMT ")"
"%s",
data->log_ptr,
NM_HASH_OBFUSCATE_PTR(data),
integration_source ? " (integrated main source)" : "");
/* I don't think g_object_weak_ref() + GWeakRef can actually be used in
* a race-free way here, because g_object_weak_ref() has no GDestroyNotify
* and cannot keep task alive to avoid races. Instead, implement a weak pointer
* notification via the qdata.
*
* Yes, getting cancellation thread-safe is rather complicated here! I think
* the code is correct though, and you can cancel the operation from
* any thread without races. */
G_LOCK(wait_shutdown_mutex);
qdata_arr = g_object_get_qdata(priv->context_busy_watcher, quark);
if (!qdata_arr) {
qdata_arr = g_ptr_array_new();
g_object_set_qdata_full(priv->context_busy_watcher,
quark,
qdata_arr,
_wait_shutdown_qdata_cb);
}
/* data->task gets an additional reference, take it now. */
g_object_ref(data->task);
g_ptr_array_add(qdata_arr, data);
G_UNLOCK(wait_shutdown_mutex);
if (data->cancellable) {
/* Take an additional reference on task. */
data->cancellable_id = g_cancellable_connect(data->cancellable,
G_CALLBACK(_wait_shutdown_cancelled_cb),
g_object_ref(task),
g_object_unref);
}
}
/**
* nm_client_wait_shutdown_finish:
* @result: a #GAsyncResult obtained from the #GAsyncReadyCallback passed to nm_client_wait_shutdown()
* @error: return location for error or %NULL
*
* Returns: %TRUE if waiting is complete successfully. In that case, all resources of the
* nmclient are wrapped up and released. This can only fail by user cancellation.
*
* Since: 1.42
*/
gboolean
nm_client_wait_shutdown_finish(GAsyncResult *result, GError **error)
{
g_return_val_if_fail(nm_g_task_is_valid(result, NULL, nm_client_wait_shutdown), FALSE);
return g_task_propagate_boolean(G_TASK(result), error);
}
/*****************************************************************************
* Backported symbols. Usually, new API is only added in new major versions
* of NetworkManager (that is, on "master" branch). Sometimes however, we might
* have to backport some API to an older stable branch. In that case, we backport
* the symbols with a different version corresponding to the minor API.
*
* To allow upgrading from such a extended minor-release, "master" contains these
* backported symbols too.
*
* For example, 1.2.0 added nm_setting_connection_autoconnect_slaves_get_type.
* This was backported for 1.0.4 as nm_setting_connection_autoconnect_slaves_get_type@libnm_1_0_4
* To allow an application that was linked against 1.0.4 to seamlessly upgrade to
* a newer major version, the same symbols is also exposed on "master". Note, that
* a user can only seamlessly upgrade to a newer major version, that is released
* *after* 1.0.4 is out. In this example, 1.2.0 was released after 1.4.0, and thus
* a 1.0.4 user can upgrade to 1.2.0 ABI.
*****************************************************************************/
NM_BACKPORT_SYMBOL(libnm_1_0_4,
NMSettingConnectionAutoconnectSlaves,
nm_setting_connection_get_autoconnect_slaves,
(NMSettingConnection * setting),
(setting));
NM_BACKPORT_SYMBOL(libnm_1_0_4,
GType,
nm_setting_connection_autoconnect_slaves_get_type,
(void),
());
NM_BACKPORT_SYMBOL(libnm_1_0_6,
NMMetered,
nm_setting_connection_get_metered,
(NMSettingConnection * setting),
(setting));
NM_BACKPORT_SYMBOL(libnm_1_0_6, GType, nm_metered_get_type, (void), ());
NM_BACKPORT_SYMBOL(libnm_1_0_6,
NMSettingWiredWakeOnLan,
nm_setting_wired_get_wake_on_lan,
(NMSettingWired * setting),
(setting));
NM_BACKPORT_SYMBOL(libnm_1_0_6,
const char *,
nm_setting_wired_get_wake_on_lan_password,
(NMSettingWired * setting),
(setting));
NM_BACKPORT_SYMBOL(libnm_1_0_6, GType, nm_setting_wired_wake_on_lan_get_type, (void), ());
NM_BACKPORT_SYMBOL(libnm_1_0_6, const guint *, nm_utils_wifi_2ghz_freqs, (void), ());
NM_BACKPORT_SYMBOL(libnm_1_0_6, const guint *, nm_utils_wifi_5ghz_freqs, (void), ());
NM_BACKPORT_SYMBOL(libnm_1_0_6,
char *,
nm_utils_enum_to_str,
(GType type, int value),
(type, value));
NM_BACKPORT_SYMBOL(libnm_1_0_6,
gboolean,
nm_utils_enum_from_str,
(GType type, const char *str, int *out_value, char **err_token),
(type, str, out_value, err_token));
NM_BACKPORT_SYMBOL(libnm_1_2_4,
int,
nm_setting_ip_config_get_dns_priority,
(NMSettingIPConfig * setting),
(setting));
NM_BACKPORT_SYMBOL(libnm_1_10_14,
NMSettingConnectionMdns,
nm_setting_connection_get_mdns,
(NMSettingConnection * setting),
(setting));
NM_BACKPORT_SYMBOL(libnm_1_10_14, GType, nm_setting_connection_mdns_get_type, (void), ());
NM_BACKPORT_SYMBOL(libnm_1_30_8,
int,
nm_setting_ip_config_get_required_timeout,
(NMSettingIPConfig * setting),
(setting));
NM_BACKPORT_SYMBOL(libnm_1_30_8,
NMIPAddress *,
nm_ip_address_dup,
(NMIPAddress * address),
(address));
NM_BACKPORT_SYMBOL(libnm_1_30_8, NMIPRoute *, nm_ip_route_dup, (NMIPRoute * route), (route));
Reference in a new issue View git blame Copy permalink