fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-02-03 19:30:41 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

libnm, core: use _nm_dbus_signal_connect()

Browse source
This commit is contained in:
Dan Winship 2015-03-27 08:03:22 -04:00
parent 4e61f4bf35
commit 1a0bc83c39
7 changed files with 175 additions and 148 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
libnm/nm-object.c
View file

@ -34,6 +34,7 @@
#include "nm-glib-compat.h"
#include "nm-dbus-helpers.h"
#include "nm-client.h"
#include "nm-core-internal.h"
static gboolean debug = FALSE;
#define dbgmsg(f,...) if (G_UNLIKELY (debug)) { g_message (f, ## __VA_ARGS__ ); }
@ -961,20 +962,11 @@ process_properties_changed (NMObject *self, GVariant *properties, gboolean synch
}
static void
property_proxy_signal (GDBusProxy *proxy,
const char *sender_name,
const char *signal_name,
GVariant *parameters,
gpointer user_data)
properties_changed (GDBusProxy *proxy,
GVariant *properties,
gpointer user_data)
{
GVariant *properties;
if (strcmp (signal_name, "PropertiesChanged") != 0)
return;
g_variant_get (parameters, "(@a{sv})", &properties);
process_properties_changed (NM_OBJECT (user_data), properties, FALSE);
g_variant_unref (properties);
}
#define HANDLE_TYPE(vtype, ctype, getter) \
@ -1117,8 +1109,8 @@ _nm_object_register_properties (NMObject *object,
proxy = _nm_object_get_proxy (object, interface);
g_return_if_fail (proxy != NULL);
g_signal_connect (proxy, "g-signal",
G_CALLBACK (property_proxy_signal), object);
_nm_dbus_signal_connect (proxy, "PropertiesChanged", G_VARIANT_TYPE ("(a{sv})"),
G_CALLBACK (properties_changed), object);
instance = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
priv->property_tables = g_slist_prepend (priv->property_tables, instance);

21
src/devices/bluetooth/nm-bluez-device.c
View file

@ -864,21 +864,14 @@ properties_changed (GDBusProxy *proxy,
static void
bluez4_property_changed (GDBusProxy *proxy,
const char *sender,
const char *signal_name,
GVariant *parameters,
gpointer user_data)
const char *property,
GVariant *v,
gpointer user_data)
{
NMBluezDevice *self = NM_BLUEZ_DEVICE (user_data);
if (g_strcmp0 (signal_name, "PropertyChanged") == 0) {
const char *property = NULL;
GVariant *v = NULL;
g_variant_get (parameters, "(&sv)", &property, &v);
_take_one_variant_property (self, property, v);
check_emit_usable (self);
}
_take_one_variant_property (self, property, v);
check_emit_usable (self);
}
static void
@ -985,8 +978,8 @@ on_proxy_acquired (GObject *object, GAsyncResult *res, NMBluezDevice *self)
G_CALLBACK (properties_changed), self);
if (priv->bluez_version == 4) {
/* Watch for custom Bluez4 PropertyChanged signals */
g_signal_connect (priv->proxy, "g-signal",
G_CALLBACK (bluez4_property_changed), self);
_nm_dbus_signal_connect (priv->proxy, "PropertyChanged", G_VARIANT_TYPE ("(sv)"),
G_CALLBACK (bluez4_property_changed), self);
}
query_properties (self);

53
src/devices/bluetooth/nm-bluez5-manager.c
View file

