diff options
Diffstat (limited to 'src/libnm-client-impl/nm-client.c')
| -rw-r--r-- | src/libnm-client-impl/nm-client.c | 8834 |
1 files changed, 8834 insertions, 0 deletions
diff --git a/src/libnm-client-impl/nm-client.c b/src/libnm-client-impl/nm-client.c new file mode 100644 index 00000000..4cbd56dc --- /dev/null +++ b/src/libnm-client-impl/nm-client.c @@ -0,0 +1,8834 @@ +/* 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-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-macsec.h" +#include "nm-device-macvlan.h" +#include "nm-device-modem.h" +#include "nm-device-olpc-mesh.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-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" +#include "nm-wifi-p2p-peer.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_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 : 3; + + 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; + 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(parameters); + 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(parameters); + nm_assert(reply_type); + + task = nm_g_task_new(source_obj, cancellable, source_tag, user_callback, user_callback_data); + + if (!self) { + 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) { + 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(g_main_context_is_owner(_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(g_main_context_is_owner(_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, ¬ify_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(¬ify_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 = (char *) dbobj->nmobj; + if (meta_iface->base_struct_offset > 0) + target_c = *((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); + + 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; + + 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) { + 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); + + 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; +} + +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); +} + +static 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; +} + +void +nml_dbus_property_ao_clear(NMLDBusPropertyAO *pr_ao, NMClient *self) +{ + _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; + gboolean changed_prop = FALSE; + + 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); +} + +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->use_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++) { + _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_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: 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: 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): 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. + **/ +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); + g_return_val_if_fail(length, 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) +{ + 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")); + + 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; + + 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; + + 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, _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_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); + g_return_if_fail(!NM_FLAGS_ANY(v_uint, ~((guint) NM_CLIENT_INSTANCE_FLAGS_ALL))); + v_uint &= ((guint) NM_CLIENT_INSTANCE_FLAGS_ALL); + + 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_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. + * + * 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: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. + * + * Since: 1.10 + * + * The property setter is a synchronous D-Bus call. This is deprecated since 1.22. + */ + 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 settings object 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 settings object 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 settings object 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 settings object 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; +} + +/***************************************************************************** + * 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), ()); |