@ -34,6 +34,7 @@
#include "nm-bluez-common.h"
#include "nm-dbus-manager.h"
#include "nm-core-internal.h"
typedef struct {
NMDBusManager *dbus_mgr;
@ -170,39 +171,23 @@ device_removed (GDBusProxy *proxy, const gchar *path, NMBluez5Manager *self)
}
static void
object_manager_g_signal (GDBusProxy *proxy,
gchar *sender_name,
gchar *signal_name,
GVariant *parameters,
NMBluez5Manager *self)
object_manager_interfaces_added (GDBusProxy *proxy,
const char *path,
GVariant *dict,
NMBluez5Manager *self)
{
GVariant *variant;
const gchar *path;
if (g_variant_lookup (dict, BLUEZ5_DEVICE_INTERFACE, "a{sv}", NULL))
device_added (proxy, path, self);
}
if (!strcmp (signal_name, "InterfacesRemoved")) {
const gchar **ifaces;
gsize i, length;
g_variant_get (parameters, "(&o*)", &path, &variant);
ifaces = g_variant_get_strv (variant, &length);
for (i = 0; i < length; i++) {
if (!strcmp (ifaces[i], BLUEZ5_DEVICE_INTERFACE)) {
device_removed (proxy, path, self);
break;
}
}
g_free (ifaces);
} else if (!strcmp (signal_name, "InterfacesAdded")) {
g_variant_get (parameters, "(&o*)", &path, &variant);
if (g_variant_lookup_value (variant, BLUEZ5_DEVICE_INTERFACE,
G_VARIANT_TYPE_DICTIONARY))
device_added (proxy, path, self);
}
static void
object_manager_interfaces_removed (GDBusProxy *proxy,
const char *path,
const char **ifaces,
NMBluez5Manager *self)
{
if (_nm_utils_string_in_list (BLUEZ5_DEVICE_INTERFACE, ifaces))
device_removed (proxy, path, self);
}
static void
@ -264,8 +249,10 @@ on_proxy_acquired (GObject *object,
(GAsyncReadyCallback) get_managed_objects_cb,
self);
g_signal_connect (priv->proxy, "g-signal",
G_CALLBACK (object_manager_g_signal), self);
_nm_dbus_signal_connect (priv->proxy, "InterfacesAdded", G_VARIANT_TYPE ("(oa{sa{sv}})"),
G_CALLBACK (object_manager_interfaces_added), self);
_nm_dbus_signal_connect (priv->proxy, "InterfacesRemoved", G_VARIANT_TYPE ("(oas)"),
G_CALLBACK (object_manager_interfaces_removed), self);
}
static void

24
src/nm-auth-manager.c
View file

@ -24,6 +24,7 @@
#include "nm-logging.h"
#include "nm-errors.h"
#include "nm-core-internal.h"
#define POLKIT_SERVICE "org.freedesktop.PolicyKit1"
#define POLKIT_OBJECT_PATH "/org/freedesktop/PolicyKit1/Authority"
@ -394,21 +395,16 @@ _dbus_on_name_owner_notify_cb (GObject *object,
}
static void
_dbus_on_g_signal_cb (GDBusProxy *proxy,
const gchar *sender_name,
const gchar *signal_name,
GVariant *parameters,
gpointer user_data)
_dbus_on_changed_signal_cb (GDBusProxy *proxy,
gpointer user_data)
{
NMAuthManager *self = user_data;
NMAuthManagerPrivate *priv = NM_AUTH_MANAGER_GET_PRIVATE (self);
g_return_if_fail (priv->proxy == proxy);
_LOGD ("dbus signal: \"%s\"", signal_name ? signal_name : "(null)");
if (g_strcmp0 (signal_name, "Changed") == 0)
_emit_changed_signal (self);
_LOGD ("dbus signal: \"Changed\"");
_emit_changed_signal (self);
}
static void
@ -463,10 +459,9 @@ _dbus_new_proxy_cb (GObject *source_object,
"notify::g-name-owner",
G_CALLBACK (_dbus_on_name_owner_notify_cb),
self);
g_signal_connect (priv->proxy,
"g-signal",
G_CALLBACK (_dbus_on_g_signal_cb),
self);
_nm_dbus_signal_connect (priv->proxy, "Changed", NULL,
G_CALLBACK (_dbus_on_changed_signal_cb),
self);
_log_name_owner (self, NULL);
@ -604,8 +599,7 @@ dispose (GObject *object)
}
if (priv->proxy) {
g_signal_handlers_disconnect_by_func (priv->proxy, _dbus_on_name_owner_notify_cb, self);
g_signal_handlers_disconnect_by_func (priv->proxy, _dbus_on_g_signal_cb, self);
g_signal_handlers_disconnect_by_data (priv->proxy, self);
g_clear_object (&priv->proxy);
}
#endif

17
src/nm-sleep-monitor-systemd.c
View file

@ -28,6 +28,7 @@
#include "nm-logging.h"
#include "nm-dbus-manager.h"
#include "nm-core-internal.h"
#include "nm-sleep-monitor.h"
@ -123,19 +124,12 @@ take_inhibitor (NMSleepMonitor *self)
}
static void
signal_cb (GDBusProxy *proxy,
const gchar *sendername,
const gchar *signalname,
GVariant *args,
gpointer data)
prepare_for_sleep_cb (GDBusProxy *proxy,
gboolean is_about_to_suspend,
gpointer data)
{
NMSleepMonitor *self = data;
gboolean is_about_to_suspend;
if (strcmp (signalname, "PrepareForSleep") != 0)
return;
g_variant_get (args, "(b)", &is_about_to_suspend);
nm_log_dbg (LOGD_SUSPEND, "Received PrepareForSleep signal: %d", is_about_to_suspend);
if (is_about_to_suspend) {
@ -182,7 +176,8 @@ on_proxy_acquired (GObject *object,
}
g_signal_connect (self->sd_proxy, "notify::g-name-owner", G_CALLBACK (name_owner_cb), self);
g_signal_connect (self->sd_proxy, "g-signal", G_CALLBACK (signal_cb), self);
_nm_dbus_signal_connect (self->sd_proxy, "PrepareForSleep", G_VARIANT_TYPE ("(b)"),
G_CALLBACK (prepare_for_sleep_cb), self);
owner = g_dbus_proxy_get_name_owner (self->sd_proxy);
if (owner)

81
src/supplicant-manager/nm-supplicant-interface.c
View file

@ -493,41 +493,59 @@ iface_check_ap_mode_cb (GDBusProxy *proxy, GAsyncResult *result, gpointer user_d
iface_check_ready (self);
}
#define MATCH_SIGNAL(s, n, v, t) (!strcmp (s, n) && g_variant_is_of_type (v, t))
static void
signal_cb (GDBusProxy *proxy,
const gchar *sender,
const gchar *signal,
GVariant *args,
gpointer user_data)
wpas_iface_scan_done (GDBusProxy *proxy,
gboolean success,
gpointer user_data)
{
NMSupplicantInterface *self = NM_SUPPLICANT_INTERFACE (user_data);
NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
const char *path, *field, *message;
gboolean success;
if (MATCH_SIGNAL (signal, "ScanDone", args, G_VARIANT_TYPE ("(b)"))) {
/* Cache last scan completed time */
/* Cache last scan completed time */
priv->last_scan = nm_utils_get_monotonic_timestamp_s ();
g_signal_emit (self, signals[SCAN_DONE], 0, success);
}
static void
wpas_iface_bss_added (GDBusProxy *proxy,
const char *path,
GVariant *props,
gpointer user_data)
{
NMSupplicantInterface *self = NM_SUPPLICANT_INTERFACE (user_data);
NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
if (priv->scanning)
priv->last_scan = nm_utils_get_monotonic_timestamp_s ();
g_variant_get (args, "(b)", &success);
g_signal_emit (self, signals[SCAN_DONE], 0, success);
} else if (MATCH_SIGNAL (signal, "BSSAdded", args, G_VARIANT_TYPE ("(oa{sv})"))) {
if (priv->scanning)
priv->last_scan = nm_utils_get_monotonic_timestamp_s ();
handle_new_bss (self, path);
}
g_variant_get (args, "(&oa{sv})", &path, NULL);
handle_new_bss (self, path);
} else if (MATCH_SIGNAL (signal, "BSSRemoved", args, G_VARIANT_TYPE ("(o)"))) {
g_variant_get (args, "(&o)", &path);
g_signal_emit (self, signals[BSS_REMOVED], 0, path);
g_hash_table_remove (priv->bss_proxies, path);
} else if (MATCH_SIGNAL (signal, "NetworkRequest", args, G_VARIANT_TYPE ("(oss)"))) {
g_variant_get (args, "(&o&s&s)", &path, &field, &message);
if (priv->has_credreq && priv->net_path && !g_strcmp0 (path, priv->net_path))
g_signal_emit (self, signals[CREDENTIALS_REQUEST], 0, field, message);
}
static void
wpas_iface_bss_removed (GDBusProxy *proxy,
const char *path,
gpointer user_data)
{
NMSupplicantInterface *self = NM_SUPPLICANT_INTERFACE (user_data);
NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
g_signal_emit (self, signals[BSS_REMOVED], 0, path);
g_hash_table_remove (priv->bss_proxies, path);
}
static void
wpas_iface_network_request (GDBusProxy *proxy,
const char *path,
const char *field,
const char *message,
gpointer user_data)
{
NMSupplicantInterface *self = NM_SUPPLICANT_INTERFACE (user_data);
NMSupplicantInterfacePrivate *priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
if (priv->has_credreq && priv->net_path && !g_strcmp0 (path, priv->net_path))
g_signal_emit (self, signals[CREDENTIALS_REQUEST], 0, field, message);
}
static void
@ -602,7 +620,14 @@ on_iface_proxy_acquired (GDBusProxy *proxy, GAsyncResult *result, gpointer user_
self = NM_SUPPLICANT_INTERFACE (user_data);
priv = NM_SUPPLICANT_INTERFACE_GET_PRIVATE (self);
g_signal_connect (priv->iface_proxy, "g-signal", G_CALLBACK (signal_cb), self);
_nm_dbus_signal_connect (priv->iface_proxy, "ScanDone", G_VARIANT_TYPE ("(b)"),
G_CALLBACK (wpas_iface_scan_done), self);
_nm_dbus_signal_connect (priv->iface_proxy, "BSSAdded", G_VARIANT_TYPE ("(oa{sv})"),
G_CALLBACK (wpas_iface_bss_added), self);
_nm_dbus_signal_connect (priv->iface_proxy, "BSSRemoved", G_VARIANT_TYPE ("(o)"),
G_CALLBACK (wpas_iface_bss_removed), self);
_nm_dbus_signal_connect (priv->iface_proxy, "NetworkRequest", G_VARIANT_TYPE ("(oss)"),
G_CALLBACK (wpas_iface_network_request), self);
/* Check whether NetworkReply and AP mode are supported */
priv->ready_count = 1;

107
src/vpn-manager/nm-vpn-connection.c
View file

@ -1580,44 +1580,74 @@ really_activate (NMVpnConnection *self, const char *username)
_set_vpn_state (self, STATE_CONNECT, NM_VPN_CONNECTION_STATE_REASON_NONE, FALSE);
}
#define MATCH_SIGNAL(s, n, v, t) (!strcmp (s, n) && g_variant_is_of_type (v, t))
static void
failure_cb (GDBusProxy *proxy,
guint32 reason,
gpointer user_data)
{
NMVpnConnection *self = NM_VPN_CONNECTION (user_data);
plugin_failed (self, reason);
}
static void
signal_cb (GDBusProxy *proxy,
const gchar *sender,
const gchar *signal,
GVariant *args,
gpointer user_data)
state_changed_cb (GDBusProxy *proxy,
guint32 new_service_state,
gpointer user_data)
{
NMVpnConnection *self = NM_VPN_CONNECTION (user_data);
plugin_state_changed (self, new_service_state);
}
static void
secrets_required_cb (GDBusProxy *proxy,
const char *message,
const char **secrets,
gpointer user_data)
{
NMVpnConnection *self = NM_VPN_CONNECTION (user_data);
plugin_interactive_secrets_required (self, message, secrets);
}
static void
config_cb (GDBusProxy *proxy,
GVariant *dict,
gpointer user_data)
{
NMVpnConnection *self = NM_VPN_CONNECTION (user_data);
NMVpnConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (self);
const char *message, **secrets;
gs_unref_variant GVariant *dict = NULL;
guint u32;
if (MATCH_SIGNAL (signal, "Failure", args, G_VARIANT_TYPE ("(u)"))) {
g_variant_get (args, "(u)", &u32);
plugin_failed (self, u32);
} else if (MATCH_SIGNAL (signal, "StateChanged", args, G_VARIANT_TYPE ("(u)"))) {
g_variant_get (args, "(u)", &u32);
plugin_state_changed (self, u32);
} else if (MATCH_SIGNAL (signal, "SecretsRequired", args, G_VARIANT_TYPE ("(sas)"))) {
g_variant_get (args, "(&s^a&s)", &message, &secrets);
plugin_interactive_secrets_required (self, message, secrets);
g_free (secrets);
} else if (priv->vpn_state >= STATE_NEED_AUTH) {
/* Only list to these signals during and after connection */
if (MATCH_SIGNAL (signal, "Config", args, G_VARIANT_TYPE ("(a{sv})"))) {
g_variant_get (args, "(@a{sv})", &dict);
nm_vpn_connection_config_get (self, dict);
} else if (MATCH_SIGNAL (signal, "Ip4Config", args, G_VARIANT_TYPE ("(a{sv})"))) {
g_variant_get (args, "(@a{sv})", &dict);
nm_vpn_connection_ip4_config_get (self, dict);
} else if (MATCH_SIGNAL (signal, "Ip6Config", args, G_VARIANT_TYPE ("(a{sv})"))) {
g_variant_get (args, "(@a{sv})", &dict);
nm_vpn_connection_ip6_config_get (self, dict);
}
}
/* Only list to this signals during and after connection */
if (priv->vpn_state >= STATE_NEED_AUTH)
nm_vpn_connection_config_get (self, dict);
}
static void
ip4_config_cb (GDBusProxy *proxy,
GVariant *dict,
gpointer user_data)
{
NMVpnConnection *self = NM_VPN_CONNECTION (user_data);
NMVpnConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (self);
/* Only list to this signals during and after connection */
if (priv->vpn_state >= STATE_NEED_AUTH)
nm_vpn_connection_ip4_config_get (self, dict);
}
static void
ip6_config_cb (GDBusProxy *proxy,
GVariant *dict,
gpointer user_data)
{
NMVpnConnection *self = NM_VPN_CONNECTION (user_data);
NMVpnConnectionPrivate *priv = NM_VPN_CONNECTION_GET_PRIVATE (self);
/* Only list to this signals during and after connection */
if (priv->vpn_state >= STATE_NEED_AUTH)
nm_vpn_connection_ip6_config_get (self, dict);
}
static void
@ -1648,7 +1678,18 @@ on_proxy_acquired (GObject *object, GAsyncResult *result, gpointer user_data)
}
priv->proxy = proxy;
g_signal_connect (priv->proxy, "g-signal", G_CALLBACK (signal_cb), self);
_nm_dbus_signal_connect (priv->proxy, "Failure", G_VARIANT_TYPE ("(u)"),
G_CALLBACK (failure_cb), self);
_nm_dbus_signal_connect (priv->proxy, "StateChanged", G_VARIANT_TYPE ("(u)"),
G_CALLBACK (state_changed_cb), self);
_nm_dbus_signal_connect (priv->proxy, "SecretsRequired", G_VARIANT_TYPE ("(sas)"),
G_CALLBACK (secrets_required_cb), self);
_nm_dbus_signal_connect (priv->proxy, "Config", G_VARIANT_TYPE ("(a{sv})"),
G_CALLBACK (config_cb), self);
_nm_dbus_signal_connect (priv->proxy, "Ip4Config", G_VARIANT_TYPE ("(a{sv})"),
G_CALLBACK (ip4_config_cb), self);
_nm_dbus_signal_connect (priv->proxy, "Ip6Config", G_VARIANT_TYPE ("(a{sv})"),
G_CALLBACK (ip6_config_cb), self);
_set_vpn_state (self, STATE_NEED_AUTH, NM_VPN_CONNECTION_STATE_REASON_NONE, FALSE);