Port libnm-core/libnm to GDBus.
The NetworkManager daemon continues to use dbus-glib; the
previously-added connection hash/variant conversion methods are now
moved to NetworkManagerUtils (along with a few other utilities that
are now only needed by the daemon code).
/initscript/*/[Nn]etwork[Mm]anager
/introspection/all.xml
+/introspection/nmdbus-*.c
+/introspection/nmdbus-*.h
/libgsystem/
SUBDIRS = \
. \
include \
+ introspection \
libnm-core \
libnm \
libnm-util \
libnm-glib \
- introspection \
src \
callouts \
clients \
libnmdbus-dispatcher.la \
$(GLIB_LIBS)
-# We have to build the gdbus generated code separately, without
-# -DGLIB_VERSION_MAX_ALLOWED, due to a bug in GLib 2.38
+# See note about gdbus-codegen in introspection/Makefile.am
noinst_LTLIBRARIES += libnmdbus-dispatcher.la
-I${top_builddir}/libnm-core \
-I${top_srcdir}/libnm \
-I${top_builddir}/libnm \
- $(DBUS_CFLAGS) \
$(GLIB_CFLAGS) \
-DNM_VERSION_MAX_ALLOWED=NM_VERSION_NEXT_STABLE \
-DNMLOCALEDIR=\"$(datadir)/locale\"
nm_online_LDADD = \
$(top_builddir)/libnm/libnm.la \
- $(DBUS_LIBS) \
$(GLIB_LIBS)
-I${top_builddir}/libnm-core \
-I${top_srcdir}/libnm \
-I${top_builddir}/libnm \
- $(DBUS_CFLAGS) \
$(GLIB_CFLAGS) \
-DG_LOG_DOMAIN=\""nmcli"\" \
-DNM_VERSION_MAX_ALLOWED=NM_VERSION_NEXT_STABLE \
utils.h
nmcli_LDADD = \
- $(DBUS_LIBS) \
$(GLIB_LIBS) \
$(READLINE_LIBS) \
$(top_builddir)/libnm/libnm.la
nmc->get_client (nmc); /* create NMClient */
nm_client_set_logging (nmc->client, level, domains, &error);
if (error) {
- if (g_error_matches (error, DBUS_GERROR, DBUS_GERROR_ACCESS_DENIED))
+ if (g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_AUTH_FAILED))
g_string_printf (nmc->return_text, _("Error: access denied to set logging; %s"), error->message);
else
g_string_printf (nmc->return_text, _("Error: %s"), error->message);
-I$(srcdir)/newt \
$(GLIB_CFLAGS) \
$(NEWT_CFLAGS) \
- $(DBUS_CFLAGS) \
$(GUDEV_CFLAGS) \
-DG_LOG_DOMAIN=\""nmtui"\" \
-DNM_VERSION_MAX_ALLOWED=NM_VERSION_NEXT_STABLE \
$(top_builddir)/libnm/libnm.la \
$(builddir)/newt/libnmt-newt.a \
$(GUDEV_LIBS) \
- $(DBUS_LIBS) \
$(NEWT_LIBS) \
$(GLIB_LIBS) \
$(NULL)
nm-object-private.h \
nm-param-spec-dbus.h \
nm-remote-connection-private.h \
- nm-secret-agent-glue.h \
nm-setting-private.h \
nm-types-private.h \
- nm-utils-private.h \
- nm-vpn-plugin-glue.h
+ nm-utils-private.h
# Images to copy into HTML directory.
HTML_IMAGES = libnm.png
-I${top_builddir}/libnm-core \
-I${top_srcdir}/libnm \
-I${top_builddir}/libnm \
- $(DBUS_CFLAGS) \
$(GLIB_CFLAGS)
noinst_PROGRAMS = \
add_connection_libnm_SOURCES = add-connection-libnm.c
add_connection_libnm_LDADD = \
$(top_builddir)/libnm/libnm.la \
- $(DBUS_LIBS) \
$(GLIB_LIBS)
get_active_connections_gdbus_SOURCES = get-active-connections-gdbus.c
get_ap_info_libnm_SOURCES = get-ap-info-libnm.c
get_ap_info_libnm_LDADD = \
$(top_builddir)/libnm/libnm.la \
- $(DBUS_LIBS) \
$(GLIB_LIBS)
list_connections_gdbus_SOURCES = list-connections-gdbus.c
list_connections_libnm_SOURCES = list-connections-libnm.c
list_connections_libnm_LDADD = \
$(top_builddir)/libnm/libnm.la \
- $(DBUS_LIBS) \
$(GLIB_LIBS)
monitor_nm_running_gdbus_SOURCES = monitor-nm-running-gdbus.c
+noinst_LTLIBRARIES = \
+ libnmdbus.la
+
+# gdbus-codegen 2.38 will emit code that requires glib 2.38, which
+# will then cause availability warnings if we define
+# GLIB_VERSION_MAX_ALLOWED=GLIB_VERSION_2_32.
+#
+# This is fixed in GLib 2.40 (it emits code that takes
+# GLIB_VERSION_MAX_ALLOWED into account), so this workaround can go
+# away when we depend on that.
+AM_CPPFLAGS = $(filter-out -DGLIB_VERSION_MAX_ALLOWED%,$(GLIB_CFLAGS))
+
+nodist_libnmdbus_la_SOURCES = \
+ nmdbus-access-point.c \
+ nmdbus-access-point.h \
+ nmdbus-active-connection.c \
+ nmdbus-active-connection.h \
+ nmdbus-agent-manager.c \
+ nmdbus-agent-manager.h \
+ nmdbus-device-bond.c \
+ nmdbus-device-bond.h \
+ nmdbus-device-bridge.c \
+ nmdbus-device-bridge.h \
+ nmdbus-device-bt.c \
+ nmdbus-device-bt.h \
+ nmdbus-device-ethernet.c \
+ nmdbus-device-ethernet.h \
+ nmdbus-device.c \
+ nmdbus-device.h \
+ nmdbus-device-generic.c \
+ nmdbus-device-generic.h \
+ nmdbus-device-gre.c \
+ nmdbus-device-gre.h \
+ nmdbus-device-infiniband.c \
+ nmdbus-device-infiniband.h \
+ nmdbus-device-macvlan.c \
+ nmdbus-device-macvlan.h \
+ nmdbus-device-tun.c \
+ nmdbus-device-tun.h \
+ nmdbus-device-veth.c \
+ nmdbus-device-veth.h \
+ nmdbus-device-vlan.c \
+ nmdbus-device-vlan.h \
+ nmdbus-device-vxlan.c \
+ nmdbus-device-vxlan.h \
+ nmdbus-device-wifi.c \
+ nmdbus-device-wifi.h \
+ nmdbus-device-wimax.c \
+ nmdbus-device-wimax.h \
+ nmdbus-dhcp4-config.c \
+ nmdbus-dhcp4-config.h \
+ nmdbus-dhcp6-config.c \
+ nmdbus-dhcp6-config.h \
+ nmdbus-ip4-config.c \
+ nmdbus-ip4-config.h \
+ nmdbus-ip6-config.c \
+ nmdbus-ip6-config.h \
+ nmdbus-manager.c \
+ nmdbus-manager.h \
+ nmdbus-ppp-manager.c \
+ nmdbus-ppp-manager.h \
+ nmdbus-secret-agent.c \
+ nmdbus-secret-agent.h \
+ nmdbus-settings-connection.c \
+ nmdbus-settings-connection.h \
+ nmdbus-settings.c \
+ nmdbus-settings.h \
+ nmdbus-vpn-connection.c \
+ nmdbus-vpn-connection.h \
+ nmdbus-vpn-plugin.c \
+ nmdbus-vpn-plugin.h
+
+define _make_nmdbus_rule
+$(1): $(patsubst nmdbus-%.c,nm-%.xml,$(1))
+ $$(AM_V_GEN) gdbus-codegen \
+ --generate-c-code $$(basename $$@) \
+ --c-namespace NMDBus \
+ --interface-prefix org.freedesktop.NetworkManager \
+ $$<
+
+$(basename $(1)).h: $(1)
+ @true
+endef
+
+$(foreach f,$(filter %.c,$(nodist_libnmdbus_la_SOURCES)),$(eval $(call _make_nmdbus_rule,$f)))
+
+CLEANFILES = $(nodist_libnmdbus_la_SOURCES)
+
EXTRA_DIST = \
all.xml.in \
generic-types.xml \
<node name="/" xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0">
<interface name="org.freedesktop.NetworkManager.Device.Wired">
+ <annotation name="org.gtk.GDBus.C.Name" value="DeviceEthernet"/>
<property name="HwAddress" type="s" access="read">
<tp:docstring>
<node name="/" xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0">
<interface name="org.freedesktop.NetworkManager.Device.Wireless">
+ <annotation name="org.gtk.GDBus.C.Name" value="DeviceWifi"/>
+
<method name="GetAccessPoints">
<annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_device_get_access_points"/>
<arg name="access_points" type="ao" direction="out">
<node name="/org/freedesktop/NetworkManager" xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0">
<interface name="org.freedesktop.NetworkManager">
+ <annotation name="org.gtk.GDBus.C.Name" value="Manager"/>
+
<method name="GetDevices">
<tp:docstring>
Get the list of network devices.
<node name="/">
<interface name="org.freedesktop.NetworkManager.PPP">
+ <annotation name="org.gtk.GDBus.C.Name" value="PPP_Manager"/>
+
<method name="NeedSecrets">
<annotation name="org.freedesktop.DBus.GLib.CSymbol" value="impl_ppp_manager_need_secrets"/>
<annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
<node name="/" xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0">
<interface name="org.freedesktop.NetworkManager.VPN.Connection">
+ <annotation name="org.gtk.GDBus.C.Name" value="VpnConnection"/>
+
<tp:docstring>
Represents an active connection to a Virtual Private Network.
</tp:docstring>
<node name="/" xmlns:tp="http://telepathy.freedesktop.org/wiki/DbusSpec#extensions-v0">
<interface name="org.freedesktop.NetworkManager.VPN.Plugin">
+ <annotation name="org.gtk.GDBus.C.Name" value="VpnPlugin"/>
+
<tp:docstring>
This interface is provided by plugins providing VPN services to the NetworkManager daemon.
</tp:docstring>
-DG_LOG_DOMAIN=\""libnm"\" \
-DNETWORKMANAGER_COMPILATION \
-DNM_VERSION_MAX_ALLOWED=NM_VERSION_NEXT_STABLE \
- $(GLIB_CFLAGS) \
- $(DBUS_CFLAGS)
+ $(GLIB_CFLAGS)
noinst_LTLIBRARIES = libnm-core.la
libnm_core_la_LIBADD = \
$(GLIB_LIBS) \
- $(DBUS_LIBS) \
$(UUID_LIBS)
if WITH_GNUTLS
GDestroyNotify free_func);
GPtrArray *_nm_utils_copy_object_array (const GPtrArray *array);
-/* compat */
-
-GVariant *_nm_utils_connection_hash_to_dict (GHashTable *hash);
-GHashTable *_nm_utils_connection_dict_to_hash (GVariant *dict);
-
#endif
gboolean _nm_utils_string_slist_validate (GSList *list,
const char **valid_values);
-gboolean _nm_utils_gvalue_array_validate (GValueArray *elements,
- guint n_expected, ...);
-
/* D-Bus transform funcs */
GVariant * _nm_utils_hwaddr_to_dbus (const GValue *prop_value);
#include "nm-utils.h"
#include "nm-utils-private.h"
#include "nm-glib-compat.h"
-#include "nm-dbus-glib-types.h"
#include "nm-setting-private.h"
#include "crypto.h"
return memcmp (ssid1, ssid2, len1) == 0 ? TRUE : FALSE;
}
-static void
-value_destroy (gpointer data)
-{
- GValue *value = (GValue *) data;
-
- g_value_unset (value);
- g_slice_free (GValue, value);
-}
-
-static void
-value_dup (gpointer key, gpointer val, gpointer user_data)
-{
- GHashTable *table = (GHashTable *) user_data;
- GValue *value = (GValue *) val;
- GValue *dup_value;
-
- dup_value = g_slice_new0 (GValue);
- g_value_init (dup_value, G_VALUE_TYPE (val));
- g_value_copy (value, dup_value);
-
- g_hash_table_insert (table, g_strdup ((char *) key), dup_value);
-}
-
-/**
- * nm_utils_gvalue_hash_dup:
- * @hash: a #GHashTable mapping string:GValue
- *
- * Utility function to duplicate a hash table of #GValues.
- *
- * Returns: (transfer container) (element-type utf8 GObject.Value): a newly allocated duplicated #GHashTable, caller must free the
- * returned hash with g_hash_table_unref() or g_hash_table_destroy()
- **/
-GHashTable *
-nm_utils_gvalue_hash_dup (GHashTable *hash)
-{
- GHashTable *table;
-
- g_return_val_if_fail (hash != NULL, NULL);
-
- table = g_hash_table_new_full (g_str_hash, g_str_equal,
- (GDestroyNotify) g_free,
- value_destroy);
-
- g_hash_table_foreach (hash, value_dup, table);
-
- return table;
-}
-
gboolean
_nm_utils_string_in_list (const char *str, const char **valid_strings)
{
return TRUE;
}
-gboolean
-_nm_utils_gvalue_array_validate (GValueArray *elements, guint n_expected, ...)
-{
- va_list args;
- GValue *tmp;
- int i;
- gboolean valid = FALSE;
-
- if (n_expected != elements->n_values)
- return FALSE;
-
- va_start (args, n_expected);
- for (i = 0; i < n_expected; i++) {
- tmp = g_value_array_get_nth (elements, i);
- if (G_VALUE_TYPE (tmp) != va_arg (args, GType))
- goto done;
- }
- valid = TRUE;
-
-done:
- va_end (args);
- return valid;
-}
-
/**
* _nm_utils_hash_values_to_slist:
* @hash: a #GHashTable
return list;
}
-/**
- * _nm_utils_connection_hash_to_dict:
- * @hash: a hashed #NMConnection
- *
- * Returns: a (floating) #GVariant equivalent to @hash.
- */
-GVariant *
-_nm_utils_connection_hash_to_dict (GHashTable *hash)
-{
- GValue val = { 0, };
- GVariant *variant;
-
- if (!hash)
- return NULL;
-
- g_value_init (&val, DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT);
- g_value_set_boxed (&val, hash);
- variant = dbus_g_value_build_g_variant (&val);
- g_value_unset (&val);
-
- return variant;
-}
-
-/**
- * _nm_utils_connection_dict_to_hash:
- * @dict: a #GVariant-serialized #NMConnection
- *
- * Returns: a #GHashTable equivalent to @dict.
- */
-GHashTable *
-_nm_utils_connection_dict_to_hash (GVariant *dict)
-{
- GValue val = { 0, };
-
- if (!dict)
- return NULL;
-
- dbus_g_value_parse_g_variant (dict, &val);
- return g_value_get_boxed (&val);
-}
-
GVariant *
_nm_utils_strdict_to_dbus (const GValue *prop_value)
{
return TRUE;
}
-/**
- * nm_utils_ip4_addresses_from_gvalue:
- * @value: #GValue containing a #GPtrArray of #GArrays of #guint32s
- *
- * Utility function to convert a #GPtrArray of #GArrays of #guint32s representing
- * a list of NetworkManager IPv4 addresses (which is a tuple of address, gateway,
- * and prefix) into a #GSList of #NMIP4Address objects. The specific format of
- * this serialization is not guaranteed to be stable and the #GArray may be
- * extended in the future.
- *
- * Returns: (transfer full) (element-type NMIP4Address): a newly allocated #GSList of #NMIP4Address objects
- **/
-GSList *
-nm_utils_ip4_addresses_from_gvalue (const GValue *value)
-{
- GPtrArray *addresses;
- int i;
- GSList *list = NULL;
-
- addresses = (GPtrArray *) g_value_get_boxed (value);
- for (i = 0; addresses && (i < addresses->len); i++) {
- GArray *array = (GArray *) g_ptr_array_index (addresses, i);
- NMIP4Address *addr;
-
- if (array->len < 3) {
- g_warning ("Ignoring invalid IP4 address");
- continue;
- }
-
- addr = nm_ip4_address_new ();
- nm_ip4_address_set_address (addr, g_array_index (array, guint32, 0));
- nm_ip4_address_set_prefix (addr, g_array_index (array, guint32, 1));
- nm_ip4_address_set_gateway (addr, g_array_index (array, guint32, 2));
- list = g_slist_prepend (list, addr);
- }
-
- return g_slist_reverse (list);
-}
-
-/**
- * nm_utils_ip4_addresses_to_gvalue:
- * @list: (element-type NMIP4Address): a list of #NMIP4Address objects
- * @value: a pointer to a #GValue into which to place the converted addresses,
- * which should be unset by the caller (when no longer needed) with
- * g_value_unset().
- *
- * Utility function to convert a #GSList of #NMIP4Address objects into a
- * #GPtrArray of #GArrays of #guint32s representing a list of NetworkManager IPv4
- * addresses (which is a tuple of address, gateway, and prefix). The specific
- * format of this serialization is not guaranteed to be stable and may be
- * extended in the future.
- **/
-void
-nm_utils_ip4_addresses_to_gvalue (GSList *list, GValue *value)
-{
- GPtrArray *addresses;
- GSList *iter;
-
- addresses = g_ptr_array_new ();
-
- for (iter = list; iter; iter = iter->next) {
- NMIP4Address *addr = (NMIP4Address *) iter->data;
- GArray *array;
- guint32 tmp;
-
- array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3);
-
- tmp = nm_ip4_address_get_address (addr);
- g_array_append_val (array, tmp);
-
- tmp = nm_ip4_address_get_prefix (addr);
- g_array_append_val (array, tmp);
-
- tmp = nm_ip4_address_get_gateway (addr);
- g_array_append_val (array, tmp);
-
- g_ptr_array_add (addresses, array);
- }
-
- g_value_take_boxed (value, addresses);
-}
-
-/**
- * nm_utils_ip4_routes_from_gvalue:
- * @value: #GValue containing a #GPtrArray of #GArrays of #guint32s
- *
- * Utility function to convert a #GPtrArray of #GArrays of #guint32s representing
- * a list of NetworkManager IPv4 routes (which is a tuple of route, next hop,
- * prefix, and metric) into a #GSList of #NMIP4Route objects. The specific
- * format of this serialization is not guaranteed to be stable and may be
- * extended in the future.
- *
- * Returns: (transfer full) (element-type NMIP4Route): a newly allocated #GSList of #NMIP4Route objects
- **/
-GSList *
-nm_utils_ip4_routes_from_gvalue (const GValue *value)
-{
- GPtrArray *routes;
- int i;
- GSList *list = NULL;
-
- routes = (GPtrArray *) g_value_get_boxed (value);
- for (i = 0; routes && (i < routes->len); i++) {
- GArray *array = (GArray *) g_ptr_array_index (routes, i);
- NMIP4Route *route;
-
- if (array->len < 4) {
- g_warning ("Ignoring invalid IP4 route");
- continue;
- }
-
- route = nm_ip4_route_new ();
- nm_ip4_route_set_dest (route, g_array_index (array, guint32, 0));
- nm_ip4_route_set_prefix (route, g_array_index (array, guint32, 1));
- nm_ip4_route_set_next_hop (route, g_array_index (array, guint32, 2));
- nm_ip4_route_set_metric (route, g_array_index (array, guint32, 3));
- list = g_slist_prepend (list, route);
- }
-
- return g_slist_reverse (list);
-}
-
-/**
- * nm_utils_ip4_routes_to_gvalue:
- * @list: (element-type NMIP4Route): a list of #NMIP4Route objects
- * @value: a pointer to a #GValue into which to place the converted routes,
- * which should be unset by the caller (when no longer needed) with
- * g_value_unset().
- *
- * Utility function to convert a #GSList of #NMIP4Route objects into a
- * #GPtrArray of #GArrays of #guint32s representing a list of NetworkManager IPv4
- * routes (which is a tuple of route, next hop, prefix, and metric). The
- * specific format of this serialization is not guaranteed to be stable and may
- * be extended in the future.
- **/
-void
-nm_utils_ip4_routes_to_gvalue (GSList *list, GValue *value)
-{
- GPtrArray *routes;
- GSList *iter;
-
- routes = g_ptr_array_new ();
-
- for (iter = list; iter; iter = iter->next) {
- NMIP4Route *route = (NMIP4Route *) iter->data;
- GArray *array;
- guint32 tmp;
-
- array = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3);
-
- tmp = nm_ip4_route_get_dest (route);
- g_array_append_val (array, tmp);
-
- tmp = nm_ip4_route_get_prefix (route);
- g_array_append_val (array, tmp);
-
- tmp = nm_ip4_route_get_next_hop (route);
- g_array_append_val (array, tmp);
-
- tmp = nm_ip4_route_get_metric (route);
- g_array_append_val (array, tmp);
-
- g_ptr_array_add (routes, array);
- }
-
- g_value_take_boxed (value, routes);
-}
-
/**
* nm_utils_ip4_dns_to_variant:
* @dns: (type utf8): an array of IP address strings
return 24; /* Class C - 255.255.255.0 */
}
-/**
- * nm_utils_ip6_addresses_from_gvalue:
- * @value: gvalue containing a GPtrArray of GValueArrays of (GArray of guchars) and #guint32
- *
- * Utility function to convert a #GPtrArray of #GValueArrays of (#GArray of guchars) and #guint32
- * representing a list of NetworkManager IPv6 addresses (which is a tuple of address,
- * prefix, and gateway), into a #GSList of #NMIP6Address objects. The specific format of
- * this serialization is not guaranteed to be stable and the #GValueArray may be
- * extended in the future.
- *
- * Returns: (transfer full) (element-type NMIP6Address): a newly allocated #GSList of #NMIP6Address objects
- **/
-GSList *
-nm_utils_ip6_addresses_from_gvalue (const GValue *value)
-{
- GPtrArray *addresses;
- int i;
- GSList *list = NULL;
-
- addresses = (GPtrArray *) g_value_get_boxed (value);
-
- for (i = 0; addresses && (i < addresses->len); i++) {
- GValueArray *elements = (GValueArray *) g_ptr_array_index (addresses, i);
- GValue *tmp;
- GByteArray *ba_addr;
- GByteArray *ba_gw = NULL;
- NMIP6Address *addr;
- guint32 prefix;
-
- if (elements->n_values < 2 || elements->n_values > 3) {
- g_warning ("%s: ignoring invalid IP6 address structure", __func__);
- continue;
- }
-
- /* Third element (gateway) is optional */
- if ( !_nm_utils_gvalue_array_validate (elements, 2, DBUS_TYPE_G_UCHAR_ARRAY, G_TYPE_UINT)
- && !_nm_utils_gvalue_array_validate (elements, 3, DBUS_TYPE_G_UCHAR_ARRAY, G_TYPE_UINT, DBUS_TYPE_G_UCHAR_ARRAY)) {
- g_warning ("%s: ignoring invalid IP6 address structure", __func__);
- continue;
- }
-
- tmp = g_value_array_get_nth (elements, 0);
- ba_addr = g_value_get_boxed (tmp);
- if (ba_addr->len != 16) {
- g_warning ("%s: ignoring invalid IP6 address of length %d",
- __func__, ba_addr->len);
- continue;
- }
-
- tmp = g_value_array_get_nth (elements, 1);
- prefix = g_value_get_uint (tmp);
- if (prefix > 128) {
- g_warning ("%s: ignoring invalid IP6 prefix %d",
- __func__, prefix);
- continue;
- }
-
- if (elements->n_values == 3) {
- tmp = g_value_array_get_nth (elements, 2);
- ba_gw = g_value_get_boxed (tmp);
- if (ba_gw->len != 16) {
- g_warning ("%s: ignoring invalid IP6 gateway address of length %d",
- __func__, ba_gw->len);
- continue;
- }
- }
-
- addr = nm_ip6_address_new ();
- nm_ip6_address_set_prefix (addr, prefix);
- nm_ip6_address_set_address (addr, (const struct in6_addr *) ba_addr->data);
- if (ba_gw)
- nm_ip6_address_set_gateway (addr, (const struct in6_addr *) ba_gw->data);
-
- list = g_slist_prepend (list, addr);
- }
-
- return g_slist_reverse (list);
-}
-
-/**
- * nm_utils_ip6_addresses_to_gvalue:
- * @list: (element-type NMIP6Address): a list of #NMIP6Address objects
- * @value: a pointer to a #GValue into which to place the converted addresses,
- * which should be unset by the caller (when no longer needed) with
- * g_value_unset().
- *
- * Utility function to convert a #GSList of #NMIP6Address objects into a
- * #GPtrArray of #GValueArrays representing a list of NetworkManager IPv6 addresses
- * (which is a tuple of address, prefix, and gateway). The specific format of
- * this serialization is not guaranteed to be stable and may be extended in the
- * future.
- **/
-void
-nm_utils_ip6_addresses_to_gvalue (GSList *list, GValue *value)
-{
- GPtrArray *addresses;
- GSList *iter;
-
- addresses = g_ptr_array_new ();
-
- for (iter = list; iter; iter = iter->next) {
- NMIP6Address *addr = (NMIP6Address *) iter->data;
- GValueArray *array;
- GValue element = G_VALUE_INIT;
- GByteArray *ba;
-
- array = g_value_array_new (3);
-
- /* IP address */
- g_value_init (&element, DBUS_TYPE_G_UCHAR_ARRAY);
- ba = g_byte_array_new ();
- g_byte_array_append (ba, (guint8 *) nm_ip6_address_get_address (addr), 16);
- g_value_take_boxed (&element, ba);
- g_value_array_append (array, &element);
- g_value_unset (&element);
-
- /* Prefix */
- g_value_init (&element, G_TYPE_UINT);
- g_value_set_uint (&element, nm_ip6_address_get_prefix (addr));
- g_value_array_append (array, &element);
- g_value_unset (&element);
-
- /* Gateway */
- g_value_init (&element, DBUS_TYPE_G_UCHAR_ARRAY);
- ba = g_byte_array_new ();
- g_byte_array_append (ba, (guint8 *) nm_ip6_address_get_gateway (addr), 16);
- g_value_take_boxed (&element, ba);
- g_value_array_append (array, &element);
- g_value_unset (&element);
-
- g_ptr_array_add (addresses, array);
- }
-
- g_value_take_boxed (value, addresses);
-}
-
-/**
- * nm_utils_ip6_routes_from_gvalue:
- * @value: #GValue containing a #GPtrArray of #GValueArrays of (#GArray of #guchars), #guint32,
- * (#GArray of #guchars), and #guint32
- *
- * Utility function #GPtrArray of #GValueArrays of (#GArray of #guchars), #guint32,
- * (#GArray of #guchars), and #guint32 representing a list of NetworkManager IPv6
- * routes (which is a tuple of destination, prefix, next hop, and metric)
- * into a #GSList of #NMIP6Route objects. The specific format of this serialization
- * is not guaranteed to be stable and may be extended in the future.
- *
- * Returns: (transfer full) (element-type NMIP6Route): a newly allocated #GSList of #NMIP6Route objects
- **/
-GSList *
-nm_utils_ip6_routes_from_gvalue (const GValue *value)
-{
- GPtrArray *routes;
- int i;
- GSList *list = NULL;
-
- routes = (GPtrArray *) g_value_get_boxed (value);
- for (i = 0; routes && (i < routes->len); i++) {
- GValueArray *route_values = (GValueArray *) g_ptr_array_index (routes, i);
- GByteArray *dest, *next_hop;
- guint prefix, metric;
- NMIP6Route *route;
-
- if (!_nm_utils_gvalue_array_validate (route_values, 4,
- DBUS_TYPE_G_UCHAR_ARRAY,
- G_TYPE_UINT,
- DBUS_TYPE_G_UCHAR_ARRAY,
- G_TYPE_UINT)) {
- g_warning ("Ignoring invalid IP6 route");
- continue;
- }
-
- dest = g_value_get_boxed (g_value_array_get_nth (route_values, 0));
- if (dest->len != 16) {
- g_warning ("%s: ignoring invalid IP6 dest address of length %d",
- __func__, dest->len);
- continue;
- }
-
- prefix = g_value_get_uint (g_value_array_get_nth (route_values, 1));
-
- next_hop = g_value_get_boxed (g_value_array_get_nth (route_values, 2));
- if (next_hop->len != 16) {
- g_warning ("%s: ignoring invalid IP6 next_hop address of length %d",
- __func__, next_hop->len);
- continue;
- }
-
- metric = g_value_get_uint (g_value_array_get_nth (route_values, 3));
-
- route = nm_ip6_route_new ();
- nm_ip6_route_set_dest (route, (struct in6_addr *)dest->data);
- nm_ip6_route_set_prefix (route, prefix);
- nm_ip6_route_set_next_hop (route, (struct in6_addr *)next_hop->data);
- nm_ip6_route_set_metric (route, metric);
- list = g_slist_prepend (list, route);
- }
-
- return g_slist_reverse (list);
-}
-
-/**
- * nm_utils_ip6_routes_to_gvalue:
- * @list: (element-type NMIP6Route): a list of #NMIP6Route objects
- * @value: a pointer to a #GValue into which to place the converted routes,
- * which should be unset by the caller (when no longer needed) with
- * g_value_unset().
- *
- * Utility function to convert a #GSList of #NMIP6Route objects into a #GPtrArray of
- * #GValueArrays of (#GArray of #guchars), #guint32, (#GArray of #guchars), and #guint32
- * representing a list of NetworkManager IPv6 routes (which is a tuple of destination,
- * prefix, next hop, and metric). The specific format of this serialization is not
- * guaranteed to be stable and may be extended in the future.
- **/
-void
-nm_utils_ip6_routes_to_gvalue (GSList *list, GValue *value)
-{
- GPtrArray *routes;
- GSList *iter;
-
- routes = g_ptr_array_new ();
-
- for (iter = list; iter; iter = iter->next) {
- NMIP6Route *route = (NMIP6Route *) iter->data;
- GValueArray *array;
- const struct in6_addr *addr;
- GByteArray *ba;
- GValue element = G_VALUE_INIT;
-
- array = g_value_array_new (4);
-
- g_value_init (&element, DBUS_TYPE_G_UCHAR_ARRAY);
- addr = nm_ip6_route_get_dest (route);
- ba = g_byte_array_new ();
- g_byte_array_append (ba, (guchar *)addr, sizeof (*addr));
- g_value_take_boxed (&element, ba);
- g_value_array_append (array, &element);
- g_value_unset (&element);
-
- g_value_init (&element, G_TYPE_UINT);
- g_value_set_uint (&element, nm_ip6_route_get_prefix (route));
- g_value_array_append (array, &element);
- g_value_unset (&element);
-
- g_value_init (&element, DBUS_TYPE_G_UCHAR_ARRAY);
- addr = nm_ip6_route_get_next_hop (route);
- ba = g_byte_array_new ();
- g_byte_array_append (ba, (guchar *)addr, sizeof (*addr));
- g_value_take_boxed (&element, ba);
- g_value_array_append (array, &element);
- g_value_unset (&element);
-
- g_value_init (&element, G_TYPE_UINT);
- g_value_set_uint (&element, nm_ip6_route_get_metric (route));
- g_value_array_append (array, &element);
- g_value_unset (&element);
-
- g_ptr_array_add (routes, array);
- }
-
- g_value_take_boxed (value, routes);
-}
-
-/**
- * nm_utils_ip6_dns_from_gvalue: (skip)
- * @value: a #GValue
- *
- * Converts a #GValue containing a #GPtrArray of IP6 DNS, represented as
- * #GByteArrays into a #GSList of IP address strings.
- *
- * Returns: a #GSList of IP6 addresses.
- */
-GSList *
-nm_utils_ip6_dns_from_gvalue (const GValue *value)
-{
- GPtrArray *dns;
- int i;
- GSList *list = NULL;
-
- dns = (GPtrArray *) g_value_get_boxed (value);
- for (i = 0; dns && (i < dns->len); i++) {
- GByteArray *bytearray = (GByteArray *) g_ptr_array_index (dns, i);
- const char *str;
-
- if (bytearray->len != 16) {
- g_warning ("%s: ignoring invalid IP6 address of length %d",
- __func__, bytearray->len);
- continue;
- }
-
- str = nm_utils_inet6_ntop ((struct in6_addr *) bytearray->data, NULL);
- list = g_slist_prepend (list, g_strdup (str));
- }
-
- return g_slist_reverse (list);
-}
-
-/**
- * nm_utils_ip6_dns_to_gvalue: (skip)
- * @list: a list of #NMIP6Route objects
- * @value: a pointer to a #GValue into which to place the converted DNS server
- * addresses, which should be unset by the caller (when no longer needed) with
- * g_value_unset().
- *
- * Utility function to convert a #GSList of <literal><type>struct
- * in6_addr</type></literal> structs into a #GPtrArray of #GByteArrays
- * representing each server's IPv6 addresses in network byte order.
- * The specific format of this serialization is not guaranteed to be
- * stable and may be extended in the future.
- */
-void
-nm_utils_ip6_dns_to_gvalue (GSList *list, GValue *value)
-{
- GPtrArray *dns;
- GSList *iter;
-
- dns = g_ptr_array_new ();
-
- for (iter = list; iter; iter = iter->next) {
- const char *str = iter->data;
- GByteArray *bytearray;
-
- bytearray = g_byte_array_new ();
- g_byte_array_set_size (bytearray, 16);
- inet_pton (AF_INET6, str, bytearray->data);
- g_ptr_array_add (dns, bytearray);
- }
-
- g_value_take_boxed (value, dns);
-}
-
/**
* nm_utils_ip6_dns_to_variant:
* @dns: (type utf8): an array of IP address strings
gboolean ignore_trailing_null);
char * nm_utils_ssid_to_utf8 (const guint8 *ssid, gsize len);
-GHashTable *nm_utils_gvalue_hash_dup (GHashTable *hash);
-
/**
* NMUtilsSecurityType:
* @NMU_SEC_INVALID: unknown or invalid security, placeholder and not used
gboolean nm_utils_wep_key_valid (const char *key, NMWepKeyType wep_type);
gboolean nm_utils_wpa_psk_valid (const char *psk);
-GSList *nm_utils_ip4_addresses_from_gvalue (const GValue *value);
-void nm_utils_ip4_addresses_to_gvalue (GSList *list, GValue *value);
-
-GSList *nm_utils_ip4_routes_from_gvalue (const GValue *value);
-void nm_utils_ip4_routes_to_gvalue (GSList *list, GValue *value);
-
GVariant *nm_utils_ip4_dns_to_variant (char **dns);
char **nm_utils_ip4_dns_from_variant (GVariant *value);
GVariant *nm_utils_ip4_addresses_to_variant (GPtrArray *addresses);
guint32 nm_utils_ip4_prefix_to_netmask (guint32 prefix);
guint32 nm_utils_ip4_get_default_prefix (guint32 ip);
-GSList *nm_utils_ip6_addresses_from_gvalue (const GValue *value);
-void nm_utils_ip6_addresses_to_gvalue (GSList *list, GValue *value);
-
-GSList *nm_utils_ip6_routes_from_gvalue (const GValue *value);
-void nm_utils_ip6_routes_to_gvalue (GSList *list, GValue *value);
-
-GSList *nm_utils_ip6_dns_from_gvalue (const GValue *value);
-void nm_utils_ip6_dns_to_gvalue (GSList *list, GValue *value);
-
GVariant *nm_utils_ip6_dns_to_variant (char **dns);
char **nm_utils_ip6_dns_from_variant (GVariant *value);
GVariant *nm_utils_ip6_addresses_to_variant (GPtrArray *addresses);
AM_CPPFLAGS = \
-I$(top_srcdir)/include \
+ -I$(top_builddir)/introspection \
-I$(top_srcdir)/libnm-core \
-I$(top_builddir)/libnm-core \
-I$(top_srcdir)/libnm \
-DNETWORKMANAGER_COMPILATION \
-DNM_VERSION_MAX_ALLOWED=NM_VERSION_NEXT_STABLE \
$(GLIB_CFLAGS) \
- $(DBUS_CFLAGS) \
$(GUDEV_CFLAGS) \
-DNMRUNDIR=\"$(nmrundir)\"
$(libnm_la_csources) \
$(libnm_la_private_headers)
-nm-secret-agent-glue.h: $(top_srcdir)/introspection/nm-secret-agent.xml
- $(AM_V_GEN) dbus-binding-tool --prefix=nm_secret_agent --mode=glib-server --output=$@ $<
-
-nm-vpn-plugin-glue.h: $(top_srcdir)/introspection/nm-vpn-plugin.xml
- $(AM_V_GEN) dbus-binding-tool --prefix=nm_vpn_plugin --mode=glib-server --output=$@ $<
-
GLIB_GENERATED = nm-enum-types.h nm-enum-types.c
nm_enum_types_sources = $(libnminclude_HEADERS)
GLIB_MKENUMS_H_FLAGS = --identifier-prefix NM --fhead '\#include <nm-core-enum-types.h>\n'
GLIB_MKENUMS_C_FLAGS = --identifier-prefix NM
-BUILT_SOURCES = \
- nm-vpn-plugin-glue.h \
- nm-secret-agent-glue.h
-
libnm_la_LIBADD = \
$(top_builddir)/libnm-core/libnm-core.la \
+ $(top_builddir)/introspection/libnmdbus.la \
$(GLIB_LIBS) \
- $(DBUS_LIBS) \
$(UUID_LIBS) \
$(GUDEV_LIBS)
###
-BUILT_SOURCES += $(GLIB_GENERATED)
+BUILT_SOURCES = $(GLIB_GENERATED)
pkgconfigdir = $(libdir)/pkgconfig
pkgconfig_DATA = libnm.pc
$(libnm_la_csources)
NM-1.0.gir: libnm.la
-NM_1_0_gir_INCLUDES = Gio-2.0 DBusGLib-1.0
-NM_1_0_gir_PACKAGES = gio-2.0 dbus-glib-1 gudev-1.0
+NM_1_0_gir_INCLUDES = Gio-2.0
+NM_1_0_gir_PACKAGES = gio-2.0 gudev-1.0
NM_1_0_gir_EXPORT_PACKAGES = libnm
NM_1_0_gir_CFLAGS = $(AM_CPPFLAGS)
NM_1_0_gir_LIBS = libnm.la
nm_utils_deinit;
nm_utils_escape_ssid;
nm_utils_file_is_pkcs12;
- nm_utils_gvalue_hash_dup;
nm_utils_hex2byte;
nm_utils_hexstr2bin;
nm_utils_hwaddr_atoba;
nm_utils_inet4_ntop;
nm_utils_inet6_ntop;
nm_utils_init;
- nm_utils_ip4_addresses_from_gvalue;
nm_utils_ip4_addresses_from_variant;
- nm_utils_ip4_addresses_to_gvalue;
nm_utils_ip4_addresses_to_variant;
nm_utils_ip4_dns_from_variant;
nm_utils_ip4_dns_to_variant;
nm_utils_ip4_get_default_prefix;
nm_utils_ip4_netmask_to_prefix;
nm_utils_ip4_prefix_to_netmask;
- nm_utils_ip4_routes_from_gvalue;
nm_utils_ip4_routes_from_variant;
- nm_utils_ip4_routes_to_gvalue;
nm_utils_ip4_routes_to_variant;
- nm_utils_ip6_addresses_from_gvalue;
nm_utils_ip6_addresses_from_variant;
- nm_utils_ip6_addresses_to_gvalue;
nm_utils_ip6_addresses_to_variant;
- nm_utils_ip6_dns_from_gvalue;
nm_utils_ip6_dns_from_variant;
- nm_utils_ip6_dns_to_gvalue;
nm_utils_ip6_dns_to_variant;
- nm_utils_ip6_routes_from_gvalue;
nm_utils_ip6_routes_from_variant;
- nm_utils_ip6_routes_to_gvalue;
nm_utils_ip6_routes_to_variant;
nm_utils_is_empty_ssid;
nm_utils_is_uuid;
#include "nm-glib-compat.h"
#include "nm-dbus-helpers.h"
-static GType _nm_active_connection_decide_type (GValue *value);
+static GType _nm_active_connection_decide_type (GVariant *value);
G_DEFINE_TYPE_WITH_CODE (NMActiveConnection, nm_active_connection, NM_TYPE_OBJECT,
_nm_object_register_type_func (g_define_type_id,
};
static GType
-_nm_active_connection_decide_type (GValue *value)
+_nm_active_connection_decide_type (GVariant *value)
{
/* @value is the value of the o.fd.NM.ActiveConnection property "VPN" */
- if (g_value_get_boolean (value))
+ if (g_variant_get_boolean (value))
return NM_TYPE_VPN_CONNECTION;
else
return NM_TYPE_ACTIVE_CONNECTION;
* Copyright 2007 - 2013 Red Hat, Inc.
*/
-#include <dbus/dbus-glib.h>
#include <string.h>
#include <nm-utils.h>
#include "nm-active-connection.h"
#include "nm-vpn-connection.h"
#include "nm-object-cache.h"
-#include "nm-dbus-glib-types.h"
#include "nm-glib-compat.h"
-#include "nm-utils-private.h"
+#include "nm-dbus-helpers.h"
+
+#include "nmdbus-manager.h"
void _nm_device_wifi_set_wireless_enabled (NMDeviceWifi *device, gboolean enabled);
#define NM_CLIENT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_CLIENT, NMClientPrivate))
typedef struct {
- DBusGProxy *client_proxy;
+ NMDBusManager *manager_proxy;
char *version;
NMState state;
gboolean startup;
NMActiveConnection *primary_connection;
NMActiveConnection *activating_connection;
- DBusGProxyCall *perm_call;
+ GCancellable *perm_call_cancellable;
GHashTable *permissions;
/* Activations waiting for their NMActiveConnection
poke_wireless_devices_with_rf_status (NM_CLIENT (object));
}
-static void client_recheck_permissions (DBusGProxy *proxy, gpointer user_data);
+static void client_recheck_permissions (NMDBusManager *proxy, gpointer user_data);
static void active_connections_changed_cb (GObject *object, GParamSpec *pspec, gpointer user_data);
static void object_creation_failed_cb (GObject *object, GError *error, char *failed_path);
NM_OBJECT_CLASS (nm_client_parent_class)->init_dbus (object);
- priv->client_proxy = _nm_object_get_proxy (object, NM_DBUS_INTERFACE);
+ priv->manager_proxy = NMDBUS_MANAGER (_nm_object_get_proxy (object, NM_DBUS_INTERFACE));
_nm_object_register_properties (object,
NM_DBUS_INTERFACE,
property_info);
/* Permissions */
- dbus_g_proxy_add_signal (priv->client_proxy, "CheckPermissions", G_TYPE_INVALID);
- dbus_g_proxy_connect_signal (priv->client_proxy,
- "CheckPermissions",
- G_CALLBACK (client_recheck_permissions),
- object,
- NULL);
+ g_signal_connect (priv->manager_proxy, "check-permissions",
+ G_CALLBACK (client_recheck_permissions), object);
}
#define NM_AUTH_PERMISSION_ENABLE_DISABLE_NETWORK "org.freedesktop.NetworkManager.enable-disable-network"
}
static void
-update_permissions (NMClient *self, GHashTable *permissions)
+update_permissions (NMClient *self, GVariant *permissions)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (self);
GHashTableIter iter;
g_hash_table_remove_all (priv->permissions);
if (permissions) {
+ GVariantIter viter;
+ const char *pkey, *pvalue;
+
/* Process new permissions */
- g_hash_table_iter_init (&iter, permissions);
- while (g_hash_table_iter_next (&iter, &key, &value)) {
- perm = nm_permission_to_client ((const char *) key);
- perm_result = nm_permission_result_to_client ((const char *) value);
+ g_variant_iter_init (&viter, permissions);
+ while (g_variant_iter_next (&viter, "{&s&s}", &pkey, &pvalue)) {
+ perm = nm_permission_to_client (pkey);
+ perm_result = nm_permission_result_to_client (pvalue);
if (perm) {
g_hash_table_insert (priv->permissions,
GUINT_TO_POINTER (perm),
static gboolean
get_permissions_sync (NMClient *self, GError **error)
{
- gboolean success;
- GHashTable *permissions = NULL;
-
- success = dbus_g_proxy_call_with_timeout (NM_CLIENT_GET_PRIVATE (self)->client_proxy,
- "GetPermissions", 3000, error,
- G_TYPE_INVALID,
- DBUS_TYPE_G_MAP_OF_STRING, &permissions, G_TYPE_INVALID);
- update_permissions (self, success ? permissions : NULL);
- if (permissions)
- g_hash_table_destroy (permissions);
+ NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (self);
+ GVariant *permissions;
- return success;
+ if (nmdbus_manager_call_get_permissions_sync (priv->manager_proxy,
+ &permissions,
+ NULL, error)) {
+ update_permissions (self, permissions);
+ g_variant_unref (permissions);
+ return TRUE;
+ } else {
+ update_permissions (self, NULL);
+ return FALSE;
+ }
}
static void
-get_permissions_reply (DBusGProxy *proxy,
- DBusGProxyCall *call,
+get_permissions_reply (GObject *object,
+ GAsyncResult *result,
gpointer user_data)
{
- NMClient *self = NM_CLIENT (user_data);
- GHashTable *permissions;
+ NMClient *self;
+ NMClientPrivate *priv;
+ GVariant *permissions = NULL;
GError *error = NULL;
- dbus_g_proxy_end_call (proxy, call, &error,
- DBUS_TYPE_G_MAP_OF_STRING, &permissions,
- G_TYPE_INVALID);
- NM_CLIENT_GET_PRIVATE (self)->perm_call = NULL;
- update_permissions (NM_CLIENT (user_data), error ? NULL : permissions);
+ /* WARNING: this may be called after the client is disposed, so we can't
+ * look at self/priv until after we've determined that that isn't the case.
+ */
+
+ nmdbus_manager_call_get_permissions_finish (NMDBUS_MANAGER (object),
+ &permissions,
+ result, &error);
+ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+ /* @self has been disposed. */
+ g_error_free (error);
+ return;
+ }
+
+ self = user_data;
+ priv = NM_CLIENT_GET_PRIVATE (self);
+
+ update_permissions (self, permissions);
+
+ g_clear_pointer (&permissions, g_variant_unref);
g_clear_error (&error);
+ g_clear_object (&priv->perm_call_cancellable);
}
static void
-client_recheck_permissions (DBusGProxy *proxy, gpointer user_data)
+client_recheck_permissions (NMDBusManager *proxy, gpointer user_data)
{
NMClient *self = NM_CLIENT (user_data);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (self);
- if (!priv->perm_call) {
- priv->perm_call = dbus_g_proxy_begin_call (NM_CLIENT_GET_PRIVATE (self)->client_proxy, "GetPermissions",
- get_permissions_reply, self, NULL,
- G_TYPE_INVALID);
- }
+ if (priv->perm_call_cancellable)
+ return;
+
+ priv->perm_call_cancellable = g_cancellable_new ();
+ nmdbus_manager_call_get_permissions (priv->manager_proxy,
+ priv->perm_call_cancellable,
+ get_permissions_reply,
+ self);
}
/**
}
static void
-activate_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+activate_cb (GObject *object,
+ GAsyncResult *result,
gpointer user_data)
{
ActivateInfo *info = user_data;
- char *path;
GError *error = NULL;
- dbus_g_proxy_end_call (proxy, call, &error,
- DBUS_TYPE_G_OBJECT_PATH, &path,
- G_TYPE_INVALID);
- if (error) {
+ if (nmdbus_manager_call_activate_connection_finish (NMDBUS_MANAGER (object),
+ &info->active_path,
+ result, &error)) {
+ recheck_pending_activations (info->client, NULL, NULL);
+ } else {
activate_info_complete (info, NULL, error);
activate_info_free (info);
g_clear_error (&error);
- } else {
- info->active_path = path;
- recheck_pending_activations (info->client, NULL, NULL);
}
}
return;
}
- dbus_g_proxy_begin_call (priv->client_proxy, "ActivateConnection",
- activate_cb, info, NULL,
- DBUS_TYPE_G_OBJECT_PATH, connection ? nm_connection_get_path (connection) : "/",
- DBUS_TYPE_G_OBJECT_PATH, device ? nm_object_get_path (NM_OBJECT (device)) : "/",
- DBUS_TYPE_G_OBJECT_PATH, specific_object ? specific_object : "/",
- G_TYPE_INVALID);
+ nmdbus_manager_call_activate_connection (priv->manager_proxy,
+ connection ? nm_connection_get_path (connection) : "/",
+ device ? nm_object_get_path (NM_OBJECT (device)) : "/",
+ specific_object ? specific_object : "/",
+ NULL,
+ activate_cb, info);
}
static void
-add_activate_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+add_activate_cb (GObject *object,
+ GAsyncResult *result,
gpointer user_data)
{
ActivateInfo *info = user_data;
- char *connection_path;
- char *active_path;
GError *error = NULL;
- dbus_g_proxy_end_call (proxy, call, &error,
- DBUS_TYPE_G_OBJECT_PATH, &connection_path,
- DBUS_TYPE_G_OBJECT_PATH, &active_path,
- G_TYPE_INVALID);
- if (error) {
+ if (nmdbus_manager_call_add_and_activate_connection_finish (NMDBUS_MANAGER (object),
+ &info->new_connection_path,
+ &info->active_path,
+ result, &error)) {
+ recheck_pending_activations (info->client, NULL, NULL);
+ } else {
activate_info_complete (info, NULL, error);
activate_info_free (info);
- } else {
- info->new_connection_path = connection_path;
- info->active_path = active_path;
- recheck_pending_activations (info->client, NULL, NULL);
+ g_clear_error (&error);
}
}
{
NMClientPrivate *priv;
ActivateInfo *info;
- GHashTable *hash = NULL;
+ GVariant *dict = NULL;
g_return_if_fail (NM_IS_CLIENT (client));
g_return_if_fail (NM_IS_DEVICE (device));
info->user_data = user_data;
info->client = client;
- if (partial) {
- GVariant *dict;
-
+ if (partial)
dict = nm_connection_to_dbus (partial, NM_CONNECTION_SERIALIZE_ALL);
- hash = _nm_utils_connection_dict_to_hash (dict);
- g_variant_unref (dict);
- }
- if (!hash)
- hash = g_hash_table_new (g_str_hash, g_str_equal);
+ if (!dict)
+ dict = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
priv = NM_CLIENT_GET_PRIVATE (client);
priv->pending_activations = g_slist_prepend (priv->pending_activations, info);
if (nm_client_get_nm_running (client)) {
- dbus_g_proxy_begin_call (priv->client_proxy, "AddAndActivateConnection",
- add_activate_cb, info, NULL,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, hash,
- DBUS_TYPE_G_OBJECT_PATH, nm_object_get_path (NM_OBJECT (device)),
- DBUS_TYPE_G_OBJECT_PATH, specific_object ? specific_object : "/",
- G_TYPE_INVALID);
+ nmdbus_manager_call_add_and_activate_connection (priv->manager_proxy,
+ dict,
+ nm_object_get_path (NM_OBJECT (device)),
+ specific_object ? specific_object : "/",
+ NULL,
+ add_activate_cb, info);
} else
info->idle_id = g_idle_add (activate_nm_not_running, info);
-
- g_hash_table_unref (hash);
}
static void
return;
path = nm_object_get_path (NM_OBJECT (active));
- if (!dbus_g_proxy_call (priv->client_proxy, "DeactivateConnection", &error,
- DBUS_TYPE_G_OBJECT_PATH, path,
- G_TYPE_INVALID,
- G_TYPE_INVALID)) {
+ if (!nmdbus_manager_call_deactivate_connection_sync (priv->manager_proxy,
+ path,
+ NULL, &error)) {
g_warning ("Could not deactivate connection '%s': %s", path, error->message);
g_error_free (error);
}
void
nm_client_wireless_set_enabled (NMClient *client, gboolean enabled)
{
- GValue value = G_VALUE_INIT;
-
g_return_if_fail (NM_IS_CLIENT (client));
if (!nm_client_get_nm_running (client))
return;
- g_value_init (&value, G_TYPE_BOOLEAN);
- g_value_set_boolean (&value, enabled);
-
_nm_object_set_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WirelessEnabled",
- &value);
+ "b", enabled);
}
/**
void
nm_client_wwan_set_enabled (NMClient *client, gboolean enabled)
{
- GValue value = G_VALUE_INIT;
-
g_return_if_fail (NM_IS_CLIENT (client));
if (!nm_client_get_nm_running (client))
return;
- g_value_init (&value, G_TYPE_BOOLEAN);
- g_value_set_boolean (&value, enabled);
-
_nm_object_set_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WwanEnabled",
- &value);
+ "b", enabled);
}
/**
void
nm_client_wimax_set_enabled (NMClient *client, gboolean enabled)
{
- GValue value = G_VALUE_INIT;
-
g_return_if_fail (NM_IS_CLIENT (client));
if (!nm_client_get_nm_running (client))
return;
- g_value_init (&value, G_TYPE_BOOLEAN);
- g_value_set_boolean (&value, enabled);
-
_nm_object_set_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WimaxEnabled",
- &value);
+ "b", enabled);
}
/**
if (!nm_client_get_nm_running (client))
return;
- if (!dbus_g_proxy_call (NM_CLIENT_GET_PRIVATE (client)->client_proxy, "Enable", &err,
- G_TYPE_BOOLEAN, enable,
- G_TYPE_INVALID,
- G_TYPE_INVALID)) {
+ if (!nmdbus_manager_call_enable_sync (NM_CLIENT_GET_PRIVATE (client)->manager_proxy,
+ enable,
+ NULL, &err)) {
g_warning ("Error enabling/disabling networking: %s", err->message);
g_error_free (err);
}
if (!level && !domains)
return TRUE;
- return dbus_g_proxy_call (priv->client_proxy, "GetLogging", error,
- G_TYPE_INVALID,
- G_TYPE_STRING, level,
- G_TYPE_STRING, domains,
- G_TYPE_INVALID);
+ return nmdbus_manager_call_get_logging_sync (priv->manager_proxy,
+ level, domains,
+ NULL, error);
}
/**
if (!level && !domains)
return TRUE;
- return dbus_g_proxy_call (priv->client_proxy, "SetLogging", error,
- G_TYPE_STRING, level ? level : "",
- G_TYPE_STRING, domains ? domains : "",
- G_TYPE_INVALID,
- G_TYPE_INVALID);
+ return nmdbus_manager_call_set_logging_sync (priv->manager_proxy,
+ level, domains,
+ NULL, error);
}
/**
} else {
_nm_object_suppress_property_updates (NM_OBJECT (client), FALSE);
_nm_object_reload_properties_async (NM_OBJECT (client), updated_properties, client);
- client_recheck_permissions (priv->client_proxy, client);
+ client_recheck_permissions (priv->manager_proxy, client);
}
}
GError **error)
{
NMClientPrivate *priv;
- NMConnectivityState connectivity;
+ guint32 connectivity;
g_return_val_if_fail (NM_IS_CLIENT (client), NM_CONNECTIVITY_UNKNOWN);
priv = NM_CLIENT_GET_PRIVATE (client);
- if (!dbus_g_proxy_call (priv->client_proxy, "CheckConnectivity", error,
- G_TYPE_INVALID,
- G_TYPE_UINT, &connectivity,
- G_TYPE_INVALID))
- connectivity = NM_CONNECTIVITY_UNKNOWN;
-
- return connectivity;
-}
-
-typedef struct {
- NMClient *client;
- DBusGProxyCall *call;
- GCancellable *cancellable;
- guint cancelled_id;
- NMConnectivityState connectivity;
-} CheckConnectivityData;
-
-static void
-check_connectivity_data_free (CheckConnectivityData *ccd)
-{
- if (ccd->cancellable) {
- if (ccd->cancelled_id)
- g_signal_handler_disconnect (ccd->cancellable, ccd->cancelled_id);
- g_object_unref (ccd->cancellable);
- }
-
- g_slice_free (CheckConnectivityData, ccd);
+ if (nmdbus_manager_call_check_connectivity_sync (priv->manager_proxy,
+ &connectivity,
+ cancellable, error))
+ return connectivity;
+ else
+ return NM_CONNECTIVITY_UNKNOWN;
}
static void
-check_connectivity_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+check_connectivity_cb (GObject *object,
+ GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
- CheckConnectivityData *ccd = g_simple_async_result_get_op_res_gpointer (simple);
+ guint32 connectivity;
GError *error = NULL;
- if (ccd->cancellable) {
- g_signal_handler_disconnect (ccd->cancellable, ccd->cancelled_id);
- ccd->cancelled_id = 0;
- }
-
- if (!dbus_g_proxy_end_call (proxy, call, &error,
- G_TYPE_UINT, &ccd->connectivity,
- G_TYPE_INVALID))
+ if (nmdbus_manager_call_check_connectivity_finish (NMDBUS_MANAGER (object),
+ &connectivity,
+ result, &error))
+ g_simple_async_result_set_op_res_gssize (simple, connectivity);
+ else
g_simple_async_result_take_error (simple, error);
g_simple_async_result_complete (simple);
g_object_unref (simple);
}
-static void
-check_connectivity_cancelled_cb (GCancellable *cancellable,
- gpointer user_data)
-{
- GSimpleAsyncResult *simple = user_data;
- CheckConnectivityData *ccd = g_simple_async_result_get_op_res_gpointer (simple);
-
- g_signal_handler_disconnect (cancellable, ccd->cancelled_id);
- ccd->cancelled_id = 0;
-
- dbus_g_proxy_cancel_call (NM_CLIENT_GET_PRIVATE (ccd->client)->client_proxy, ccd->call);
- g_simple_async_result_complete_in_idle (simple);
-}
-
/**
* nm_client_check_connectivity_async:
* @client: an #NMClient
{
NMClientPrivate *priv;
GSimpleAsyncResult *simple;
- CheckConnectivityData *ccd;
g_return_if_fail (NM_IS_CLIENT (client));
priv = NM_CLIENT_GET_PRIVATE (client);
- ccd = g_slice_new (CheckConnectivityData);
- ccd->client = client;
-
simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
nm_client_check_connectivity_async);
- g_simple_async_result_set_op_res_gpointer (simple, ccd, (GDestroyNotify) check_connectivity_data_free);
-
- if (cancellable) {
- ccd->cancellable = g_object_ref (cancellable);
- ccd->cancelled_id = g_signal_connect (cancellable, "cancelled",
- G_CALLBACK (check_connectivity_cancelled_cb),
- simple);
- g_simple_async_result_set_check_cancellable (simple, cancellable);
- }
-
- ccd->call = dbus_g_proxy_begin_call (priv->client_proxy, "CheckConnectivity",
- check_connectivity_cb, simple, NULL,
- G_TYPE_INVALID);
+ nmdbus_manager_call_check_connectivity (priv->manager_proxy,
+ cancellable,
+ check_connectivity_cb, simple);
}
/**
GError **error)
{
GSimpleAsyncResult *simple;
- CheckConnectivityData *ccd;
g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (client), nm_client_check_connectivity_async), NM_CONNECTIVITY_UNKNOWN);
simple = G_SIMPLE_ASYNC_RESULT (result);
- ccd = g_simple_async_result_get_op_res_gpointer (simple);
if (g_simple_async_result_propagate_error (simple, error))
return NM_CONNECTIVITY_UNKNOWN;
-
- return ccd->connectivity;
+ return (NMConnectivityState) g_simple_async_result_get_op_res_gssize (simple);
}
/****************************************************************/
typedef struct {
NMClient *client;
+ GCancellable *cancellable;
GSimpleAsyncResult *result;
} NMClientInitData;
{
g_simple_async_result_complete (init_data->result);
g_object_unref (init_data->result);
+ g_clear_object (&init_data->cancellable);
g_slice_free (NMClientInitData, init_data);
}
static void
-init_async_got_permissions (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
+init_async_got_permissions (GObject *object, GAsyncResult *result, gpointer user_data)
{
NMClientInitData *init_data = user_data;
- GHashTable *permissions;
- GError *error = NULL;
+ GVariant *permissions;
- dbus_g_proxy_end_call (proxy, call, &error,
- DBUS_TYPE_G_MAP_OF_STRING, &permissions,
- G_TYPE_INVALID);
- update_permissions (init_data->client, error ? NULL : permissions);
- if (error)
- g_simple_async_result_take_error (init_data->result, error);
+ if (nmdbus_manager_call_get_permissions_finish (NMDBUS_MANAGER (object),
+ &permissions,
+ result, NULL)) {
+ update_permissions (init_data->client, permissions);
+ g_variant_unref (permissions);
+ } else
+ update_permissions (init_data->client, NULL);
init_async_complete (init_data);
}
return;
}
- dbus_g_proxy_begin_call (priv->client_proxy, "GetPermissions",
- init_async_got_permissions, init_data, NULL,
- G_TYPE_INVALID);
+ nmdbus_manager_call_get_permissions (priv->manager_proxy,
+ init_data->cancellable,
+ init_async_got_permissions, init_data);
}
static void
init_data = g_slice_new0 (NMClientInitData);
init_data->client = NM_CLIENT (initable);
+ init_data->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
init_data->result = g_simple_async_result_new (G_OBJECT (initable), callback,
user_data, init_async);
g_simple_async_result_set_op_res_gboolean (init_data->result, TRUE);
NMClient *client = NM_CLIENT (object);
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (object);
- if (priv->perm_call) {
- dbus_g_proxy_cancel_call (priv->client_proxy, priv->perm_call);
- priv->perm_call = NULL;
+ if (priv->perm_call_cancellable) {
+ g_cancellable_cancel (priv->perm_call_cancellable);
+ g_clear_object (&priv->perm_call_cancellable);
}
free_devices (client, TRUE);
g_type_class_add_private (client_class, sizeof (NMClientPrivate));
_nm_object_class_add_interface (nm_object_class, NM_DBUS_INTERFACE);
+ _nm_dbus_register_proxy_type (NM_DBUS_INTERFACE, NMDBUS_TYPE_MANAGER_PROXY);
/* virtual methods */
object_class->constructor = constructor;
#include <string.h>
#include <config.h>
#include <gio/gio.h>
-#include <dbus/dbus.h>
-#include <dbus/dbus-glib-lowlevel.h>
#include "nm-dbus-helpers.h"
#include "nm-dbus-interface.h"
-static dbus_int32_t priv_slot = -1;
-static DBusBusType nm_bus = DBUS_BUS_SYSTEM;
+#define NM_DBUS_PRIVATE_CONNECTION_TAG "libnm-private-connection"
+static GBusType nm_bus = G_BUS_TYPE_SYSTEM;
-static void
-_ensure_nm_dbus_helpers_inited (void)
+GBusType
+_nm_dbus_bus_type (void)
{
static gsize init_value = 0;
if (g_once_init_enter (&init_value)) {
- dbus_connection_allocate_data_slot (&priv_slot);
- g_assert (priv_slot != -1);
-
if (g_getenv ("LIBNM_USE_SESSION_BUS"))
- nm_bus = DBUS_BUS_SESSION;
+ nm_bus = G_BUS_TYPE_SESSION;
g_once_init_leave (&init_value, 1);
}
+
+ return nm_bus;
}
-DBusGConnection *
-_nm_dbus_new_connection (GCancellable *cancellable,
- GError **error)
+GDBusConnection *
+_nm_dbus_new_connection (GCancellable *cancellable, GError **error)
{
- DBusGConnection *connection = NULL;
+ GDBusConnection *connection = NULL;
- _ensure_nm_dbus_helpers_inited ();
-
-#if HAVE_DBUS_GLIB_100
/* If running as root try the private bus first */
- if (0 == geteuid () && nm_bus == DBUS_BUS_SYSTEM) {
- connection = dbus_g_connection_open ("unix:path=" NMRUNDIR "/private", error);
- if (connection) {
- DBusConnection *dbus_connection = dbus_g_connection_get_connection (connection);
+ if (0 == geteuid ()) {
+ GError *local = NULL;
+ connection = g_dbus_connection_new_for_address_sync ("unix:path=" NMRUNDIR "/private",
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
+ NULL, cancellable, &local);
+ if (connection) {
/* Mark this connection as private */
- dbus_connection_set_data (dbus_connection, priv_slot, GUINT_TO_POINTER (TRUE), NULL);
- dbus_connection_set_exit_on_disconnect (dbus_connection, FALSE);
+ g_object_set_data (G_OBJECT (connection),
+ NM_DBUS_PRIVATE_CONNECTION_TAG,
+ GUINT_TO_POINTER (TRUE));
return connection;
}
- /* Fall back to a bus if for some reason private socket isn't available */
- g_clear_error (error);
+
+ if (g_error_matches (local, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+ g_propagate_error (error, local);
+ return NULL;
+ }
+ g_error_free (local);
}
-#endif
- if (connection == NULL)
- connection = dbus_g_bus_get (nm_bus, error);
+ return g_bus_get_sync (_nm_dbus_bus_type (), cancellable, error);
+}
- return connection;
+static void
+new_connection_async_got_system (GObject *source, GAsyncResult *result, gpointer user_data)
+{
+ GSimpleAsyncResult *simple = user_data;
+ GDBusConnection *connection;
+ GError *error = NULL;
+
+ connection = g_bus_get_finish (result, &error);
+ if (connection)
+ g_simple_async_result_set_op_res_gpointer (simple, connection, g_object_unref);
+ else
+ g_simple_async_result_take_error (simple, error);
+
+ g_simple_async_result_complete (simple);
+ g_object_unref (simple);
+}
+
+static void
+new_connection_async_got_private (GObject *source, GAsyncResult *result, gpointer user_data)
+{
+ GSimpleAsyncResult *simple = user_data;
+ GDBusConnection *connection;
+ GError *error = NULL;
+
+ connection = g_dbus_connection_new_for_address_finish (result, &error);
+ if (connection) {
+ g_simple_async_result_set_op_res_gpointer (simple, connection, g_object_unref);
+ g_simple_async_result_complete (simple);
+ g_object_unref (simple);
+ return;
+ }
+
+ if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+ g_simple_async_result_take_error (simple, error);
+ g_simple_async_result_complete (simple);
+ g_object_unref (simple);
+ return;
+ }
+
+ g_clear_error (&error);
+ g_bus_get (_nm_dbus_bus_type (),
+ g_object_get_data (G_OBJECT (simple), "cancellable"),
+ new_connection_async_got_system, simple);
}
void
gpointer user_data)
{
GSimpleAsyncResult *simple;
- DBusGConnection *connection;
- GError *error = NULL;
- simple = g_simple_async_result_new (NULL, callback, user_data,
- _nm_dbus_new_connection_async);
- connection = _nm_dbus_new_connection (cancellable, &error);
- if (connection)
- g_simple_async_result_set_op_res_gpointer (simple, connection, (GDestroyNotify) dbus_g_connection_unref);
- else
- g_simple_async_result_take_error (simple, error);
+ simple = g_simple_async_result_new (NULL, callback, user_data, _nm_dbus_new_connection_async);
- g_simple_async_result_complete_in_idle (simple);
- g_object_unref (simple);
+ /* If running as root try the private bus first */
+ if (0 == geteuid ()) {
+ g_object_set_data_full (G_OBJECT (simple), "cancellable",
+ g_object_ref (cancellable), g_object_unref);
+ g_dbus_connection_new_for_address ("unix:path=" NMRUNDIR "/private",
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT,
+ NULL,
+ cancellable,
+ new_connection_async_got_private, simple);
+ } else {
+ g_bus_get (_nm_dbus_bus_type (),
+ cancellable,
+ new_connection_async_got_system, simple);
+ }
}
-DBusGConnection *
+GDBusConnection *
_nm_dbus_new_connection_finish (GAsyncResult *result,
GError **error)
{
if (g_simple_async_result_propagate_error (simple, error))
return NULL;
- return dbus_g_connection_ref (g_simple_async_result_get_op_res_gpointer (simple));
+ return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
}
gboolean
-_nm_dbus_is_connection_private (DBusGConnection *connection)
+_nm_dbus_is_connection_private (GDBusConnection *connection)
{
- if (priv_slot == -1)
- return FALSE;
- return !!dbus_connection_get_data (dbus_g_connection_get_connection (connection), priv_slot);
+ return !!g_object_get_data (G_OBJECT (connection), NM_DBUS_PRIVATE_CONNECTION_TAG);
}
-DBusGProxy *
-_nm_dbus_new_proxy_for_connection (DBusGConnection *connection,
+static GHashTable *proxy_types;
+
+#undef _nm_dbus_register_proxy_type
+void
+_nm_dbus_register_proxy_type (const char *interface,
+ GType proxy_type)
+{
+ if (!proxy_types)
+ proxy_types = g_hash_table_new (g_str_hash, g_str_equal);
+
+ g_assert (g_hash_table_lookup (proxy_types, interface) == NULL);
+ g_hash_table_insert (proxy_types, (char *) interface, GSIZE_TO_POINTER (proxy_type));
+}
+
+/* We don't (currently) use GDBus's property-handling code */
+#define NM_DBUS_PROXY_FLAGS (G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES | \
+ G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START)
+
+GDBusProxy *
+_nm_dbus_new_proxy_for_connection (GDBusConnection *connection,
const char *path,
const char *interface,
GCancellable *cancellable,
GError **error)
{
- /* Private connections can't use dbus_g_proxy_new_for_name() or
- * dbus_g_proxy_new_for_name_owner() because peer-to-peer connections don't
- * have either a bus daemon or name owners, both of which those functions
- * require.
- */
+ GType proxy_type;
+ const char *name;
+
+ proxy_type = GPOINTER_TO_SIZE (g_hash_table_lookup (proxy_types, interface));
+ if (!proxy_type)
+ proxy_type = G_TYPE_DBUS_PROXY;
+
if (_nm_dbus_is_connection_private (connection))
- return dbus_g_proxy_new_for_peer (connection, path, interface);
+ name = NULL;
+ else
+ name = NM_DBUS_SERVICE;
- return dbus_g_proxy_new_for_name (connection, NM_DBUS_SERVICE, path, interface);
+ return g_initable_new (proxy_type, cancellable, error,
+ "g-connection", connection,
+ "g-flags", NM_DBUS_PROXY_FLAGS,
+ "g-name", name,
+ "g-object-path", path,
+ "g-interface-name", interface,
+ NULL);
}
void
-_nm_dbus_new_proxy_for_connection_async (DBusGConnection *connection,
+_nm_dbus_new_proxy_for_connection_async (GDBusConnection *connection,
const char *path,
const char *interface,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
- GSimpleAsyncResult *simple;
- DBusGProxy *proxy;
- GError *error = NULL;
+ GType proxy_type;
+ const char *name;
+
+ proxy_type = GPOINTER_TO_SIZE (g_hash_table_lookup (proxy_types, interface));
+ if (!proxy_type)
+ proxy_type = G_TYPE_DBUS_PROXY;
- simple = g_simple_async_result_new (NULL, callback, user_data,
- _nm_dbus_new_proxy_for_connection_async);
- proxy = _nm_dbus_new_proxy_for_connection (connection, path, interface,
- cancellable, &error);
- if (proxy)
- g_simple_async_result_set_op_res_gpointer (simple, proxy, g_object_unref);
+ if (_nm_dbus_is_connection_private (connection))
+ name = NULL;
else
- g_simple_async_result_take_error (simple, error);
+ name = NM_DBUS_SERVICE;
- g_simple_async_result_complete_in_idle (simple);
- g_object_unref (simple);
+ g_async_initable_new_async (proxy_type, G_PRIORITY_DEFAULT,
+ cancellable, callback, user_data,
+ "g-connection", connection,
+ "g-flags", NM_DBUS_PROXY_FLAGS,
+ "g-name", name,
+ "g-object-path", path,
+ "g-interface-name", interface,
+ NULL);
}
-DBusGProxy *
+GDBusProxy *
_nm_dbus_new_proxy_for_connection_finish (GAsyncResult *result,
GError **error)
{
- GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (result);
+ GObject *source, *proxy;
- if (g_simple_async_result_propagate_error (simple, error))
- return NULL;
+ source = g_async_result_get_source_object (result);
+ proxy = g_async_initable_new_finish (G_ASYNC_INITABLE (source), result, error);
+ g_object_unref (source);
- return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
+ return G_DBUS_PROXY (proxy);
+}
+
+void
+_nm_dbus_register_error_domain (GQuark domain,
+ const char *interface,
+ GType enum_type)
+{
+ GEnumClass *enum_class;
+ GEnumValue *e;
+ char *error_name;
+ int i;
+
+ enum_class = g_type_class_ref (enum_type);
+ for (i = 0; i < enum_class->n_values; i++) {
+ e = &enum_class->values[i];
+ error_name = g_strdup_printf ("%s.%s", interface, e->value_nick);
+ g_dbus_error_register_error (domain, e->value, error_name);
+ g_free (error_name);
+ }
+
+ g_type_class_unref (enum_class);
+}
+
+/* Binds the properties on a generated server-side GDBus object to the
+ * corresponding properties on the public object.
+ */
+void
+_nm_dbus_bind_properties (gpointer object, gpointer skeleton)
+{
+ GParamSpec **properties;
+ guint n_properties;
+ int i;
+
+ properties = g_object_class_list_properties (G_OBJECT_GET_CLASS (skeleton), &n_properties);
+ for (i = 0; i < n_properties; i++) {
+ if (g_str_has_prefix (properties[i]->name, "g-"))
+ continue;
+
+ g_object_bind_property (object, properties[i]->name,
+ skeleton, properties[i]->name,
+ G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
+ }
+}
+
+static char *
+signal_name_from_method_name (const char *method_name)
+{
+ GString *signal_name;
+ const char *p;
+
+ signal_name = g_string_new ("handle");
+ for (p = method_name; *p; p++) {
+ if (g_ascii_isupper (*p))
+ g_string_append_c (signal_name, '-');
+ g_string_append_c (signal_name, g_ascii_tolower (*p));
+ }
+
+ return g_string_free (signal_name, FALSE);
+}
+
+static void
+_nm_dbus_method_meta_marshal (GClosure *closure, GValue *return_value,
+ guint n_param_values, const GValue *param_values,
+ gpointer invocation_hint, gpointer marshal_data)
+{
+ closure->marshal (closure, return_value, n_param_values,
+ param_values, invocation_hint,
+ ((GCClosure *)closure)->callback);
+
+ g_value_set_boolean (return_value, TRUE);
+}
+
+/* Takes (method_name, handler_func) pairs and connects the handlers to the
+ * signals on skeleton, with object as the user_data, but swapped so it comes
+ * first in the argument list, and handling the return value automatically.
+ */
+void
+_nm_dbus_bind_methods (gpointer object, gpointer skeleton, ...)
+{
+ va_list ap;
+ const char *method_name;
+ char *signal_name;
+ GCallback handler;
+ GClosure *closure;
+
+ va_start (ap, skeleton);
+ while ( (method_name = va_arg (ap, const char *))
+ && (handler = va_arg (ap, GCallback))) {
+ signal_name = signal_name_from_method_name (method_name);
+ closure = g_cclosure_new_swap (handler, object, NULL);
+ g_closure_set_meta_marshal (closure, NULL, _nm_dbus_method_meta_marshal);
+ g_signal_connect_closure (skeleton, signal_name, closure, FALSE);
+ g_free (signal_name);
+ }
+ va_end (ap);
}
#define __NM_DBUS_HELPERS_PRIVATE_H__
#include <gio/gio.h>
-#include <dbus/dbus.h>
-#include <dbus/dbus-glib-lowlevel.h>
-DBusGConnection *_nm_dbus_new_connection (GCancellable *cancellable,
+/* Copied from dbus/dbus-shared.h */
+#define DBUS_SERVICE_DBUS "org.freedesktop.DBus"
+#define DBUS_PATH_DBUS "/org/freedesktop/DBus"
+#define DBUS_PATH_LOCAL "/org/freedesktop/DBus/Local"
+
+#define DBUS_INTERFACE_DBUS "org.freedesktop.DBus"
+#define DBUS_INTERFACE_INTROSPECTABLE "org.freedesktop.DBus.Introspectable"
+#define DBUS_INTERFACE_PROPERTIES "org.freedesktop.DBus.Properties"
+#define DBUS_INTERFACE_PEER "org.freedesktop.DBus.Peer"
+
+
+GBusType _nm_dbus_bus_type (void);
+
+GDBusConnection *_nm_dbus_new_connection (GCancellable *cancellable,
GError **error);
void _nm_dbus_new_connection_async (GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
-DBusGConnection *_nm_dbus_new_connection_finish (GAsyncResult *result,
+GDBusConnection *_nm_dbus_new_connection_finish (GAsyncResult *result,
GError **error);
-gboolean _nm_dbus_is_connection_private (DBusGConnection *connection);
+gboolean _nm_dbus_is_connection_private (GDBusConnection *connection);
void _nm_dbus_register_proxy_type (const char *interface,
GType proxy_type);
+/* Guarantee that @interface is a static string */
+#define _nm_dbus_register_proxy_type(interface, proxy_type) \
+ _nm_dbus_register_proxy_type (interface "", proxy_type) \
-DBusGProxy *_nm_dbus_new_proxy_for_connection (DBusGConnection *connection,
+GDBusProxy *_nm_dbus_new_proxy_for_connection (GDBusConnection *connection,
const char *path,
const char *interface,
GCancellable *cancellable,
GError **error);
-void _nm_dbus_new_proxy_for_connection_async (DBusGConnection *connection,
+void _nm_dbus_new_proxy_for_connection_async (GDBusConnection *connection,
const char *path,
const char *interface,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data);
-DBusGProxy *_nm_dbus_new_proxy_for_connection_finish (GAsyncResult *result,
+GDBusProxy *_nm_dbus_new_proxy_for_connection_finish (GAsyncResult *result,
GError **error);
+void _nm_dbus_register_error_domain (GQuark domain,
+ const char *interface,
+ GType enum_type);
+
+void _nm_dbus_bind_properties (gpointer object,
+ gpointer skeleton);
+
+void _nm_dbus_bind_methods (gpointer object,
+ gpointer skeleton,
+ ...) G_GNUC_NULL_TERMINATED;
+
#endif /* __NM_DBUS_HELPERS_PRIVATE_H__ */
#include "nm-device-private.h"
#include "nm-object-private.h"
#include "nm-object-cache.h"
-#include "nm-dbus-glib-types.h"
#include "nm-core-internal.h"
+#include "nm-dbus-helpers.h"
+
+#include "nmdbus-device-wifi.h"
G_DEFINE_TYPE (NMDeviceWifi, nm_device_wifi, NM_TYPE_DEVICE)
typedef struct {
NMDeviceWifi *device;
+ GCancellable *cancellable;
NMDeviceWifiRequestScanFn callback;
gpointer user_data;
} RequestScanInfo;
typedef struct {
- DBusGProxy *proxy;
+ NMDBusDeviceWifi *proxy;
char *hw_address;
char *perm_hw_address;
NMDeviceWifiCapabilities wireless_caps;
GPtrArray *aps;
- DBusGProxyCall *scan_call;
RequestScanInfo *scan_info;
} NMDeviceWifiPrivate;
}
static void
-request_scan_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+request_scan_cb (GObject *source,
+ GAsyncResult *result,
gpointer user_data)
{
RequestScanInfo *info = user_data;
- NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (info->device);
- GError *error = NULL;
- dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
+ if (info->callback) {
+ NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (info->device);
+ GError *error = NULL;
+
+ nmdbus_device_wifi_call_request_scan_finish (NMDBUS_DEVICE_WIFI (source),
+ result, &error);
- if (info->callback)
info->callback (info->device, error, info->user_data);
- g_clear_error (&error);
- g_slice_free (RequestScanInfo, info);
+ g_clear_error (&error);
+ priv->scan_info = NULL;
+ }
- priv->scan_call = NULL;
- priv->scan_info = NULL;
+ g_clear_object (&info->cancellable);
+ g_slice_free (RequestScanInfo, info);
}
/**
gpointer user_data)
{
RequestScanInfo *info;
- GHashTable *options;
NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
g_return_if_fail (NM_IS_DEVICE_WIFI (device));
/* If a scan is in progress, just return */
- if (priv->scan_call)
+ if (priv->scan_info)
return;
- options = g_hash_table_new (g_str_hash, g_str_equal);
-
info = g_slice_new0 (RequestScanInfo);
info->device = device;
+ info->cancellable = g_cancellable_new ();
info->callback = callback;
info->user_data = user_data;
priv->scan_info = info;
- priv->scan_call = dbus_g_proxy_begin_call (NM_DEVICE_WIFI_GET_PRIVATE (device)->proxy, "RequestScan",
- request_scan_cb, info, NULL,
- DBUS_TYPE_G_MAP_OF_VARIANT, options,
- G_TYPE_INVALID);
-
- g_hash_table_unref (options);
+ nmdbus_device_wifi_call_request_scan (NM_DEVICE_WIFI_GET_PRIVATE (device)->proxy,
+ g_variant_new_array (G_VARIANT_TYPE_VARDICT, NULL, 0),
+ info->cancellable,
+ request_scan_cb, info);
}
static void
NM_OBJECT_CLASS (nm_device_wifi_parent_class)->init_dbus (object);
- priv->proxy = _nm_object_get_proxy (object, NM_DBUS_INTERFACE_DEVICE_WIRELESS);
+ priv->proxy = NMDBUS_DEVICE_WIFI (_nm_object_get_proxy (object, NM_DBUS_INTERFACE_DEVICE_WIRELESS));
_nm_object_register_properties (object,
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
property_info);
NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (object);
GError *error = NULL;
- if (priv->scan_call) {
- g_set_error_literal (&error, NM_DEVICE_WIFI_ERROR, NM_DEVICE_WIFI_ERROR_UNKNOWN,
- "Wi-Fi device was destroyed");
- if (priv->scan_info) {
- if (priv->scan_info->callback)
- priv->scan_info->callback (NULL, error, priv->scan_info->user_data);
- g_slice_free (RequestScanInfo, priv->scan_info);
- priv->scan_info = NULL;
+ if (priv->scan_info) {
+ RequestScanInfo *scan_info;
+
+ scan_info = priv->scan_info;
+ priv->scan_info = NULL;
+
+ if (scan_info->callback) {
+ g_set_error_literal (&error, NM_DEVICE_WIFI_ERROR, NM_DEVICE_WIFI_ERROR_UNKNOWN,
+ "Wi-Fi device was destroyed");
+ scan_info->callback (NULL, error, scan_info->user_data);
+ scan_info->callback = NULL;
+ g_clear_error (&error);
}
- g_clear_error (&error);
- dbus_g_proxy_cancel_call (priv->proxy, priv->scan_call);
- priv->scan_call = NULL;
+ g_cancellable_cancel (scan_info->cancellable);
+ /* request_scan_cb() will free scan_info */
}
if (priv->aps)
g_type_class_add_private (wifi_class, sizeof (NMDeviceWifiPrivate));
_nm_object_class_add_interface (nm_object_class, NM_DBUS_INTERFACE_DEVICE_WIRELESS);
+ _nm_dbus_register_proxy_type (NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+ NMDBUS_TYPE_DEVICE_WIFI_PROXY);
/* virtual methods */
object_class->get_property = get_property;
#include "nm-device-wimax.h"
#include "nm-object-private.h"
#include "nm-object-cache.h"
-#include "nm-dbus-glib-types.h"
#include "nm-core-internal.h"
#include "nm-device-private.h"
#include "nm-object-cache.h"
#include "nm-remote-connection.h"
#include "nm-core-internal.h"
-#include "nm-dbus-glib-types.h"
#include "nm-glib-compat.h"
#include "nm-utils.h"
#include "nm-dbus-helpers.h"
-static GType _nm_device_decide_type (GValue *value);
+#include "nmdbus-device.h"
+
+static GType _nm_device_decide_type (GVariant *value);
gboolean connection_compatible (NMDevice *device, NMConnection *connection, GError **error);
G_DEFINE_TYPE_WITH_CODE (NMDevice, nm_device, NM_TYPE_OBJECT,
#define NM_DEVICE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_DEVICE, NMDevicePrivate))
typedef struct {
- DBusGProxy *proxy;
+ NMDBusDevice *proxy;
char *iface;
char *ip_iface;
priv->reason = NM_DEVICE_STATE_REASON_NONE;
}
-#define DBUS_G_TYPE_UINT_STRUCT (dbus_g_type_get_struct ("GValueArray", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID))
-
static gboolean
-demarshal_state_reason (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_state_reason (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
guint32 *reason_field = field;
- if (!G_VALUE_HOLDS (value, DBUS_G_TYPE_UINT_STRUCT))
- return FALSE;
-
- dbus_g_type_struct_get (value,
- 1, reason_field,
- G_MAXUINT);
-
+ g_variant_get (value, "(uu)", NULL, reason_field);
_nm_object_queue_notify (object, NM_DEVICE_STATE_REASON);
return TRUE;
}
static void
-device_state_changed (DBusGProxy *proxy,
- NMDeviceState new_state,
- NMDeviceState old_state,
- NMDeviceStateReason reason,
+device_state_changed (NMDBusDevice *proxy,
+ guint new_state,
+ guint old_state,
+ guint reason,
gpointer user_data);
static void
NM_OBJECT_CLASS (nm_device_parent_class)->init_dbus (object);
- priv->proxy = _nm_object_get_proxy (object, NM_DBUS_INTERFACE_DEVICE);
+ priv->proxy = NMDBUS_DEVICE (_nm_object_get_proxy (object, NM_DBUS_INTERFACE_DEVICE));
_nm_object_register_properties (object,
NM_DBUS_INTERFACE_DEVICE,
property_info);
- dbus_g_object_register_marshaller (g_cclosure_marshal_generic,
- G_TYPE_NONE,
- G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT,
- G_TYPE_INVALID);
-
- dbus_g_proxy_add_signal (priv->proxy,
- "StateChanged",
- G_TYPE_UINT, G_TYPE_UINT, G_TYPE_UINT,
- G_TYPE_INVALID);
-
- dbus_g_proxy_connect_signal (priv->proxy, "StateChanged",
- G_CALLBACK (device_state_changed),
- NM_DEVICE (object),
- NULL);
-
+ g_signal_connect (priv->proxy, "state-changed",
+ G_CALLBACK (device_state_changed), object);
}
typedef struct {
}
static void
-device_state_changed (DBusGProxy *proxy,
- NMDeviceState new_state,
- NMDeviceState old_state,
- NMDeviceStateReason reason,
+device_state_changed (NMDBusDevice *proxy,
+ guint new_state,
+ guint old_state,
+ guint reason,
gpointer user_data)
{
NMDevice *self = NM_DEVICE (user_data);
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
+ StateChangeData *data;
- if (old_state != new_state) {
- StateChangeData *data;
+ if (old_state == new_state)
+ return;
- /* Our object-valued properties (eg, ip4_config) will still
- * have their old values at this point, because NMObject is
- * in the process of asynchronously reading the new values.
- * Wait for that to finish before emitting the signal.
- */
- priv->last_seen_state = new_state;
-
- data = g_slice_new (StateChangeData);
- data->old_state = old_state;
- data->new_state = new_state;
- data->reason = reason;
- _nm_object_reload_properties_async (NM_OBJECT (user_data),
- device_state_change_reloaded,
- data);
- }
+ /* Our object-valued properties (eg, ip4_config) will still
+ * have their old values at this point, because NMObject is
+ * in the process of asynchronously reading the new values.
+ * Wait for that to finish before emitting the signal.
+ */
+ priv->last_seen_state = new_state;
+
+ data = g_slice_new (StateChangeData);
+ data->old_state = old_state;
+ data->new_state = new_state;
+ data->reason = reason;
+ _nm_object_reload_properties_async (NM_OBJECT (user_data),
+ device_state_change_reloaded,
+ data);
}
static GType
g_type_class_add_private (device_class, sizeof (NMDevicePrivate));
_nm_object_class_add_interface (nm_object_class, NM_DBUS_INTERFACE_DEVICE);
+ _nm_dbus_register_proxy_type (NM_DBUS_INTERFACE_DEVICE, NMDBUS_TYPE_DEVICE_PROXY);
/* virtual methods */
object_class->constructed = constructed;
}
static GType
-_nm_device_decide_type (GValue *value)
+_nm_device_decide_type (GVariant *value)
{
- return _nm_device_gtype_from_dtype (g_value_get_uint (value));
+ return _nm_device_gtype_from_dtype (g_variant_get_uint32 (value));
}
/**
void
nm_device_set_autoconnect (NMDevice *device, gboolean autoconnect)
{
- GValue value = G_VALUE_INIT;
-
g_return_if_fail (NM_IS_DEVICE (device));
- g_value_init (&value, G_TYPE_BOOLEAN);
- g_value_set_boolean (&value, autoconnect);
-
-
NM_DEVICE_GET_PRIVATE (device)->autoconnect = autoconnect;
_nm_object_set_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Autoconnect",
- &value);
+ "b", autoconnect);
}
/**
NMDevice *device;
NMDeviceCallbackFn fn;
gpointer user_data;
- const char *method;
} DeviceCallbackInfo;
static void
-device_operation_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
- gpointer user_data)
+device_disconnect_cb (GObject *proxy,
+ GAsyncResult *result,
+ gpointer user_data)
{
DeviceCallbackInfo *info = user_data;
GError *error = NULL;
- dbus_g_proxy_end_call (proxy, call, &error,
- G_TYPE_INVALID);
+ nmdbus_device_call_disconnect_finish (NMDBUS_DEVICE (proxy), result, &error);
if (info->fn)
info->fn (info->device, error, info->user_data);
else if (error) {
- g_warning ("%s: device %s %s failed: (%d) %s",
+ g_warning ("%s: device %s disconnect failed: %s",
__func__,
nm_object_get_path (NM_OBJECT (info->device)),
- info->method,
- error ? error->code : -1,
- error && error->message ? error->message : "(unknown)");
+ error->message);
}
g_clear_error (&error);
info = g_slice_new (DeviceCallbackInfo);
info->fn = callback;
info->user_data = user_data;
- info->method = "Disconnect";
info->device = g_object_ref (device);
- dbus_g_proxy_begin_call (NM_DEVICE_GET_PRIVATE (device)->proxy, "Disconnect",
- device_operation_cb, info, NULL,
- G_TYPE_INVALID);
+ nmdbus_device_call_disconnect (NM_DEVICE_GET_PRIVATE (device)->proxy,
+ NULL,
+ device_disconnect_cb, info);
+}
+
+static void
+device_delete_cb (GObject *proxy,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ DeviceCallbackInfo *info = user_data;
+ GError *error = NULL;
+
+ nmdbus_device_call_delete_finish (NMDBUS_DEVICE (proxy), result, &error);
+ if (info->fn)
+ info->fn (info->device, error, info->user_data);
+ else if (error) {
+ g_warning ("%s: device %s delete failed: %s",
+ __func__,
+ nm_object_get_path (NM_OBJECT (info->device)),
+ error->message);
+ }
+ g_clear_error (&error);
+
+ g_object_unref (info->device);
+ g_slice_free (DeviceCallbackInfo, info);
}
/**
info = g_slice_new (DeviceCallbackInfo);
info->fn = callback;
info->user_data = user_data;
- info->method = "Delete";
info->device = g_object_ref (device);
- dbus_g_proxy_begin_call (NM_DEVICE_GET_PRIVATE (device)->proxy, "Delete",
- device_operation_cb, info, NULL,
- G_TYPE_INVALID);
+ nmdbus_device_call_delete (NM_DEVICE_GET_PRIVATE (device)->proxy,
+ NULL,
+ device_delete_cb, info);
}
/**
}
static gboolean
-demarshal_dhcp4_options (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_dhcp4_options (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
NMDhcp4ConfigPrivate *priv = NM_DHCP4_CONFIG_GET_PRIVATE (object);
- GHashTable *new_options;
- GHashTableIter iter;
+ GVariantIter iter;
const char *key;
- GValue *opt;
+ GVariant *opt;
g_hash_table_remove_all (priv->options);
- new_options = g_value_get_boxed (value);
- if (new_options) {
- g_hash_table_iter_init (&iter, new_options);
- while (g_hash_table_iter_next (&iter, (gpointer) &key, (gpointer) &opt))
- g_hash_table_insert (priv->options, g_strdup (key), g_value_dup_string (opt));
+ g_variant_iter_init (&iter, value);
+ while (g_variant_iter_next (&iter, "{&sv}", &key, &opt)) {
+ g_hash_table_insert (priv->options, g_strdup (key), g_variant_dup_string (opt, NULL));
+ g_variant_unref (opt);
}
_nm_object_queue_notify (object, NM_DHCP4_CONFIG_OPTIONS);
}
static gboolean
-demarshal_dhcp6_options (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_dhcp6_options (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
NMDhcp6ConfigPrivate *priv = NM_DHCP6_CONFIG_GET_PRIVATE (object);
- GHashTable *new_options;
- GHashTableIter iter;
+ GVariantIter iter;
const char *key;
- GValue *opt;
+ GVariant *opt;
g_hash_table_remove_all (priv->options);
- new_options = g_value_get_boxed (value);
- if (new_options) {
- g_hash_table_iter_init (&iter, new_options);
- while (g_hash_table_iter_next (&iter, (gpointer) &key, (gpointer) &opt))
- g_hash_table_insert (priv->options, g_strdup (key), g_value_dup_string (opt));
+ g_variant_iter_init (&iter, value);
+ while (g_variant_iter_next (&iter, "{&sv}", &key, &opt)) {
+ g_hash_table_insert (priv->options, g_strdup (key), g_variant_dup_string (opt, NULL));
+ g_variant_unref (opt);
}
_nm_object_queue_notify (object, NM_DHCP6_CONFIG_OPTIONS);
typedef struct {
char *gateway;
- GSList *addresses;
- GSList *routes;
+ GPtrArray *addresses;
+ GPtrArray *routes;
char **nameservers;
char **domains;
char **searches;
{
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (config);
+ priv->addresses = g_ptr_array_new ();
+ priv->routes = g_ptr_array_new ();
priv->nameservers = g_new0 (char *, 1);
priv->domains = g_new0 (char *, 1);
priv->searches = g_new0 (char *, 1);
}
static gboolean
-demarshal_ip4_address_array (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_ip4_address_array (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (object);
- g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip4_address_unref);
- priv->addresses = NULL;
-
- priv->addresses = nm_utils_ip4_addresses_from_gvalue (value);
+ g_ptr_array_unref (priv->addresses);
+ priv->addresses = nm_utils_ip4_addresses_from_variant (value);
_nm_object_queue_notify (object, NM_IP4_CONFIG_ADDRESSES);
return TRUE;
}
static gboolean
-demarshal_ip4_array (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_ip4_array (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
- GArray *ip_array;
char ***obj_field;
- int i;
-
- if (!G_VALUE_HOLDS (value, DBUS_TYPE_G_UINT_ARRAY))
- return FALSE;
-
- ip_array = g_value_get_boxed (value);
obj_field = field;
if (*obj_field)
g_strfreev (*obj_field);
- *obj_field = g_new (char *, ip_array->len + 1);
- for (i = 0; i < ip_array->len; i++) {
- guint32 ip = g_array_index (ip_array, guint32, i);
- const char *str;
-
- str = nm_utils_inet4_ntop (ip, NULL);
- (*obj_field)[i] = g_strdup (str);
- }
- (*obj_field)[i] = NULL;
+ *obj_field = nm_utils_ip4_dns_from_variant (value);
_nm_object_queue_notify (object, pspec->name);
return TRUE;
}
static gboolean
-demarshal_ip4_routes_array (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_ip4_routes_array (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (object);
- g_slist_free_full (priv->routes, (GDestroyNotify) nm_ip4_route_unref);
- priv->routes = NULL;
-
- priv->routes = nm_utils_ip4_routes_from_gvalue (value);
+ g_ptr_array_unref (priv->routes);
+ priv->routes = nm_utils_ip4_routes_from_variant (value);
_nm_object_queue_notify (object, NM_IP4_CONFIG_ROUTES);
return TRUE;
g_free (priv->gateway);
- g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip4_address_unref);
- g_slist_free_full (priv->routes, (GDestroyNotify) nm_ip4_route_unref);
+ g_ptr_array_unref (priv->addresses);
+ g_ptr_array_unref (priv->routes);
g_strfreev (priv->nameservers);
g_strfreev (priv->domains);
GParamSpec *pspec)
{
NMIP4Config *self = NM_IP4_CONFIG (object);
- NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
switch (prop_id) {
case PROP_GATEWAY:
g_value_set_string (value, nm_ip4_config_get_gateway (self));
break;
case PROP_ADDRESSES:
- g_value_take_boxed (value, _nm_utils_copy_slist_to_array (priv->addresses,
- (NMUtilsCopyFunc) nm_ip4_address_dup,
- (GDestroyNotify) nm_ip4_address_unref));
+ g_value_take_boxed (value, _nm_utils_copy_array (nm_ip4_config_get_addresses (self),
+ (NMUtilsCopyFunc) nm_ip4_address_dup,
+ (GDestroyNotify) nm_ip4_address_unref));
break;
case PROP_ROUTES:
- g_value_take_boxed (value, _nm_utils_copy_slist_to_array (priv->routes,
- (NMUtilsCopyFunc) nm_ip4_route_dup,
- (GDestroyNotify) nm_ip4_route_unref));
+ g_value_take_boxed (value, _nm_utils_copy_array (nm_ip4_config_get_routes (self),
+ (NMUtilsCopyFunc) nm_ip4_route_dup,
+ (GDestroyNotify) nm_ip4_route_unref));
break;
case PROP_NAMESERVERS:
g_value_set_boxed (value, (char **) nm_ip4_config_get_nameservers (self));
*
* Gets the IP4 addresses (containing the address, prefix, and gateway).
*
- * Returns: (element-type NMIP4Address) (transfer none): the #GSList containing #NMIP4Address<!-- -->es.
- * This is the internal copy used by the configuration and must not be modified.
+ * Returns: (element-type NMIP4Address) (transfer none): the #GPtrArray
+ * containing #NMIP4Address<!-- -->es. This is the internal copy used by the
+ * configuration and must not be modified.
**/
-const GSList *
+GPtrArray *
nm_ip4_config_get_addresses (NMIP4Config *config)
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
*
* Gets the routes.
*
- * Returns: (element-type NMIP4Route) (transfer none): the #GSList containing
- * #NMIP4Routes. This is the internal copy used by the configuration,
- * and must not be modified.
+ * Returns: (element-type NMIP4Route) (transfer none): the #GPtrArray containing
+ * #NMIP4Routes. This is the internal copy used by the configuration, and must
+ * not be modified.
**/
-const GSList *
+GPtrArray *
nm_ip4_config_get_routes (NMIP4Config *config)
{
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
GType nm_ip4_config_get_type (void);
const char * nm_ip4_config_get_gateway (NMIP4Config *config);
-const GSList * nm_ip4_config_get_addresses (NMIP4Config *config);
-const GSList * nm_ip4_config_get_routes (NMIP4Config *config);
+GPtrArray * nm_ip4_config_get_addresses (NMIP4Config *config);
+GPtrArray * nm_ip4_config_get_routes (NMIP4Config *config);
const char * const *nm_ip4_config_get_nameservers (NMIP4Config *config);
const char * const *nm_ip4_config_get_domains (NMIP4Config *config);
const char * const *nm_ip4_config_get_searches (NMIP4Config *config);
#include "nm-dbus-interface.h"
#include "nm-object-private.h"
#include "nm-utils.h"
-#include "nm-dbus-glib-types.h"
#include "nm-core-internal.h"
G_DEFINE_TYPE (NMIP6Config, nm_ip6_config, NM_TYPE_OBJECT)
typedef struct {
char *gateway;
- GSList *addresses;
- GSList *routes;
+ GPtrArray *addresses;
+ GPtrArray *routes;
char **nameservers;
char **domains;
char **searches;
};
static gboolean
-demarshal_ip6_address_array (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_ip6_address_array (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (object);
- g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip6_address_unref);
- priv->addresses = NULL;
-
- priv->addresses = nm_utils_ip6_addresses_from_gvalue (value);
+ g_ptr_array_unref (priv->addresses);
+ priv->addresses = nm_utils_ip6_addresses_from_variant (value);
_nm_object_queue_notify (object, NM_IP6_CONFIG_ADDRESSES);
return TRUE;
}
static gboolean
-demarshal_ip6_nameserver_array (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_ip6_nameserver_array (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
- GPtrArray *ip_array;
char ***obj_field;
- int i;
-
- if (!G_VALUE_HOLDS (value, DBUS_TYPE_G_ARRAY_OF_ARRAY_OF_UCHAR))
- return FALSE;
-
- ip_array = g_value_get_boxed (value);
obj_field = field;
if (*obj_field)
g_strfreev (*obj_field);
- *obj_field = g_new (char *, ip_array ? ip_array->len + 1 : 1);
- for (i = 0; ip_array && i < ip_array->len; i++) {
- GByteArray *ip = g_ptr_array_index (ip_array, i);
- const char *str;
-
- str = nm_utils_inet6_ntop ((struct in6_addr *) ip->data, NULL);
- (*obj_field)[i] = g_strdup (str);
- }
- (*obj_field)[i] = NULL;
+ *obj_field = nm_utils_ip6_dns_from_variant (value);
_nm_object_queue_notify (object, pspec->name);
return TRUE;
}
static gboolean
-demarshal_ip6_routes_array (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
+demarshal_ip6_routes_array (NMObject *object, GParamSpec *pspec, GVariant *value, gpointer field)
{
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (object);
- g_slist_free_full (priv->routes, (GDestroyNotify) nm_ip6_route_unref);
- priv->routes = NULL;
-
- priv->routes = nm_utils_ip6_routes_from_gvalue (value);
+ g_ptr_array_unref (priv->routes);
+ priv->routes = nm_utils_ip6_routes_from_variant (value);
_nm_object_queue_notify (object, NM_IP6_CONFIG_ROUTES);
return TRUE;
*
* Gets the IP6 addresses (containing the address, prefix, and gateway).
*
- * Returns: (element-type NMIP6Address) (transfer none): the #GSList containing
- * #NMIP6Address<!-- -->es. This is the internal copy used by the configuration
- * and must not be modified.
+ * Returns: (element-type NMIP6Address) (transfer none): the #GPtrArray
+ * containing #NMIP6Address<!-- -->es. This is the internal copy used by the
+ * configuration and must not be modified.
**/
-const GSList *
+GPtrArray *
nm_ip6_config_get_addresses (NMIP6Config *config)
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
*
* Gets the routes.
*
- * Returns: (element-type NMIP6Route): (transfer none): the #GSList containing
- * #NMIP6Routes. This is the internal copy used by the configuration,
- * and must not be modified.
+ * Returns: (element-type NMIP6Route) (transfer none): the #GPtrArray containing
+ * #NMIP6Routes. This is the internal copy used by the configuration, and must
+ * not be modified.
**/
-const GSList *
+GPtrArray *
nm_ip6_config_get_routes (NMIP6Config *config)
{
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
g_free (priv->gateway);
- g_slist_free_full (priv->addresses, (GDestroyNotify) nm_ip6_address_unref);
- g_slist_free_full (priv->routes, (GDestroyNotify) nm_ip6_route_unref);
+ g_ptr_array_unref (priv->addresses);
+ g_ptr_array_unref (priv->routes);
g_strfreev (priv->nameservers);
g_strfreev (priv->domains);
GParamSpec *pspec)
{
NMIP6Config *self = NM_IP6_CONFIG (object);
- NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
switch (prop_id) {
case PROP_GATEWAY:
g_value_set_string (value, nm_ip6_config_get_gateway (self));
break;
case PROP_ADDRESSES:
- g_value_take_boxed (value, _nm_utils_copy_slist_to_array (priv->addresses,
- (NMUtilsCopyFunc) nm_ip6_address_dup,
- (GDestroyNotify) nm_ip6_address_unref));
+ g_value_take_boxed (value, _nm_utils_copy_array (nm_ip6_config_get_addresses (self),
+ (NMUtilsCopyFunc) nm_ip6_address_dup,
+ (GDestroyNotify) nm_ip6_address_unref));
break;
case PROP_ROUTES:
- g_value_take_boxed (value, _nm_utils_copy_slist_to_array (priv->routes,
- (NMUtilsCopyFunc) nm_ip6_route_dup,
- (GDestroyNotify) nm_ip6_route_unref));
+ g_value_take_boxed (value, _nm_utils_copy_array (nm_ip6_config_get_routes (self),
+ (NMUtilsCopyFunc) nm_ip6_route_dup,
+ (GDestroyNotify) nm_ip6_route_unref));
break;
case PROP_NAMESERVERS:
g_value_set_boxed (value, (char **) nm_ip6_config_get_nameservers (self));
{
NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (config);
+ priv->addresses = g_ptr_array_new ();
+ priv->routes = g_ptr_array_new ();
priv->nameservers = g_new0 (char *, 1);
priv->domains = g_new0 (char *, 1);
priv->searches = g_new0 (char *, 1);
GType nm_ip6_config_get_type (void);
const char * nm_ip6_config_get_gateway (NMIP6Config *config);
-const GSList * nm_ip6_config_get_addresses (NMIP6Config *config);
-const GSList * nm_ip6_config_get_routes (NMIP6Config *config);
+GPtrArray * nm_ip6_config_get_addresses (NMIP6Config *config);
+GPtrArray * nm_ip6_config_get_routes (NMIP6Config *config);
const char * const * nm_ip6_config_get_nameservers (NMIP6Config *config);
const char * const * nm_ip6_config_get_domains (NMIP6Config *config);
const char * const * nm_ip6_config_get_searches (NMIP6Config *config);
#include <gio/gio.h>
#include "nm-object.h"
-typedef gboolean (*PropertyMarshalFunc) (NMObject *, GParamSpec *, GValue *, gpointer);
+typedef gboolean (*PropertyMarshalFunc) (NMObject *, GParamSpec *, GVariant *, gpointer);
-typedef GObject * (*NMObjectCreatorFunc) (DBusGConnection *, const char *);
+typedef GObject * (*NMObjectCreatorFunc) (GDBusConnection *, const char *);
typedef struct {
const char *name;
void _nm_object_set_property (NMObject *object,
const char *interface,
const char *prop_name,
- GValue *value);
+ const char *format_string,
+ ...);
/* object demarshalling support */
-typedef GType (*NMObjectDecideTypeFunc) (GValue *);
+typedef GType (*NMObjectDecideTypeFunc) (GVariant *);
void _nm_object_register_type_func (GType base_type,
NMObjectDecideTypeFunc type_func,
void _nm_object_class_add_interface (NMObjectClass *object_class,
const char *interface);
-DBusGProxy *_nm_object_get_proxy (NMObject *object,
+GDBusProxy *_nm_object_get_proxy (NMObject *object,
const char *interface);
#endif /* __NM_OBJECT_PRIVATE_H__ */
#include "nm-object.h"
#include "nm-object-cache.h"
#include "nm-object-private.h"
-#include "nm-dbus-glib-types.h"
#include "nm-glib-compat.h"
#include "nm-dbus-helpers.h"
static void reload_complete (NMObject *object);
typedef struct {
- DBusGConnection *connection;
- DBusGProxy *bus_proxy;
+ GDBusConnection *connection;
+ gboolean private_connection;
gboolean nm_running;
char *path;
GHashTable *proxies;
- DBusGProxy *properties_proxy;
+ GDBusProxy *properties_proxy;
GSList *property_tables;
NMObject *parent;
gboolean suppress_property_updates;
}
static void
-proxy_name_owner_changed (DBusGProxy *proxy,
- const char *name,
- const char *old_owner,
- const char *new_owner,
- gpointer user_data)
+on_name_owner_changed (GObject *proxy,
+ GParamSpec *pspec,
+ gpointer user_data)
{
NMObject *self = NM_OBJECT (user_data);
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
gboolean now_running;
- if (g_strcmp0 (name, NM_DBUS_SERVICE) != 0)
- return;
-
- now_running = (new_owner && new_owner[0]);
+ now_running = (g_dbus_proxy_get_name_owner (priv->properties_proxy) != NULL);
if (now_running != priv->nm_running) {
priv->nm_running = now_running;
g_object_notify (G_OBJECT (self), NM_OBJECT_NM_RUNNING);
if (_nm_dbus_is_connection_private (priv->connection))
priv->nm_running = TRUE;
else {
- priv->bus_proxy = dbus_g_proxy_new_for_name (priv->connection,
- DBUS_SERVICE_DBUS,
- DBUS_PATH_DBUS,
- DBUS_INTERFACE_DBUS);
- g_assert (priv->bus_proxy);
-
- dbus_g_proxy_add_signal (priv->bus_proxy, "NameOwnerChanged",
- G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
- G_TYPE_INVALID);
- dbus_g_proxy_connect_signal (priv->bus_proxy,
- "NameOwnerChanged",
- G_CALLBACK (proxy_name_owner_changed),
- object, NULL);
+ priv->nm_running = (g_dbus_proxy_get_name_owner (priv->properties_proxy) != NULL);
+ g_signal_connect (priv->properties_proxy, "notify::g-name-owner",
+ G_CALLBACK (on_name_owner_changed), object);
}
}
/* Create proxies */
for (iter = cpriv->interfaces; iter; iter = iter->next) {
const char *interface = iter->data;
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
proxy = _nm_dbus_new_proxy_for_connection (priv->connection, priv->path, interface,
cancellable, error);
NM_OBJECT_GET_CLASS (self)->init_dbus (self);
- if (priv->bus_proxy) {
- if (!dbus_g_proxy_call (priv->bus_proxy,
- "NameHasOwner", error,
- G_TYPE_STRING, NM_DBUS_SERVICE,
- G_TYPE_INVALID,
- G_TYPE_BOOLEAN, &priv->nm_running,
- G_TYPE_INVALID))
- return FALSE;
- }
-
return _nm_object_reload_properties (self, error);
}
init_async_complete (init_data);
}
-static void
-init_async_get_properties (NMObjectInitData *init_data)
-{
- _nm_object_reload_properties_async (init_data->object, init_async_got_properties, init_data);
-}
-
-static void
-init_async_got_nm_running (DBusGProxy *proxy, DBusGProxyCall *call,
- gpointer user_data)
-{
- NMObjectInitData *init_data = user_data;
- NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (init_data->object);
-
- if (!dbus_g_proxy_end_call (proxy, call, &init_data->error,
- G_TYPE_BOOLEAN, &priv->nm_running,
- G_TYPE_INVALID)) {
- init_async_complete (init_data);
- } else if (!priv->nm_running)
- init_async_complete (init_data);
- else
- init_async_get_properties (init_data);
-}
-
static void
init_async_got_proxy (GObject *object, GAsyncResult *result, gpointer user_data)
{
NMObjectInitData *init_data = user_data;
NMObject *self = init_data->object;
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
if (!init_data->error) {
proxy = _nm_dbus_new_proxy_for_connection_finish (result, &init_data->error);
if (proxy) {
- const char *interface = dbus_g_proxy_get_interface (proxy);
+ const char *interface = g_dbus_proxy_get_interface_name (proxy);
if (!strcmp (interface, DBUS_INTERFACE_PROPERTIES))
priv->properties_proxy = proxy;
NM_OBJECT_GET_CLASS (self)->init_dbus (self);
- if (_nm_dbus_is_connection_private (priv->connection)) {
- priv->nm_running = TRUE;
- init_async_get_properties (init_data);
- } else {
- dbus_g_proxy_begin_call (priv->bus_proxy, "NameHasOwner",
- init_async_got_nm_running,
- init_data, NULL,
- G_TYPE_STRING, NM_DBUS_SERVICE,
- G_TYPE_INVALID);
- }
+ _nm_object_reload_properties_async (init_data->object, init_async_got_properties, init_data);
}
static void
init_async_got_proxy, init_data);
init_data->proxies_pending++;
}
-
+
static void
init_async (GAsyncInitable *initable, int io_priority,
GCancellable *cancellable, GAsyncReadyCallback callback,
g_clear_pointer (&priv->proxies, g_hash_table_unref);
g_clear_object (&priv->properties_proxy);
- g_clear_object (&priv->bus_proxy);
- if (priv->connection) {
- dbus_g_connection_unref (priv->connection);
- priv->connection = NULL;
- }
+ g_clear_object (&priv->connection);
G_OBJECT_CLASS (nm_object_parent_class)->dispose (object);
}
*
* Returns: (transfer none): a D-Bus proxy
*/
-DBusGProxy *
+GDBusProxy *
_nm_object_get_proxy (NMObject *object,
const char *interface)
{
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
g_return_val_if_fail (NM_IS_OBJECT (object), NULL);
}
static GObject *
-_nm_object_create (GType type, DBusGConnection *connection, const char *path)
+_nm_object_create (GType type, GDBusConnection *connection, const char *path)
{
NMObjectTypeFuncData *type_data;
GObject *object;
type_data = g_hash_table_lookup (type_funcs, GSIZE_TO_POINTER (type));
if (type_data) {
- DBusGProxy *proxy;
- GValue value = G_VALUE_INIT;
+ GDBusProxy *proxy;
+ GVariant *ret, *value;
proxy = _nm_dbus_new_proxy_for_connection (connection, path,
DBUS_INTERFACE_PROPERTIES,
return G_TYPE_INVALID;
}
- if (!dbus_g_proxy_call (proxy,
- "Get", &error,
- G_TYPE_STRING, type_data->interface,
- G_TYPE_STRING, type_data->property,
- G_TYPE_INVALID,
- G_TYPE_VALUE, &value,
- G_TYPE_INVALID)) {
+ ret = g_dbus_proxy_call_sync (proxy,
+ "Get",
+ g_variant_new ("(ss)",
+ type_data->interface,
+ type_data->property),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &error);
+ g_object_unref (proxy);
+ if (!ret) {
g_warning ("Could not fetch property '%s' of interface '%s' on %s: %s\n",
type_data->property, type_data->interface, path, error->message);
g_error_free (error);
- g_object_unref (proxy);
return G_TYPE_INVALID;
}
- g_object_unref (proxy);
- type = type_data->type_func (&value);
- g_value_unset (&value);
+ g_variant_get (ret, "(v)", &value);
+ type = type_data->type_func (value);
+ g_variant_unref (value);
+ g_variant_unref (ret);
}
if (type == G_TYPE_INVALID) {
}
static void
-create_async_got_property (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
+create_async_got_property (GObject *proxy, GAsyncResult *result, gpointer user_data)
{
NMObjectTypeAsyncData *async_data = user_data;
NMObjectTypeFuncData *type_data = async_data->type_data;
- GValue value = G_VALUE_INIT;
+ GVariant *ret, *value;
GError *error = NULL;
GType type;
- if (dbus_g_proxy_end_call (proxy, call, &error,
- G_TYPE_VALUE, &value,
- G_TYPE_INVALID)) {
- type = type_data->type_func (&value);
- g_value_unset (&value);
+ ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, &error);
+ if (ret) {
+ g_variant_get (ret, "(v)", &value);
+ type = type_data->type_func (value);
+ g_variant_unref (value);
+ g_variant_unref (ret);
} else {
- const char *path = dbus_g_proxy_get_path (proxy);
-
g_warning ("Could not fetch property '%s' of interface '%s' on %s: %s\n",
- type_data->property, type_data->interface, path, error->message);
+ type_data->property, type_data->interface, async_data->path,
+ error->message);
g_clear_error (&error);
type = G_TYPE_INVALID;
}
create_async_got_proxy (GObject *object, GAsyncResult *result, gpointer user_data)
{
NMObjectTypeAsyncData *async_data = user_data;
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
GError *error = NULL;
proxy = _nm_dbus_new_proxy_for_connection_finish (result, &error);
return;
}
- dbus_g_proxy_begin_call (proxy, "Get",
- create_async_got_property, async_data, NULL,
- G_TYPE_STRING, async_data->type_data->interface,
- G_TYPE_STRING, async_data->type_data->property,
- G_TYPE_INVALID);
+ g_dbus_proxy_call (proxy,
+ "Get",
+ g_variant_new ("(ss)",
+ async_data->type_data->interface,
+ async_data->type_data->property),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL,
+ create_async_got_property, async_data);
}
static void
-_nm_object_create_async (GType type, DBusGConnection *connection, const char *path,
+_nm_object_create_async (GType type, GDBusConnection *connection, const char *path,
NMObjectCreateCallbackFunc callback, gpointer user_data)
{
NMObjectTypeAsyncData *async_data;
}
static gboolean
-handle_object_property (NMObject *self, const char *property_name, GValue *value,
+handle_object_property (NMObject *self, const char *property_name, GVariant *value,
PropertyInfo *pi, gboolean synchronously)
{
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
if (priv->reload_results)
priv->reload_remaining++;
- path = g_value_get_boxed (value);
+ path = g_variant_get_string (value, NULL);
if (!strcmp (path, "/")) {
object_created (NULL, path, odata);
}
static gboolean
-handle_object_array_property (NMObject *self, const char *property_name, GValue *value,
+handle_object_array_property (NMObject *self, const char *property_name, GVariant *value,
PropertyInfo *pi, gboolean synchronously)
{
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
GObject *obj;
- GPtrArray *paths;
+ GVariantIter iter;
+ gsize npaths;
GPtrArray **array = pi->field;
const char *path;
ObjectCreatedData *odata;
- int i;
- paths = g_value_get_boxed (value);
+ npaths = g_variant_n_children (value);
odata = g_slice_new (ObjectCreatedData);
odata->self = g_object_ref (self);
odata->pi = pi;
- odata->objects = g_new0 (GObject *, paths->len);
- odata->length = odata->remaining = paths->len;
+ odata->objects = g_new0 (GObject *, npaths);
+ odata->length = odata->remaining = npaths;
odata->array = TRUE;
odata->property_name = property_name;
if (priv->reload_results)
priv->reload_remaining++;
- if (paths->len == 0) {
+ if (npaths == 0) {
object_property_complete (odata);
return TRUE;
}
- for (i = 0; i < paths->len; i++) {
- path = paths->pdata[i];
+ g_variant_iter_init (&iter, value);
+ while (g_variant_iter_next (&iter, "&o", &path)) {
if (!strcmp (path, "/")) {
/* FIXME: can't happen? */
continue;
return TRUE;
}
- return *array && ((*array)->len == paths->len);
+ return *array && ((*array)->len == npaths);
}
static void
-handle_property_changed (NMObject *self, const char *dbus_name, GValue *value, gboolean synchronously)
+handle_property_changed (NMObject *self, const char *dbus_name,
+ GVariant *value, gboolean synchronously)
{
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
char *prop_name;
if (G_UNLIKELY (debug)) {
char *s;
- s = g_strdup_value_contents (value);
+ s = g_variant_print (value, FALSE);
dbgmsg ("PC: (%p) %s::%s => '%s' (%s%s%s)",
self, G_OBJECT_TYPE_NAME (self),
prop_name,
}
if (pi->object_type) {
- if (G_VALUE_HOLDS (value, DBUS_TYPE_G_OBJECT_PATH))
+ if (g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH))
success = handle_object_property (self, pspec->name, value, pi, synchronously);
- else if (G_VALUE_HOLDS (value, DBUS_TYPE_G_ARRAY_OF_OBJECT_PATH))
+ else if (g_variant_is_of_type (value, G_VARIANT_TYPE ("ao")))
success = handle_object_array_property (self, pspec->name, value, pi, synchronously);
else {
g_warn_if_reached ();
}
static void
-process_properties_changed (NMObject *self, GHashTable *properties, gboolean synchronously)
+process_properties_changed (NMObject *self, GVariant *properties, gboolean synchronously)
{
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (self);
- GHashTableIter iter;
- gpointer name, value;
+ GVariantIter iter;
+ const char *name;
+ GVariant *value;
if (priv->suppress_property_updates)
return;
- g_hash_table_iter_init (&iter, properties);
- while (g_hash_table_iter_next (&iter, &name, &value)) {
- if (value)
- handle_property_changed (self, name, value, synchronously);
- else {
- dbgmsg ("%s:%d %s(): object %s property '%s' value is unexpectedly NULL",
- __FILE__, __LINE__, __func__, G_OBJECT_TYPE_NAME (self), (const char *) name);
- }
- }
+ g_variant_iter_init (&iter, properties);
+ while (g_variant_iter_next (&iter, "{sv}", &name, &value))
+ handle_property_changed (self, name, value, synchronously);
}
static void
-properties_changed_proxy (DBusGProxy *proxy,
- GHashTable *properties,
- gpointer user_data)
+property_proxy_signal (GDBusProxy *proxy,
+ const char *sender_name,
+ const char *signal_name,
+ GVariant *parameters,
+ 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(ucase, lcase, getter) \
- } else if (pspec->value_type == G_TYPE_##ucase) { \
- if (G_VALUE_HOLDS_##ucase (value)) { \
- g##lcase *param = (g##lcase *) field; \
- *param = g_value_get_##getter (value); \
+#define HANDLE_TYPE(gtype, vtype, ctype, getter) \
+ } else if (pspec->value_type == gtype) { \
+ if (g_variant_is_of_type (value, vtype)) { \
+ ctype *param = (ctype *) field; \
+ *param = getter (value); \
} else { \
success = FALSE; \
goto done; \
static gboolean
demarshal_generic (NMObject *object,
GParamSpec *pspec,
- GValue *value,
+ GVariant *value,
gpointer field)
{
gboolean success = TRUE;
if (pspec->value_type == G_TYPE_STRING) {
- if (G_VALUE_HOLDS_STRING (value)) {
+ if (g_variant_is_of_type (value, G_VARIANT_TYPE_STRING)) {
char **param = (char **) field;
g_free (*param);
- *param = g_value_dup_string (value);
- } else if (G_VALUE_HOLDS (value, DBUS_TYPE_G_OBJECT_PATH)) {
+ *param = g_variant_dup_string (value, NULL);
+ } else if (g_variant_is_of_type (value, G_VARIANT_TYPE_OBJECT_PATH)) {
char **param = (char **) field;
g_free (*param);
- *param = g_strdup (g_value_get_boxed (value));
+ *param = g_variant_dup_string (value, NULL);
/* Handle "NULL" object paths */
if (g_strcmp0 (*param, "/") == 0) {
g_free (*param);
char ***param = (char ***)field;
if (*param)
g_strfreev (*param);
- *param = g_value_dup_boxed (value);
+ *param = g_variant_dup_strv (value, NULL);
} else if (pspec->value_type == G_TYPE_BYTES) {
GBytes **param = (GBytes **)field;
- GByteArray *val;
+ gconstpointer val;
+ gsize length;
+
if (*param)
g_bytes_unref (*param);
- val = g_value_get_boxed (value);
- *param = g_bytes_new (val->data, val->len);
- HANDLE_TYPE(BOOLEAN, boolean, boolean)
- HANDLE_TYPE(CHAR, char, schar)
- HANDLE_TYPE(UCHAR, uchar, uchar)
- HANDLE_TYPE(DOUBLE, double, double)
- HANDLE_TYPE(INT, int, int)
- HANDLE_TYPE(UINT, uint, uint)
- HANDLE_TYPE(INT64, int, int)
- HANDLE_TYPE(UINT64, uint, uint)
- HANDLE_TYPE(LONG, long, long)
- HANDLE_TYPE(ULONG, ulong, ulong)
+ val = g_variant_get_fixed_array (value, &length, 1);
+ if (length)
+ *param = g_bytes_new (val, length);
+ else
+ *param = NULL;
+ HANDLE_TYPE (G_TYPE_BOOLEAN, G_VARIANT_TYPE_BOOLEAN, gboolean, g_variant_get_boolean)
+ HANDLE_TYPE (G_TYPE_UCHAR, G_VARIANT_TYPE_BYTE, guchar, g_variant_get_byte)
+ HANDLE_TYPE (G_TYPE_DOUBLE, G_VARIANT_TYPE_DOUBLE, gdouble, g_variant_get_double)
+ HANDLE_TYPE (G_TYPE_INT, G_VARIANT_TYPE_INT32, gint, g_variant_get_int32)
+ HANDLE_TYPE (G_TYPE_UINT, G_VARIANT_TYPE_UINT32, guint, g_variant_get_uint32)
+ HANDLE_TYPE (G_TYPE_INT64, G_VARIANT_TYPE_INT64, gint, g_variant_get_int64)
+ HANDLE_TYPE (G_TYPE_UINT64, G_VARIANT_TYPE_UINT64, guint, g_variant_get_uint64)
+ HANDLE_TYPE (G_TYPE_LONG, G_VARIANT_TYPE_INT64, glong, g_variant_get_int64)
+ HANDLE_TYPE (G_TYPE_ULONG, G_VARIANT_TYPE_UINT64, gulong, g_variant_get_uint64)
} else {
dbgmsg ("%s: %s/%s unhandled type %s.",
__func__,
const NMPropertiesInfo *info)
{
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (object);
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
static gsize dval = 0;
const char *debugstr;
NMPropertiesInfo *tmp;
proxy = _nm_object_get_proxy (object, interface);
g_return_if_fail (proxy != NULL);
- dbus_g_proxy_add_signal (proxy, "PropertiesChanged", DBUS_TYPE_G_MAP_OF_VARIANT, G_TYPE_INVALID);
- dbus_g_proxy_connect_signal (proxy,
- "PropertiesChanged",
- G_CALLBACK (properties_changed_proxy),
- object,
- NULL);
+ g_signal_connect (proxy, "g-signal",
+ G_CALLBACK (property_proxy_signal), 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);
_nm_object_reload_properties (NMObject *object, GError **error)
{
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (object);
- GHashTable *props = NULL;
+ GVariant *ret, *props;
GHashTableIter iter;
const char *interface;
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
if (!g_hash_table_size (priv->proxies) || !priv->nm_running)
return TRUE;
g_hash_table_iter_init (&iter, priv->proxies);
while (g_hash_table_iter_next (&iter, (gpointer *) &interface, (gpointer *) &proxy)) {
- if (!dbus_g_proxy_call (priv->properties_proxy, "GetAll", error,
- G_TYPE_STRING, interface,
- G_TYPE_INVALID,
- DBUS_TYPE_G_MAP_OF_VARIANT, &props,
- G_TYPE_INVALID))
+ ret = g_dbus_proxy_call_sync (priv->properties_proxy,
+ "GetAll",
+ g_variant_new ("(s)", interface),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, error);
+ if (!ret)
return FALSE;
+ g_variant_get (ret, "(@a{sv})", &props);
process_properties_changed (object, props, TRUE);
- g_hash_table_destroy (props);
+ g_variant_unref (props);
+ g_variant_unref (ret);
}
return TRUE;
const char *interface,
const char *prop_name)
{
- GValue value = G_VALUE_INIT;
+ GVariant *ret, *value;
GError *err = NULL;
g_return_if_fail (NM_IS_OBJECT (object));
if (!NM_OBJECT_GET_PRIVATE (object)->nm_running)
return;
- if (!dbus_g_proxy_call_with_timeout (NM_OBJECT_GET_PRIVATE (object)->properties_proxy,
- "Get", 15000, &err,
- G_TYPE_STRING, interface,
- G_TYPE_STRING, prop_name,
- G_TYPE_INVALID,
- G_TYPE_VALUE, &value,
- G_TYPE_INVALID)) {
+ ret = g_dbus_proxy_call_sync (NM_OBJECT_GET_PRIVATE (object)->properties_proxy,
+ "Get",
+ g_variant_new ("(ss)", interface, prop_name),
+ G_DBUS_CALL_FLAGS_NONE, 15000,
+ NULL, &err);
+ if (!ret) {
dbgmsg ("%s: Error getting '%s' for %s: (%d) %s\n",
__func__,
prop_name,
return;
}
- handle_property_changed (object, prop_name, &value, TRUE);
- g_value_unset (&value);
+ g_variant_get (ret, "(v)", &value);
+ handle_property_changed (object, prop_name, value, TRUE);
+ g_variant_unref (value);
+ g_variant_unref (ret);
}
void
_nm_object_set_property (NMObject *object,
const char *interface,
const char *prop_name,
- GValue *value)
+ const char *format_string,
+ ...)
{
+ GVariant *val, *ret;
+ va_list ap;
+
g_return_if_fail (NM_IS_OBJECT (object));
g_return_if_fail (interface != NULL);
g_return_if_fail (prop_name != NULL);
- g_return_if_fail (G_IS_VALUE (value));
+ g_return_if_fail (format_string != NULL);
if (!NM_OBJECT_GET_PRIVATE (object)->nm_running)
return;
- if (!dbus_g_proxy_call_with_timeout (NM_OBJECT_GET_PRIVATE (object)->properties_proxy,
- "Set", 2000, NULL,
- G_TYPE_STRING, interface,
- G_TYPE_STRING, prop_name,
- G_TYPE_VALUE, value,
- G_TYPE_INVALID)) {
-
- /* Ignore errors. dbus_g_proxy_call_with_timeout() is called instead of
- * dbus_g_proxy_call_no_reply() to give NM chance to authenticate the caller.
- */
- }
+ va_start (ap, format_string);
+ val = g_variant_new_va (format_string, NULL, &ap);
+ va_end (ap);
+ g_return_if_fail (val != NULL);
+
+ ret = g_dbus_proxy_call_sync (NM_OBJECT_GET_PRIVATE (object)->properties_proxy,
+ "Set",
+ g_variant_new ("(ssv)", interface, prop_name, val),
+ G_DBUS_CALL_FLAGS_NONE, 2000,
+ NULL, NULL);
+ /* Ignore errors. */
+ if (ret)
+ g_variant_unref (ret);
}
static void
}
static void
-reload_got_properties (DBusGProxy *proxy, DBusGProxyCall *call,
+reload_got_properties (GObject *proxy,
+ GAsyncResult *result,
gpointer user_data)
{
NMObject *object = user_data;
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (object);
- GHashTable *props = NULL;
+ GVariant *ret, *props;
GError *error = NULL;
- if (dbus_g_proxy_end_call (proxy, call, &error,
- DBUS_TYPE_G_MAP_OF_VARIANT, &props,
- G_TYPE_INVALID)) {
+ ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, &error);
+ if (ret) {
+ g_variant_get (ret, "(@a{sv})", &props);
process_properties_changed (object, props, FALSE);
- g_hash_table_destroy (props);
+ g_variant_unref (props);
+ g_variant_unref (ret);
} else {
if (priv->reload_error)
g_error_free (error);
GSimpleAsyncResult *simple;
GHashTableIter iter;
const char *interface;
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
simple = g_simple_async_result_new (G_OBJECT (object), callback,
user_data, _nm_object_reload_properties_async);
- if (!g_hash_table_size (priv->proxies)) {
+ if (!g_hash_table_size (priv->proxies) || !priv->nm_running) {
g_simple_async_result_complete_in_idle (simple);
g_object_unref (simple);
return;
g_hash_table_iter_init (&iter, priv->proxies);
while (g_hash_table_iter_next (&iter, (gpointer *) &interface, (gpointer *) &proxy)) {
priv->reload_remaining++;
- dbus_g_proxy_begin_call (priv->properties_proxy, "GetAll",
- reload_got_properties, object, NULL,
- G_TYPE_STRING, interface,
- G_TYPE_INVALID);
+ g_dbus_proxy_call (priv->properties_proxy,
+ "GetAll",
+ g_variant_new ("(s)", interface),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL,
+ reload_got_properties, object);
}
}
#error "Only <NetworkManager.h> can be included directly."
#endif
-#include <glib.h>
-#include <glib-object.h>
-#include <dbus/dbus-glib.h>
+#include <gio/gio.h>
#include <nm-version.h>
#include "nm-remote-connection.h"
#include "nm-remote-connection-private.h"
#include "nm-object-private.h"
-#include "nm-dbus-glib-types.h"
#include "nm-glib-compat.h"
#include "nm-dbus-helpers.h"
-#include "nm-utils-private.h"
+
+#include "nmdbus-settings-connection.h"
static void nm_remote_connection_connection_iface_init (NMConnectionInterface *iface);
static void nm_remote_connection_initable_iface_init (GInitableIface *iface);
};
typedef struct RemoteCall RemoteCall;
-typedef void (*RemoteCallFetchResultCb) (RemoteCall *call, DBusGProxyCall *proxy_call, GError *error);
+typedef void (*RemoteCallFetchResultCb) (RemoteCall *call, GAsyncResult *result);
struct RemoteCall {
NMRemoteConnection *self;
- DBusGProxyCall *call;
RemoteCallFetchResultCb fetch_result_cb;
GFunc callback;
gpointer user_data;
};
typedef struct {
- DBusGProxy *proxy;
- gboolean proxy_is_destroyed;
- GSList *calls;
+ NMDBusSettingsConnection *proxy;
gboolean unsaved;
/****************************************************************/
static void
-remote_call_dbus_cb (DBusGProxy *proxy, DBusGProxyCall *proxy_call, gpointer user_data)
+remote_call_dbus_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
{
RemoteCall *call = user_data;
- NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (call->self);
- GError *error = NULL;
- g_assert ( (!proxy && !proxy_call && priv->proxy_is_destroyed) ||
- ( proxy && proxy_call && !priv->proxy_is_destroyed && proxy == priv->proxy) );
-
- if (priv->proxy_is_destroyed) {
- error = g_error_new_literal (NM_REMOTE_CONNECTION_ERROR,
- NM_REMOTE_CONNECTION_ERROR_DISCONNECTED,
- _("Disconnected by D-Bus"));
- }
- call->fetch_result_cb (call, proxy_call, error);
- g_clear_error (&error);
+ call->fetch_result_cb (call, result);
- priv->calls = g_slist_remove (priv->calls, call);
g_object_unref (call->self);
g_free (call);
}
-static gboolean
-remote_call_cleanup_cb (void *user_data)
-{
- remote_call_dbus_cb (NULL, NULL, user_data);
- return G_SOURCE_REMOVE;
-}
-
static RemoteCall *
remote_call_new (NMRemoteConnection *self,
RemoteCallFetchResultCb fetch_result_cb,
gpointer user_data)
{
RemoteCall *call;
- NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
g_assert (fetch_result_cb);
- if (priv->proxy_is_destroyed && !callback)
- return NULL;
-
call = g_malloc0 (sizeof (RemoteCall));
call->self = g_object_ref (self);
call->fetch_result_cb = fetch_result_cb;
call->user_data = user_data;
call->callback = callback;
- if (priv->proxy_is_destroyed) {
- g_idle_add (remote_call_cleanup_cb, call);
- return NULL;
- }
- priv->calls = g_slist_prepend (priv->calls, call);
return call;
}
-static void
-proxy_set_destroyed (NMRemoteConnection *self)
-{
- NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
-
- if (priv->proxy_is_destroyed) {
- g_assert (!priv->calls);
- return;
- }
-
- priv->proxy_is_destroyed = TRUE;
-
- priv->calls = g_slist_reverse (priv->calls);
- while (priv->calls)
- remote_call_dbus_cb (NULL, NULL, priv->calls->data);
-}
-
-static void
-proxy_destroy_cb (DBusGProxy* proxy, gpointer user_data) {
- proxy_set_destroyed (user_data);
-}
-
/****************************************************************/
static void
-result_cb (RemoteCall *call, DBusGProxyCall *proxy_call, GError *error)
+update_result_cb (RemoteCall *call, GAsyncResult *result)
{
+ NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (call->self);
NMRemoteConnectionResultFunc func = (NMRemoteConnectionResultFunc) call->callback;
- GError *local_error = NULL;
+ GError *error = NULL;
- if (!error) {
- dbus_g_proxy_end_call (NM_REMOTE_CONNECTION_GET_PRIVATE (call->self)->proxy,
- proxy_call, &local_error, G_TYPE_INVALID);
- error = local_error;
- }
+ nmdbus_settings_connection_call_update_finish (priv->proxy, result, &error);
if (func)
(*func) (call->self, error, call->user_data);
- g_clear_error (&local_error);
+ g_clear_error (&error);
}
/**
{
NMRemoteConnectionPrivate *priv;
RemoteCall *call;
- GVariant *settings_dict;
- GHashTable *settings;
+ GVariant *settings;
g_return_if_fail (NM_IS_REMOTE_CONNECTION (self));
priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
- call = remote_call_new (self, result_cb, (GFunc) callback, user_data);
+ call = remote_call_new (self, update_result_cb, (GFunc) callback, user_data);
if (!call)
return;
- settings_dict = nm_connection_to_dbus (NM_CONNECTION (self), NM_CONNECTION_SERIALIZE_ALL);
- settings = _nm_utils_connection_dict_to_hash (settings_dict);
- g_variant_unref (settings_dict);
+ settings = nm_connection_to_dbus (NM_CONNECTION (self), NM_CONNECTION_SERIALIZE_ALL);
+ nmdbus_settings_connection_call_update (priv->proxy,
+ settings,
+ NULL,
+ remote_call_dbus_cb, call);
+}
- call->call = dbus_g_proxy_begin_call (priv->proxy, "Update",
- remote_call_dbus_cb, call, NULL,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, settings,
- G_TYPE_INVALID);
- g_assert (call->call);
- g_hash_table_destroy (settings);
+static void
+update_unsaved_result_cb (RemoteCall *call, GAsyncResult *result)
+{
+ NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (call->self);
+ NMRemoteConnectionResultFunc func = (NMRemoteConnectionResultFunc) call->callback;
+ GError *error = NULL;
+
+ nmdbus_settings_connection_call_update_unsaved_finish (priv->proxy, result, &error);
+ if (func)
+ (*func) (call->self, error, call->user_data);
+ g_clear_error (&error);
}
/**
gpointer user_data)
{
NMRemoteConnectionPrivate *priv;
- GVariant *settings_dict;
- GHashTable *settings;
+ GVariant *settings;
RemoteCall *call;
g_return_if_fail (NM_IS_REMOTE_CONNECTION (connection));
priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
- call = remote_call_new (connection, result_cb, (GFunc) callback, user_data);
+ call = remote_call_new (connection, update_unsaved_result_cb, (GFunc) callback, user_data);
if (!call)
return;
- settings_dict = nm_connection_to_dbus (NM_CONNECTION (connection), NM_CONNECTION_SERIALIZE_ALL);
- settings = _nm_utils_connection_dict_to_hash (settings_dict);
- g_variant_unref (settings_dict);
- call->call = dbus_g_proxy_begin_call (priv->proxy, "UpdateUnsaved",
- remote_call_dbus_cb, call, NULL,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, settings,
- G_TYPE_INVALID);
- g_assert (call->call);
- g_hash_table_destroy (settings);
+ settings = nm_connection_to_dbus (NM_CONNECTION (connection), NM_CONNECTION_SERIALIZE_ALL);
+ nmdbus_settings_connection_call_update_unsaved (priv->proxy,
+ settings,
+ NULL,
+ remote_call_dbus_cb, call);
+}
+
+static void
+save_result_cb (RemoteCall *call, GAsyncResult *result)
+{
+ NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (call->self);
+ NMRemoteConnectionResultFunc func = (NMRemoteConnectionResultFunc) call->callback;
+ GError *error = NULL;
+
+ nmdbus_settings_connection_call_save_finish (priv->proxy, result, &error);
+ if (func)
+ (*func) (call->self, error, call->user_data);
+ g_clear_error (&error);
}
/**
priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
- call = remote_call_new (connection, result_cb, (GFunc) callback, user_data);
+ call = remote_call_new (connection, save_result_cb, (GFunc) callback, user_data);
if (!call)
return;
- call->call = dbus_g_proxy_begin_call (priv->proxy, "Save", remote_call_dbus_cb, call, NULL, G_TYPE_INVALID);
- g_assert (call->call);
+ nmdbus_settings_connection_call_save (priv->proxy,
+ NULL,
+ remote_call_dbus_cb, call);
+}
+
+static void
+delete_result_cb (RemoteCall *call, GAsyncResult *result)
+{
+ NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (call->self);
+ NMRemoteConnectionResultFunc func = (NMRemoteConnectionResultFunc) call->callback;
+ GError *error = NULL;
+
+ nmdbus_settings_connection_call_delete_finish (priv->proxy, result, &error);
+ if (func)
+ (*func) (call->self, error, call->user_data);
+ g_clear_error (&error);
}
/**
priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
- call = remote_call_new (self, result_cb, (GFunc) callback, user_data);
+ call = remote_call_new (self, delete_result_cb, (GFunc) callback, user_data);
if (!call)
return;
- call->call = dbus_g_proxy_begin_call (priv->proxy, "Delete",
- remote_call_dbus_cb, call, NULL,
- G_TYPE_INVALID);
- g_assert (call->call);
+ nmdbus_settings_connection_call_delete (priv->proxy,
+ NULL,
+ remote_call_dbus_cb, call);
}
static void
-get_secrets_cb (RemoteCall *call, DBusGProxyCall *proxy_call, GError *error)
+get_secrets_cb (RemoteCall *call, GAsyncResult *result)
{
+ NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (call->self);
NMRemoteConnectionGetSecretsFunc func = (NMRemoteConnectionGetSecretsFunc) call->callback;
- GHashTable *secrets = NULL;
- GError *local_error = NULL;
-
- if (!error) {
- dbus_g_proxy_end_call (NM_REMOTE_CONNECTION_GET_PRIVATE (call->self)->proxy,
- proxy_call, &local_error,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, &secrets,
- G_TYPE_INVALID);
- error = local_error;
- }
- if (func) {
- GVariant *secrets_dict;
-
- if (secrets)
- secrets_dict = _nm_utils_connection_hash_to_dict (secrets);
- else
- secrets_dict = NULL;
-
- (*func) (call->self, error ? NULL : secrets_dict, error, call->user_data);
+ GVariant *secrets = NULL;
+ GError *error = NULL;
- if (secrets_dict)
- g_variant_unref (secrets_dict);
- }
- g_clear_error (&local_error);
+ if (!nmdbus_settings_connection_call_get_secrets_finish (priv->proxy, &secrets,
+ result, &error))
+ secrets = NULL;
+ if (func)
+ (*func) (call->self, error ? NULL : secrets, error, call->user_data);
+ g_clear_error (&error);
if (secrets)
- g_hash_table_destroy (secrets);
+ g_variant_unref (secrets);
}
if (!call)
return;
- call->call = dbus_g_proxy_begin_call (priv->proxy, "GetSecrets",
- remote_call_dbus_cb, call, NULL,
- G_TYPE_STRING, setting_name,
- G_TYPE_INVALID);
- g_assert (call->call);
+ nmdbus_settings_connection_call_get_secrets (priv->proxy,
+ setting_name,
+ NULL,
+ remote_call_dbus_cb, call);
}
/**
/****************************************************************/
static void
-replace_settings (NMRemoteConnection *self, GHashTable *new_settings)
+replace_settings (NMRemoteConnection *self, GVariant *new_settings)
{
GError *error = NULL;
- GVariant *new_settings_dict;
- new_settings_dict = _nm_utils_connection_hash_to_dict (new_settings);
- if (!nm_connection_replace_settings (NM_CONNECTION (self), new_settings_dict, &error)) {
+ if (!nm_connection_replace_settings (NM_CONNECTION (self), new_settings, &error)) {
g_warning ("%s: error updating connection %s settings: (%d) %s",
__func__,
nm_connection_get_path (NM_CONNECTION (self)),
(error && error->message) ? error->message : "(unknown)");
g_clear_error (&error);
}
- g_variant_unref (new_settings_dict);
}
static void
-updated_get_settings_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+updated_get_settings_cb (GObject *proxy,
+ GAsyncResult *result,
gpointer user_data)
{
NMRemoteConnection *self = user_data;
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
- GHashTable *new_settings;
- GError *error = NULL;
+ GVariant *new_settings;
gboolean visible;
- dbus_g_proxy_end_call (proxy, call, &error,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, &new_settings,
- G_TYPE_INVALID);
- if (error) {
- g_error_free (error);
-
+ if (!nmdbus_settings_connection_call_get_settings_finish (priv->proxy, &new_settings,
+ result, NULL)) {
/* Connection is no longer visible to this user. */
nm_connection_clear_settings (NM_CONNECTION (self));
visible = FALSE;
} else {
replace_settings (self, new_settings);
- g_hash_table_destroy (new_settings);
+ g_variant_unref (new_settings);
visible = TRUE;
}
}
static void
-updated_cb (DBusGProxy *proxy, gpointer user_data)
+updated_cb (NMDBusSettingsConnection *proxy, gpointer user_data)
{
NMRemoteConnection *self = NM_REMOTE_CONNECTION (user_data);
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
/* The connection got updated; request the replacement settings */
- if (!priv->proxy_is_destroyed) {
- dbus_g_proxy_begin_call (priv->proxy, "GetSettings",
- updated_get_settings_cb, self, NULL,
- G_TYPE_INVALID);
- }
+ nmdbus_settings_connection_call_get_settings (priv->proxy,
+ NULL,
+ updated_get_settings_cb, self);
}
/****************************************************************/
NM_OBJECT_CLASS (nm_remote_connection_parent_class)->init_dbus (object);
- priv->proxy = _nm_object_get_proxy (object, NM_DBUS_INTERFACE_SETTINGS_CONNECTION);
+ priv->proxy = NMDBUS_SETTINGS_CONNECTION (_nm_object_get_proxy (object, NM_DBUS_INTERFACE_SETTINGS_CONNECTION));
g_assert (priv->proxy);
- dbus_g_proxy_set_default_timeout (priv->proxy, G_MAXINT);
_nm_object_register_properties (object,
NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
property_info);
- dbus_g_proxy_add_signal (priv->proxy, "Updated", G_TYPE_INVALID);
- dbus_g_proxy_connect_signal (priv->proxy, "Updated", G_CALLBACK (updated_cb), object, NULL);
-
- g_signal_connect (priv->proxy, "destroy", G_CALLBACK (proxy_destroy_cb), object);
+ g_signal_connect (priv->proxy, "updated",
+ G_CALLBACK (updated_cb), object);
}
static gboolean
{
NMRemoteConnection *self = NM_REMOTE_CONNECTION (initable);
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (initable);
- GHashTable *hash;
+ GVariant *settings;
if (!nm_remote_connection_parent_initable_iface->init (initable, cancellable, error))
return FALSE;
- if (!dbus_g_proxy_call (priv->proxy, "GetSettings", error,
- G_TYPE_INVALID,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, &hash,
- G_TYPE_INVALID))
+ if (!nmdbus_settings_connection_call_get_settings_sync (priv->proxy,
+ &settings,
+ cancellable, error))
return FALSE;
+
priv->visible = TRUE;
- replace_settings (self, hash);
- g_hash_table_destroy (hash);
+ replace_settings (self, settings);
+ g_variant_unref (settings);
return TRUE;
}
typedef struct {
NMRemoteConnection *connection;
+ GCancellable *cancellable;
GSimpleAsyncResult *result;
} NMRemoteConnectionInitData;
g_simple_async_result_complete (init_data->result);
g_object_unref (init_data->result);
+ g_clear_object (&init_data->cancellable);
g_slice_free (NMRemoteConnectionInitData, init_data);
}
static void
-init_get_settings_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+init_get_settings_cb (GObject *proxy,
+ GAsyncResult *result,
gpointer user_data)
{
NMRemoteConnectionInitData *init_data = user_data;
NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (init_data->connection);
- GHashTable *settings;
+ GVariant *settings;
GError *error = NULL;
- dbus_g_proxy_end_call (proxy, call, &error,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, &settings,
- G_TYPE_INVALID);
- if (error) {
+ if (!nmdbus_settings_connection_call_get_settings_finish (priv->proxy, &settings,
+ result, &error)) {
init_async_complete (init_data, error);
return;
}
priv->visible = TRUE;
replace_settings (init_data->connection, settings);
- g_hash_table_destroy (settings);
+ g_variant_unref (settings);
init_async_complete (init_data, NULL);
}
return;
}
- dbus_g_proxy_begin_call (priv->proxy, "GetSettings",
- init_get_settings_cb, init_data, NULL,
- G_TYPE_INVALID);
+ nmdbus_settings_connection_call_get_settings (priv->proxy,
+ init_data->cancellable,
+ init_get_settings_cb, init_data);
}
static void
init_data = g_slice_new0 (NMRemoteConnectionInitData);
init_data->connection = NM_REMOTE_CONNECTION (initable);
+ init_data->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
init_data->result = g_simple_async_result_new (G_OBJECT (initable), callback,
user_data, init_async);
nm_object_get_path (NM_OBJECT (object)));
}
-static void
-dispose (GObject *object)
-{
- NMRemoteConnection *self = NM_REMOTE_CONNECTION (object);
- NMRemoteConnectionPrivate *priv = NM_REMOTE_CONNECTION_GET_PRIVATE (self);
-
- proxy_set_destroyed (self);
-
- if (priv->proxy) {
- g_signal_handlers_disconnect_by_func (priv->proxy, proxy_destroy_cb, object);
- priv->proxy = NULL;
- }
-
- G_OBJECT_CLASS (nm_remote_connection_parent_class)->dispose (object);
-}
-
static void
nm_remote_connection_class_init (NMRemoteConnectionClass *remote_class)
{
g_type_class_add_private (object_class, sizeof (NMRemoteConnectionPrivate));
_nm_object_class_add_interface (nm_object_class, NM_DBUS_INTERFACE_SETTINGS_CONNECTION);
+ _nm_dbus_register_proxy_type (NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+ NMDBUS_TYPE_SETTINGS_CONNECTION_PROXY);
/* virtual methods */
object_class->constructed = constructed;
object_class->get_property = get_property;
- object_class->dispose = dispose;
nm_object_class->init_dbus = init_dbus;
#include <nm-dbus-interface.h>
#include <nm-connection.h>
-#include "nm-dbus-glib-types.h"
#include "nm-remote-settings.h"
#include "nm-remote-connection-private.h"
#include "nm-object-private.h"
#include "nm-object-private.h"
#include "nm-core-internal.h"
+#include "nmdbus-settings.h"
+
/**
* SECTION:nm-remote-settings
* @Short_description: A helper for NetworkManager's settings API
#define NM_REMOTE_SETTINGS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_REMOTE_SETTINGS, NMRemoteSettingsPrivate))
typedef struct {
- DBusGProxy *proxy;
+ NMDBusSettings *proxy;
GPtrArray *all_connections;
GPtrArray *visible_connections;
}
static void
-add_connection_done (DBusGProxy *proxy, DBusGProxyCall *call, gpointer user_data)
+add_connection_done (GObject *proxy, GAsyncResult *result, gpointer user_data)
{
AddConnectionInfo *info = user_data;
GError *error = NULL;
- char *path = NULL;
- if (dbus_g_proxy_end_call (proxy, call, &error, DBUS_TYPE_G_OBJECT_PATH, &path, G_TYPE_INVALID)) {
- info->path = path;
+ if (nmdbus_settings_call_add_connection_finish (NMDBUS_SETTINGS (proxy),
+ &info->path,
+ result, &error)) {
/* Wait until this connection is fully initialized before calling the callback */
- } else
+ } else {
add_connection_info_complete (info->self, info, NULL, error);
-
- g_clear_error (&error);
+ g_clear_error (&error);
+ }
}
/**
{
NMRemoteSettingsPrivate *priv;
AddConnectionInfo *info;
- GVariant *new_settings_dict;
- GHashTable *new_settings;
+ GVariant *new_settings;
g_return_val_if_fail (NM_IS_REMOTE_SETTINGS (settings), FALSE);
g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE);
info->callback = callback;
info->callback_data = user_data;
- new_settings_dict = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
- new_settings = _nm_utils_connection_dict_to_hash (new_settings_dict);
- dbus_g_proxy_begin_call (priv->proxy, "AddConnection",
- add_connection_done,
- info,
- NULL,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, new_settings,
- G_TYPE_INVALID);
- g_hash_table_destroy (new_settings);
- g_variant_unref (new_settings_dict);
+ new_settings = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
+ nmdbus_settings_call_add_connection (priv->proxy,
+ new_settings,
+ NULL,
+ add_connection_done, info);
priv->add_list = g_slist_append (priv->add_list, info);
{
NMRemoteSettingsPrivate *priv;
AddConnectionInfo *info;
- GVariant *new_settings_dict;
- GHashTable *new_settings;
+ GVariant *new_settings;
g_return_val_if_fail (NM_IS_REMOTE_SETTINGS (settings), FALSE);
g_return_val_if_fail (NM_IS_CONNECTION (connection), FALSE);
info->callback = callback;
info->callback_data = user_data;
- new_settings_dict = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
- new_settings = _nm_utils_connection_dict_to_hash (new_settings_dict);
- dbus_g_proxy_begin_call (priv->proxy, "AddConnectionUnsaved",
- add_connection_done,
- info,
- NULL,
- DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT, new_settings,
- G_TYPE_INVALID);
- g_hash_table_destroy (new_settings);
- g_variant_unref (new_settings_dict);
+ new_settings = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
+ nmdbus_settings_call_add_connection_unsaved (priv->proxy,
+ new_settings,
+ NULL,
+ add_connection_done, info);
priv->add_list = g_slist_append (priv->add_list, info);
GError **error)
{
NMRemoteSettingsPrivate *priv;
- char **my_failures = NULL;
- gboolean ret;
+ gboolean success;
g_return_val_if_fail (NM_IS_REMOTE_SETTINGS (settings), FALSE);
g_return_val_if_fail (filenames != NULL, FALSE);
return FALSE;
}
- if (!dbus_g_proxy_call (priv->proxy, "LoadConnections", error,
- G_TYPE_STRV, filenames,
- G_TYPE_INVALID,
- G_TYPE_BOOLEAN, &ret,
- G_TYPE_STRV, &my_failures,
- G_TYPE_INVALID))
- ret = FALSE;
-
- if (failures) {
- if (my_failures && !*my_failures)
- g_clear_pointer (&my_failures, g_free);
- *failures = my_failures;
- } else
- g_strfreev (my_failures);
-
- return ret;
+ if (!nmdbus_settings_call_load_connections_sync (priv->proxy,
+ (const char * const *) filenames,
+ &success,
+ failures,
+ NULL, error))
+ success = FALSE;
+
+ return success;
}
/**
return FALSE;
}
- if (!dbus_g_proxy_call (priv->proxy, "ReloadConnections", error,
- G_TYPE_INVALID,
- G_TYPE_BOOLEAN, &success,
- G_TYPE_INVALID))
- return FALSE;
+ if (!nmdbus_settings_call_reload_connections_sync (priv->proxy, &success,
+ NULL, error))
+ success = FALSE;
+
return success;
}
} SaveHostnameInfo;
static void
-save_hostname_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+save_hostname_cb (GObject *proxy,
+ GAsyncResult *result,
gpointer user_data)
{
SaveHostnameInfo *info = user_data;
GError *error = NULL;
- dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
+ nmdbus_settings_call_save_hostname_finish (NMDBUS_SETTINGS (proxy), result, &error);
if (info->callback != NULL)
info->callback (info->settings, error, info->callback_data);
g_clear_error (&error);
info->callback = callback;
info->callback_data = user_data;
- dbus_g_proxy_begin_call (priv->proxy, "SaveHostname",
- save_hostname_cb,
- info,
- g_free,
- G_TYPE_STRING, hostname ? hostname : "",
- G_TYPE_INVALID);
+ nmdbus_settings_call_save_hostname (priv->proxy,
+ hostname ? hostname : "",
+ NULL,
+ save_hostname_cb, info);
return TRUE;
}
NM_OBJECT_CLASS (nm_remote_settings_parent_class)->init_dbus (object);
- priv->proxy = _nm_object_get_proxy (object, NM_DBUS_INTERFACE_SETTINGS);
+ priv->proxy = NMDBUS_SETTINGS (_nm_object_get_proxy (object, NM_DBUS_INTERFACE_SETTINGS));
_nm_object_register_properties (object,
NM_DBUS_INTERFACE_SETTINGS,
property_info);
g_type_class_add_private (class, sizeof (NMRemoteSettingsPrivate));
_nm_object_class_add_interface (nm_object_class, NM_DBUS_INTERFACE_SETTINGS);
+ _nm_dbus_register_proxy_type (NM_DBUS_INTERFACE_SETTINGS, NMDBUS_TYPE_SETTINGS_PROXY);
/* Virtual methods */
object_class->constructor = constructor;
#include <config.h>
#include <string.h>
-#include <dbus/dbus-glib-lowlevel.h>
#include "nm-glib-compat.h"
#include "nm-dbus-interface.h"
#include "nm-enum-types.h"
#include "nm-dbus-helpers.h"
#include "nm-simple-connection.h"
-#include "nm-utils-private.h"
-static void impl_secret_agent_get_secrets (NMSecretAgent *self,
- GHashTable *connection_hash,
- const char *connection_path,
- const char *setting_name,
- const char **hints,
- guint32 flags,
- DBusGMethodInvocation *context);
-
-static void impl_secret_agent_cancel_get_secrets (NMSecretAgent *self,
- const char *connection_path,
- const char *setting_name,
- DBusGMethodInvocation *context);
-
-static void impl_secret_agent_save_secrets (NMSecretAgent *self,
- GHashTable *connection_hash,
- const char *connection_path,
- DBusGMethodInvocation *context);
-
-static void impl_secret_agent_delete_secrets (NMSecretAgent *self,
- GHashTable *connection_hash,
- const char *connection_path,
- DBusGMethodInvocation *context);
-
-#include "nm-secret-agent-glue.h"
+#include "nmdbus-secret-agent.h"
+#include "nmdbus-agent-manager.h"
static void nm_secret_agent_initable_iface_init (GInitableIface *iface);
static void nm_secret_agent_async_initable_iface_init (GAsyncInitableIface *iface);
gboolean registering;
NMSecretAgentCapabilities capabilities;
- DBusGConnection *bus;
+ GDBusConnection *bus;
gboolean private_bus;
gboolean session_bus;
- DBusGProxy *dbus_proxy;
- DBusGProxy *manager_proxy;
+ NMDBusAgentManager *manager_proxy;
+ NMDBusSecretAgent *dbus_secret_agent;
/* GetSecretsInfo structs of in-flight GetSecrets requests */
GSList *pending_gets;
- char *nm_owner;
-
char *identifier;
gboolean auto_register;
gboolean suppress_auto;
/*************************************************************/
-static const char *
-get_nm_owner (NMSecretAgent *self)
-{
- NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
- GError *error = NULL;
- char *owner;
-
- if (!priv->nm_owner) {
- if (!dbus_g_proxy_call_with_timeout (priv->dbus_proxy,
- "GetNameOwner", 2000, &error,
- G_TYPE_STRING, NM_DBUS_SERVICE,
- G_TYPE_INVALID,
- G_TYPE_STRING, &owner,
- G_TYPE_INVALID))
- return NULL;
-
- priv->nm_owner = g_strdup (owner);
- g_free (owner);
- }
-
- return priv->nm_owner;
-}
-
static void
_internal_unregister (NMSecretAgent *self)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
if (priv->registered) {
- dbus_g_connection_unregister_g_object (priv->bus, G_OBJECT (self));
+ g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (priv->dbus_secret_agent));
priv->registered = FALSE;
priv->registering = FALSE;
g_object_notify (G_OBJECT (self), NM_SECRET_AGENT_REGISTERED);
typedef struct {
char *path;
char *setting_name;
- DBusGMethodInvocation *context;
+ GDBusMethodInvocation *context;
} GetSecretsInfo;
static void
}
static void
-name_owner_changed (DBusGProxy *proxy,
- const char *name,
- const char *old_owner,
- const char *new_owner,
+name_owner_changed (GObject *proxy,
+ GParamSpec *pspec,
gpointer user_data)
{
NMSecretAgent *self = NM_SECRET_AGENT (user_data);
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
- gboolean old_owner_good = (old_owner && strlen (old_owner));
- gboolean new_owner_good = (new_owner && strlen (new_owner));
GSList *iter;
- if (strcmp (name, NM_DBUS_SERVICE) == 0) {
- g_free (priv->nm_owner);
- priv->nm_owner = g_strdup (new_owner);
-
- if (!old_owner_good && new_owner_good) {
- /* NM appeared */
- if (should_auto_register (self))
- nm_secret_agent_register_async (self, NULL, NULL, NULL);
- } else if (old_owner_good && !new_owner_good) {
- /* Cancel any pending secrets requests */
- for (iter = priv->pending_gets; iter; iter = g_slist_next (iter)) {
- GetSecretsInfo *info = iter->data;
-
- NM_SECRET_AGENT_GET_CLASS (self)->cancel_get_secrets (self,
- info->path,
- info->setting_name);
- }
- g_slist_free (priv->pending_gets);
- priv->pending_gets = NULL;
-
- /* NM disappeared */
- _internal_unregister (self);
- } else if (old_owner_good && new_owner_good && strcmp (old_owner, new_owner)) {
- /* Hmm, NM magically restarted */
- _internal_unregister (self);
- if (should_auto_register (self))
- nm_secret_agent_register_async (self, NULL, NULL, NULL);
+ if (g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)) != NULL) {
+ if (should_auto_register (self))
+ nm_secret_agent_register_async (self, NULL, NULL, NULL);
+ } else {
+ /* Cancel any pending secrets requests */
+ for (iter = priv->pending_gets; iter; iter = g_slist_next (iter)) {
+ GetSecretsInfo *info = iter->data;
+
+ NM_SECRET_AGENT_GET_CLASS (self)->cancel_get_secrets (self,
+ info->path,
+ info->setting_name);
}
+ g_slist_free (priv->pending_gets);
+ priv->pending_gets = NULL;
+
+ _internal_unregister (self);
}
}
static gboolean
verify_sender (NMSecretAgent *self,
- DBusGMethodInvocation *context,
+ GDBusMethodInvocation *context,
GError **error)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
- DBusConnection *bus;
- char *sender;
const char *nm_owner;
- DBusError dbus_error;
- uid_t sender_uid = G_MAXUINT;
- gboolean allowed = FALSE;
+ const char *sender;
+ guint32 sender_uid;
+ GVariant *ret;
+ GError *local = NULL;
g_return_val_if_fail (context != NULL, FALSE);
/* Verify that the sender is the same as NetworkManager's bus name owner. */
- nm_owner = get_nm_owner (self);
+ nm_owner = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (priv->manager_proxy));
if (!nm_owner) {
g_set_error_literal (error,
NM_SECRET_AGENT_ERROR,
return FALSE;
}
- bus = dbus_g_connection_get_connection (priv->bus);
- if (!bus) {
- g_set_error_literal (error,
- NM_SECRET_AGENT_ERROR,
- NM_SECRET_AGENT_ERROR_NOT_AUTHORIZED,
- "Failed to get DBus connection.");
- return FALSE;
- }
-
- sender = dbus_g_method_get_sender (context);
+ sender = g_dbus_method_invocation_get_sender (context);
if (!sender) {
g_set_error_literal (error,
NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_NOT_AUTHORIZED,
"Request sender does not match NetworkManager bus name owner.");
- goto out;
+ return FALSE;
}
/* If we're connected to the session bus, then this must be a test program,
* so skip the UID check.
*/
- if (priv->session_bus) {
- allowed = TRUE;
- goto out;
- }
+ if (priv->session_bus)
+ return TRUE;
- dbus_error_init (&dbus_error);
- sender_uid = dbus_bus_get_unix_user (bus, sender, &dbus_error);
- if (dbus_error_is_set (&dbus_error)) {
+ /* Check the UID of the sender */
+ ret = g_dbus_connection_call_sync (priv->bus,
+ DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "GetConnectionUnixUser",
+ g_variant_new ("(s)", sender),
+ G_VARIANT_TYPE ("(u)"),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL, &local);
+ if (!ret) {
+ char *remote_error = g_dbus_error_get_remote_error (local);
+
+ g_dbus_error_strip_remote_error (local);
g_set_error (error,
NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_NOT_AUTHORIZED,
- "Failed to get request unix user: (%s) %s.",
- dbus_error.name, dbus_error.message);
- dbus_error_free (&dbus_error);
- goto out;
+ "Failed to request unix user: (%s) %s.",
+ remote_error ? remote_error : "",
+ local->message);
+ g_free (remote_error);
+ g_error_free (local);
+ return FALSE;
}
+ g_variant_get (ret, "(u)", &sender_uid);
+ g_variant_unref (ret);
/* We only accept requests from NM, which always runs as root */
if (0 != sender_uid) {
NM_SECRET_AGENT_ERROR,
NM_SECRET_AGENT_ERROR_NOT_AUTHORIZED,
"Request sender is not root.");
- goto out;
+ return FALSE;
}
- allowed = TRUE;
-
-out:
- g_free (sender);
- return allowed;
+ return TRUE;
}
static gboolean
verify_request (NMSecretAgent *self,
- DBusGMethodInvocation *context,
- GHashTable *connection_hash,
+ GDBusMethodInvocation *context,
+ GVariant *connection_dict,
const char *connection_path,
NMConnection **out_connection,
GError **error)
{
NMConnection *connection = NULL;
- GVariant *connection_dict;
GError *local = NULL;
if (!verify_sender (self, context, error))
return FALSE;
/* No connection? If the sender verified, then we allow the request */
- if (connection_hash == NULL)
+ if (connection_dict == NULL)
return TRUE;
- /* If we have a connection hash, we require a path too */
+ /* If we have a connection dictionary, we require a path too */
if (connection_path == NULL) {
g_set_error_literal (error,
NM_SECRET_AGENT_ERROR,
/* Make sure the given connection is valid */
g_assert (out_connection);
- connection_dict = _nm_utils_connection_hash_to_dict (connection_hash);
connection = nm_simple_connection_new_from_dbus (connection_dict, &local);
- g_variant_unref (connection_dict);
if (connection) {
nm_connection_set_path (connection, connection_path);
*out_connection = connection;
GetSecretsInfo *info = user_data;
if (error)
- dbus_g_method_return_error (info->context, error);
+ g_dbus_method_invocation_return_gerror (info->context, error);
else {
- GHashTable *secrets_hash;
-
- secrets_hash = _nm_utils_connection_dict_to_hash (secrets);
- dbus_g_method_return (info->context, secrets_hash);
- g_hash_table_unref (secrets_hash);
+ g_dbus_method_invocation_return_value (info->context,
+ g_variant_new ("(@a{sa{sv}})", secrets));
}
/* Remove the request from internal tracking */
static void
impl_secret_agent_get_secrets (NMSecretAgent *self,
- GHashTable *connection_hash,
+ GDBusMethodInvocation *context,
+ GVariant *connection_dict,
const char *connection_path,
const char *setting_name,
- const char **hints,
- guint32 flags,
- DBusGMethodInvocation *context)
+ const char * const *hints,
+ guint flags,
+ gpointer user_data)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
GError *error = NULL;
GetSecretsInfo *info;
/* Make sure the request comes from NetworkManager and is valid */
- if (!verify_request (self, context, connection_hash, connection_path, &connection, &error)) {
- dbus_g_method_return_error (context, error);
- g_clear_error (&error);
+ if (!verify_request (self, context, connection_dict, connection_path, &connection, &error)) {
+ g_dbus_method_invocation_take_error (context, error);
return;
}
connection,
connection_path,
setting_name,
- hints,
+ (const char **) hints,
flags,
get_secrets_cb,
info);
static void
impl_secret_agent_cancel_get_secrets (NMSecretAgent *self,
+ GDBusMethodInvocation *context,
const char *connection_path,
const char *setting_name,
- DBusGMethodInvocation *context)
+ gpointer user_data)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
GError *error = NULL;
/* Make sure the request comes from NetworkManager and is valid */
if (!verify_request (self, context, NULL, NULL, NULL, &error)) {
- dbus_g_method_return_error (context, error);
- g_clear_error (&error);
+ g_dbus_method_invocation_take_error (context, error);
return;
}
info = find_get_secrets_info (priv->pending_gets, connection_path, setting_name);
if (!info) {
- g_set_error_literal (&error,
- NM_SECRET_AGENT_ERROR,
- NM_SECRET_AGENT_ERROR_INTERNAL_ERROR,
- "No secrets request in progress for this connection.");
- dbus_g_method_return_error (context, error);
- g_clear_error (&error);
+ g_dbus_method_invocation_return_error (context,
+ NM_SECRET_AGENT_ERROR,
+ NM_SECRET_AGENT_ERROR_INTERNAL_ERROR,
+ "No secrets request in progress for this connection.");
return;
}
NM_SECRET_AGENT_GET_CLASS (self)->cancel_get_secrets (self,
info->path,
info->setting_name);
- dbus_g_method_return (context);
+ g_dbus_method_invocation_return_value (context, NULL);
}
static void
GError *error,
gpointer user_data)
{
- DBusGMethodInvocation *context = user_data;
+ GDBusMethodInvocation *context = user_data;
if (error)
- dbus_g_method_return_error (context, error);
+ g_dbus_method_invocation_return_gerror (context, error);
else
- dbus_g_method_return (context);
+ g_dbus_method_invocation_return_value (context, NULL);
}
static void
impl_secret_agent_save_secrets (NMSecretAgent *self,
- GHashTable *connection_hash,
+ GDBusMethodInvocation *context,
+ GVariant *connection_dict,
const char *connection_path,
- DBusGMethodInvocation *context)
+ gpointer user_data)
{
GError *error = NULL;
NMConnection *connection = NULL;
/* Make sure the request comes from NetworkManager and is valid */
- if (!verify_request (self, context, connection_hash, connection_path, &connection, &error)) {
- dbus_g_method_return_error (context, error);
- g_clear_error (&error);
+ if (!verify_request (self, context, connection_dict, connection_path, &connection, &error)) {
+ g_dbus_method_invocation_take_error (context, error);
return;
}
GError *error,
gpointer user_data)
{
- DBusGMethodInvocation *context = user_data;
+ GDBusMethodInvocation *context = user_data;
if (error)
- dbus_g_method_return_error (context, error);
+ g_dbus_method_invocation_return_gerror (context, error);
else
- dbus_g_method_return (context);
+ g_dbus_method_invocation_return_value (context, NULL);
}
static void
impl_secret_agent_delete_secrets (NMSecretAgent *self,
- GHashTable *connection_hash,
+ GDBusMethodInvocation *context,
+ GVariant *connection_dict,
const char *connection_path,
- DBusGMethodInvocation *context)
+ gpointer user_data)
{
GError *error = NULL;
NMConnection *connection = NULL;
/* Make sure the request comes from NetworkManager and is valid */
- if (!verify_request (self, context, connection_hash, connection_path, &connection, &error)) {
- dbus_g_method_return_error (context, error);
- g_clear_error (&error);
+ if (!verify_request (self, context, connection_dict, connection_path, &connection, &error)) {
+ g_dbus_method_invocation_take_error (context, error);
return;
}
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
- if (priv->nm_owner || priv->private_bus)
+ if (priv->private_bus)
+ return TRUE;
+ if (g_dbus_proxy_get_name_owner (G_DBUS_PROXY (priv->manager_proxy)))
return TRUE;
g_set_error (error, NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_INTERNAL_ERROR,
priv->suppress_auto = FALSE;
/* Export our secret agent interface before registering with the manager */
- dbus_g_connection_register_g_object (priv->bus,
- NM_DBUS_PATH_SECRET_AGENT,
- G_OBJECT (self));
+ if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->dbus_secret_agent),
+ priv->bus,
+ NM_DBUS_PATH_SECRET_AGENT,
+ error))
+ return FALSE;
priv->registering = TRUE;
- if (dbus_g_proxy_call_with_timeout (priv->manager_proxy,
- "RegisterWithCapabilities",
- 5000, NULL,
- G_TYPE_STRING, priv->identifier,
- G_TYPE_UINT, priv->capabilities,
- G_TYPE_INVALID,
- G_TYPE_INVALID))
+ if (nmdbus_agent_manager_call_register_with_capabilities_sync (priv->manager_proxy,
+ priv->identifier,
+ priv->capabilities,
+ cancellable, NULL))
goto success;
/* Might be an old NetworkManager that doesn't support capabilities;
* fall back to old Register() method instead.
*/
- if (dbus_g_proxy_call_with_timeout (priv->manager_proxy,
- "Register",
- 5000, error,
- G_TYPE_STRING, priv->identifier,
- G_TYPE_INVALID,
- G_TYPE_INVALID))
+ if (nmdbus_agent_manager_call_register_sync (priv->manager_proxy,
+ priv->identifier,
+ cancellable, NULL))
goto success;
/* Failure */
}
static void
-reg_request_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+reg_request_cb (GObject *proxy,
+ GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
NMSecretAgent *self;
+ NMSecretAgentPrivate *priv;
GError *error = NULL;
self = NM_SECRET_AGENT (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
g_object_unref (self); /* drop extra ref added by get_source_object() */
+ priv = NM_SECRET_AGENT_GET_PRIVATE (self);
- dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
+ nmdbus_agent_manager_call_register_finish (NMDBUS_AGENT_MANAGER (proxy), result, &error);
reg_result (self, simple, error);
+ g_clear_error (&error);
}
static void
-reg_with_caps_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+reg_with_caps_cb (GObject *proxy,
+ GAsyncResult *result,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
g_object_unref (self); /* drop extra ref added by get_source_object() */
priv = NM_SECRET_AGENT_GET_PRIVATE (self);
- if (dbus_g_proxy_end_call (proxy, call, NULL, G_TYPE_INVALID)) {
+ if (nmdbus_agent_manager_call_register_with_capabilities_finish (NMDBUS_AGENT_MANAGER (proxy), result, NULL)) {
reg_result (self, simple, NULL);
return;
}
/* Might be an old NetworkManager that doesn't support capabilities;
* fall back to old Register() method instead.
*/
- dbus_g_proxy_begin_call_with_timeout (priv->manager_proxy,
- "Register",
- reg_request_cb,
- self,
- NULL,
- 5000,
- G_TYPE_STRING, priv->identifier,
- G_TYPE_INVALID);
+ nmdbus_agent_manager_call_register (priv->manager_proxy,
+ priv->identifier,
+ NULL, reg_request_cb, simple);
}
/**
return;
}
- priv->suppress_auto = FALSE;
-
/* Export our secret agent interface before registering with the manager */
- dbus_g_connection_register_g_object (priv->bus,
- NM_DBUS_PATH_SECRET_AGENT,
- G_OBJECT (self));
+ if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->dbus_secret_agent),
+ priv->bus,
+ NM_DBUS_PATH_SECRET_AGENT,
+ &error)) {
+ g_simple_async_result_take_error (simple, error);
+ g_simple_async_result_complete_in_idle (simple);
+ g_object_unref (simple);
+ return;
+ }
+ priv->suppress_auto = FALSE;
priv->registering = TRUE;
- dbus_g_proxy_begin_call_with_timeout (priv->manager_proxy,
- "RegisterWithCapabilities",
- reg_with_caps_cb,
- simple,
- NULL,
- 5000,
- G_TYPE_STRING, priv->identifier,
- G_TYPE_UINT, priv->capabilities,
- G_TYPE_INVALID);
+
+ nmdbus_agent_manager_call_register_with_capabilities (priv->manager_proxy,
+ priv->identifier,
+ priv->capabilities,
+ NULL,
+ reg_with_caps_cb, simple);
}
/**
g_return_val_if_fail (priv->bus != NULL, FALSE);
g_return_val_if_fail (priv->manager_proxy != NULL, FALSE);
- if (!check_nm_running (self, error))
- return FALSE;
-
priv->suppress_auto = TRUE;
- success = dbus_g_proxy_call_with_timeout (priv->manager_proxy,
- "Unregister",
- 5000, error,
- G_TYPE_INVALID,
- G_TYPE_INVALID);
+ success = nmdbus_agent_manager_call_unregister_sync (priv->manager_proxy, cancellable, error);
_internal_unregister (self);
return success;
}
static void
-unregister_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
- gpointer user_data)
+unregister_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
NMSecretAgent *self;
_internal_unregister (self);
- if (dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID))
+ if (nmdbus_agent_manager_call_unregister_finish (NMDBUS_AGENT_MANAGER (proxy),
+ result, &error))
g_simple_async_result_set_op_res_gboolean (simple, TRUE);
else
g_simple_async_result_take_error (simple, error);
priv->suppress_auto = TRUE;
- dbus_g_proxy_begin_call_with_timeout (priv->manager_proxy,
- "Unregister",
- unregister_cb,
- simple,
- NULL,
- 5000,
- G_TYPE_INVALID);
+ nmdbus_agent_manager_call_unregister (priv->manager_proxy, cancellable,
+ unregister_cb, simple);
}
/**
static void
nm_secret_agent_init (NMSecretAgent *self)
{
+ NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+
+ priv->dbus_secret_agent = nmdbus_secret_agent_skeleton_new ();
+ _nm_dbus_bind_properties (self, priv->dbus_secret_agent);
+ _nm_dbus_bind_methods (self, priv->dbus_secret_agent,
+ "GetSecrets", impl_secret_agent_get_secrets,
+ "CancelGetSecrets", impl_secret_agent_cancel_get_secrets,
+ "DeleteSecrets", impl_secret_agent_delete_secrets,
+ "SaveSecrets", impl_secret_agent_save_secrets,
+ NULL);
}
static void
init_common (NMSecretAgent *self)
{
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
- DBusGConnection *session_bus;
-
- session_bus = dbus_g_bus_get (DBUS_BUS_SESSION, NULL);
- if (priv->bus == session_bus)
- priv->session_bus = TRUE;
- if (session_bus)
- dbus_g_connection_unref (session_bus);
priv->private_bus = _nm_dbus_is_connection_private (priv->bus);
if (priv->private_bus == FALSE) {
- priv->dbus_proxy = dbus_g_proxy_new_for_name (priv->bus,
- DBUS_SERVICE_DBUS,
- DBUS_PATH_DBUS,
- DBUS_INTERFACE_DBUS);
- g_assert (priv->dbus_proxy);
-
- dbus_g_object_register_marshaller (g_cclosure_marshal_generic,
- G_TYPE_NONE,
- G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
- G_TYPE_INVALID);
- dbus_g_proxy_add_signal (priv->dbus_proxy, "NameOwnerChanged",
- G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
- G_TYPE_INVALID);
- dbus_g_proxy_connect_signal (priv->dbus_proxy,
- "NameOwnerChanged",
- G_CALLBACK (name_owner_changed),
- self, NULL);
-
- get_nm_owner (self);
+ priv->session_bus = _nm_dbus_bus_type () == G_BUS_TYPE_SESSION;
+
+ g_signal_connect (priv->manager_proxy, "notify::g-name-owner",
+ G_CALLBACK (name_owner_changed), self);
}
}
{
NMSecretAgent *self = NM_SECRET_AGENT (initable);
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (self);
+ GDBusProxy *proxy;
priv->bus = _nm_dbus_new_connection (cancellable, error);
if (!priv->bus)
return FALSE;
- priv->manager_proxy = _nm_dbus_new_proxy_for_connection (priv->bus,
- NM_DBUS_PATH_AGENT_MANAGER,
- NM_DBUS_INTERFACE_AGENT_MANAGER,
- cancellable, error);
- if (!priv->manager_proxy)
+ proxy = _nm_dbus_new_proxy_for_connection (priv->bus,
+ NM_DBUS_PATH_AGENT_MANAGER,
+ NM_DBUS_INTERFACE_AGENT_MANAGER,
+ cancellable, error);
+ if (!proxy)
return FALSE;
+ priv->manager_proxy = NMDBUS_AGENT_MANAGER (proxy);
init_common (self);
{
NMSecretAgentInitData *init_data = user_data;
NMSecretAgentPrivate *priv = NM_SECRET_AGENT_GET_PRIVATE (init_data->self);
+ GDBusProxy *proxy;
GError *error = NULL;
- priv->manager_proxy = _nm_dbus_new_proxy_for_connection_finish (result, &error);
- if (!priv->manager_proxy) {
+ proxy = _nm_dbus_new_proxy_for_connection_finish (result, &error);
+ if (!proxy) {
init_async_complete (init_data, error);
return;
}
+ priv->manager_proxy = NMDBUS_AGENT_MANAGER (proxy);
init_common (init_data->self);
if (priv->registered)
nm_secret_agent_unregister_async (self, NULL, NULL, NULL);
- g_free (priv->identifier);
- priv->identifier = NULL;
- g_free (priv->nm_owner);
- priv->nm_owner = NULL;
+ g_clear_pointer (&priv->identifier, g_free);
while (priv->pending_gets)
get_secrets_info_finalize (self, priv->pending_gets->data);
- g_clear_object (&priv->dbus_proxy);
- g_clear_object (&priv->manager_proxy);
+ g_signal_handlers_disconnect_matched (priv->dbus_secret_agent, G_SIGNAL_MATCH_DATA,
+ 0, 0, NULL, NULL, self);
+ g_object_unref (priv->dbus_secret_agent);
- if (priv->bus) {
- dbus_g_connection_unref (priv->bus);
- priv->bus = NULL;
- }
+ g_clear_object (&priv->manager_proxy);
+ g_clear_object (&priv->bus);
G_OBJECT_CLASS (nm_secret_agent_parent_class)->dispose (object);
}
G_PARAM_CONSTRUCT |
G_PARAM_STATIC_STRINGS));
- dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (class),
- &dbus_glib_nm_secret_agent_object_info);
+ _nm_dbus_register_proxy_type (NM_DBUS_INTERFACE_AGENT_MANAGER,
+ NMDBUS_TYPE_AGENT_MANAGER_PROXY);
- dbus_g_error_domain_register (NM_SECRET_AGENT_ERROR,
- NM_DBUS_INTERFACE_SECRET_AGENT,
- NM_TYPE_SECRET_AGENT_ERROR);
+ _nm_dbus_register_error_domain (NM_SECRET_AGENT_ERROR,
+ NM_DBUS_INTERFACE_SECRET_AGENT,
+ NM_TYPE_SECRET_AGENT_ERROR);
}
static void
#include "nm-utils.h"
#include "nm-object-private.h"
#include "nm-active-connection.h"
+#include "nm-dbus-helpers.h"
+
+#include "nmdbus-vpn-connection.h"
G_DEFINE_TYPE (NMVpnConnection, nm_vpn_connection, NM_TYPE_ACTIVE_CONNECTION)
}
static void
-vpn_state_changed_proxy (DBusGProxy *proxy,
- NMVpnConnectionState vpn_state,
- NMVpnConnectionStateReason reason,
+vpn_state_changed_proxy (NMDBusVpnConnection *proxy,
+ guint vpn_state,
+ guint reason,
gpointer user_data)
{
NMVpnConnection *connection = NM_VPN_CONNECTION (user_data);
{ NM_VPN_CONNECTION_VPN_STATE, &priv->vpn_state },
{ NULL },
};
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
NM_OBJECT_CLASS (nm_vpn_connection_parent_class)->init_dbus (object);
property_info);
proxy = _nm_object_get_proxy (object, NM_DBUS_INTERFACE_VPN_CONNECTION);
- dbus_g_object_register_marshaller (g_cclosure_marshal_generic,
- G_TYPE_NONE,
- G_TYPE_UINT, G_TYPE_UINT,
- G_TYPE_INVALID);
- dbus_g_proxy_add_signal (proxy, "VpnStateChanged", G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID);
- dbus_g_proxy_connect_signal (proxy,
- "VpnStateChanged",
- G_CALLBACK (vpn_state_changed_proxy),
- object,
- NULL);
+ g_signal_connect (proxy, "vpn-state-changed",
+ G_CALLBACK (vpn_state_changed_proxy), object);
}
static void
g_type_class_add_private (connection_class, sizeof (NMVpnConnectionPrivate));
_nm_object_class_add_interface (nm_object_class, NM_DBUS_INTERFACE_VPN_CONNECTION);
+ _nm_dbus_register_proxy_type (NM_DBUS_INTERFACE_VPN_CONNECTION,
+ NMDBUS_TYPE_VPN_CONNECTION_PROXY);
/* virtual methods */
object_class->get_property = get_property;
#include "nm-vpn-plugin-utils.h"
#include "nm-vpn-plugin.h"
#include "nm-core-internal.h"
-#include "nm-dbus-glib-types.h"
#define DATA_KEY_TAG "DATA_KEY="
#define DATA_VAL_TAG "DATA_VAL="
#include "nm-vpn-plugin.h"
#include "nm-enum-types.h"
#include "nm-utils.h"
-#include "nm-dbus-glib-types.h"
-#include "nm-utils-private.h"
#include "nm-connection.h"
+#include "nm-dbus-helpers.h"
-static gboolean impl_vpn_plugin_connect (NMVpnPlugin *plugin,
- GHashTable *connection,
- GError **error);
-
-static gboolean impl_vpn_plugin_connect_interactive (NMVpnPlugin *plugin,
- GHashTable *connection,
- GHashTable *details,
- GError **error);
-
-static gboolean impl_vpn_plugin_need_secrets (NMVpnPlugin *plugin,
- GHashTable *connection,
- char **service_name,
- GError **err);
-
-static gboolean impl_vpn_plugin_new_secrets (NMVpnPlugin *plugin,
- GHashTable *connection,
- GError **err);
-
-static gboolean impl_vpn_plugin_disconnect (NMVpnPlugin *plugin,
- GError **err);
-
-static gboolean impl_vpn_plugin_set_config (NMVpnPlugin *plugin,
- GHashTable *config,
- GError **err);
-
-static gboolean impl_vpn_plugin_set_ip4_config (NMVpnPlugin *plugin,
- GHashTable *config,
- GError **err);
-
-static gboolean impl_vpn_plugin_set_ip6_config (NMVpnPlugin *plugin,
- GHashTable *config,
- GError **err);
-
-static gboolean impl_vpn_plugin_set_failure (NMVpnPlugin *plugin,
- char *reason,
- GError **err);
-
-#include "nm-vpn-plugin-glue.h"
+#include "nmdbus-vpn-plugin.h"
#define NM_VPN_PLUGIN_QUIT_TIMER 20
NMVpnServiceState state;
/* DBUS-y stuff */
- DBusGConnection *connection;
+ GDBusConnection *connection;
+ NMDBusVpnPlugin *dbus_vpn_plugin;
char *dbus_service_name;
/* Temporary stuff */
gboolean has_ip6, got_ip6;
/* Config stuff copied from config to ip4config */
- GValue banner, tundev, gateway, mtu;
+ char *banner, *tundev, *gateway, *mtu;
} NMVpnPluginPrivate;
#define NM_VPN_PLUGIN_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_VPN_PLUGIN, NMVpnPluginPrivate))
static void
nm_vpn_plugin_set_connection (NMVpnPlugin *plugin,
- DBusGConnection *connection)
+ GDBusConnection *connection)
{
NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin);
- if (priv->connection)
- dbus_g_connection_unref (priv->connection);
+ g_clear_object (&priv->connection);
- priv->connection = connection;
+ priv->connection = g_object_ref (connection);
}
-DBusGConnection *
+/**
+ * nm_vpn_plugin_get_connection:
+ *
+ * Returns: (transfer full):
+ */
+GDBusConnection *
nm_vpn_plugin_get_connection (NMVpnPlugin *plugin)
{
- DBusGConnection *connection;
+ GDBusConnection *connection;
g_return_val_if_fail (NM_IS_VPN_PLUGIN (plugin), NULL);
connection = NM_VPN_PLUGIN_GET_PRIVATE (plugin)->connection;
if (connection)
- dbus_g_connection_ref (connection);
+ g_object_ref (connection);
return connection;
}
priv->fail_stop_id = g_idle_add (fail_stop, plugin);
}
-static void
-_g_value_set (GValue *dst, GValue *src)
-{
- if (src) {
- GType type = G_VALUE_TYPE (src);
-
- if (G_IS_VALUE (dst))
- g_value_unset (dst);
- g_value_init (dst, type);
- g_value_copy (src, dst);
- } else if (G_IS_VALUE (dst))
- g_value_unset (dst);
-}
-
void
nm_vpn_plugin_set_config (NMVpnPlugin *plugin,
- GHashTable *config)
+ GVariant *config)
{
NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin);
- GValue *val;
g_return_if_fail (NM_IS_VPN_PLUGIN (plugin));
g_return_if_fail (config != NULL);
priv->got_config = TRUE;
- val = g_hash_table_lookup (config, NM_VPN_PLUGIN_CONFIG_HAS_IP4);
- if (val && g_value_get_boolean (val))
- priv->has_ip4 = TRUE;
- val = g_hash_table_lookup (config, NM_VPN_PLUGIN_CONFIG_HAS_IP6);
- if (val && g_value_get_boolean (val))
- priv->has_ip6 = TRUE;
+ g_variant_lookup (config, NM_VPN_PLUGIN_CONFIG_HAS_IP4, "b", &priv->has_ip4);
+ g_variant_lookup (config, NM_VPN_PLUGIN_CONFIG_HAS_IP6, "b", &priv->has_ip6);
g_warn_if_fail (priv->has_ip4 || priv->has_ip6);
/* Record the items that need to also be inserted into the
* ip4config, for compatibility with older daemons.
*/
- _g_value_set (&priv->banner, g_hash_table_lookup (config, NM_VPN_PLUGIN_CONFIG_BANNER));
- _g_value_set (&priv->tundev, g_hash_table_lookup (config, NM_VPN_PLUGIN_CONFIG_TUNDEV));
- _g_value_set (&priv->gateway, g_hash_table_lookup (config, NM_VPN_PLUGIN_CONFIG_EXT_GATEWAY));
- _g_value_set (&priv->mtu, g_hash_table_lookup (config, NM_VPN_PLUGIN_CONFIG_MTU));
+ g_clear_pointer (&priv->banner, g_free);
+ g_variant_lookup (config, NM_VPN_PLUGIN_CONFIG_BANNER, "&s", &priv->banner);
+ g_clear_pointer (&priv->tundev, g_free);
+ g_variant_lookup (config, NM_VPN_PLUGIN_CONFIG_TUNDEV, "&s", &priv->tundev);
+ g_clear_pointer (&priv->gateway, g_free);
+ g_variant_lookup (config, NM_VPN_PLUGIN_CONFIG_EXT_GATEWAY, "&s", &priv->gateway);
+ g_clear_pointer (&priv->mtu, g_free);
+ g_variant_lookup (config, NM_VPN_PLUGIN_CONFIG_MTU, "&s", &priv->mtu);
g_signal_emit (plugin, signals[CONFIG], 0, config);
}
void
nm_vpn_plugin_set_ip4_config (NMVpnPlugin *plugin,
- GHashTable *ip4_config)
+ GVariant *ip4_config)
{
NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin);
- GHashTable *combined_config;
- GHashTableIter iter;
- gpointer key, value;
+ GVariant *combined_config;
+ GVariantBuilder builder;
+ GVariantIter iter;
+ const char *key, *value;
g_return_if_fail (NM_IS_VPN_PLUGIN (plugin));
g_return_if_fail (ip4_config != NULL);
* being emitted. So just copy all of that data into the ip4
* config too.
*/
- combined_config = g_hash_table_new (g_str_hash, g_str_equal);
- g_hash_table_iter_init (&iter, ip4_config);
- while (g_hash_table_iter_next (&iter, &key, &value))
- g_hash_table_insert (combined_config, key, value);
-
- if (G_VALUE_TYPE (&priv->banner) != G_TYPE_INVALID)
- g_hash_table_insert (combined_config, NM_VPN_PLUGIN_IP4_CONFIG_BANNER, &priv->banner);
- if (G_VALUE_TYPE (&priv->tundev) != G_TYPE_INVALID)
- g_hash_table_insert (combined_config, NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV, &priv->tundev);
- if (G_VALUE_TYPE (&priv->gateway) != G_TYPE_INVALID)
- g_hash_table_insert (combined_config, NM_VPN_PLUGIN_IP4_CONFIG_EXT_GATEWAY, &priv->gateway);
- if (G_VALUE_TYPE (&priv->mtu) != G_TYPE_INVALID)
- g_hash_table_insert (combined_config, NM_VPN_PLUGIN_IP4_CONFIG_MTU, &priv->mtu);
-
+ g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{ss}"));
+ g_variant_iter_init (&iter, ip4_config);
+ while (g_variant_iter_next (&iter, "{&s&s}", &key, &value))
+ g_variant_builder_add (&builder, "{ss}", key, value);
+
+ if (priv->banner)
+ g_variant_builder_add (&builder, "{ss}", NM_VPN_PLUGIN_IP4_CONFIG_BANNER, &priv->banner);
+ if (priv->tundev)
+ g_variant_builder_add (&builder, "{ss}", NM_VPN_PLUGIN_IP4_CONFIG_TUNDEV, &priv->tundev);
+ if (priv->gateway)
+ g_variant_builder_add (&builder, "{ss}", NM_VPN_PLUGIN_IP4_CONFIG_EXT_GATEWAY, &priv->gateway);
+ if (priv->mtu)
+ g_variant_builder_add (&builder, "{ss}", NM_VPN_PLUGIN_IP4_CONFIG_MTU, &priv->mtu);
+
+ combined_config = g_variant_builder_end (&builder);
+ g_variant_ref_sink (combined_config);
g_signal_emit (plugin, signals[IP4_CONFIG], 0, combined_config);
- g_hash_table_destroy (combined_config);
+ g_variant_unref (combined_config);
if ( priv->has_ip4 == priv->got_ip4
&& priv->has_ip6 == priv->got_ip6)
void
nm_vpn_plugin_set_ip6_config (NMVpnPlugin *plugin,
- GHashTable *ip6_config)
+ GVariant *ip6_config)
{
NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin);
connect_timer_removed);
}
-static gboolean
+static void
_connect_generic (NMVpnPlugin *plugin,
- GHashTable *properties,
- GHashTable *details,
- GError **error)
+ GDBusMethodInvocation *context,
+ GVariant *properties,
+ GVariant *details)
{
NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin);
NMVpnPluginClass *vpn_class = NM_VPN_PLUGIN_GET_CLASS (plugin);
- GVariant *properties_dict;
NMConnection *connection;
gboolean success = FALSE;
- GError *local = NULL;
+ GError *error = NULL;
if (priv->state != NM_VPN_SERVICE_STATE_STOPPED &&
priv->state != NM_VPN_SERVICE_STATE_INIT) {
- g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_WRONG_STATE,
- "Could not start connection: wrong plugin state %d",
- priv->state);
- return FALSE;
+ g_dbus_method_invocation_return_error (context,
+ NM_VPN_PLUGIN_ERROR,
+ NM_VPN_PLUGIN_ERROR_WRONG_STATE,
+ "Could not start connection: wrong plugin state %d",
+ priv->state);
+ return;
}
- properties_dict = _nm_utils_connection_hash_to_dict (properties);
- connection = nm_simple_connection_new_from_dbus (properties_dict, &local);
- g_variant_unref (properties_dict);
+ connection = nm_simple_connection_new_from_dbus (properties, &error);
if (!connection) {
- g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
- "Invalid connection: (%d) %s",
- local->code, local->message);
- g_clear_error (&local);
- return FALSE;
+ g_dbus_method_invocation_return_error (context,
+ NM_VPN_PLUGIN_ERROR,
+ NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
+ "Invalid connection: (%d) %s",
+ error->code, error->message);
+ g_clear_error (&error);
}
-
priv->interactive = FALSE;
if (details && !vpn_class->connect_interactive) {
- g_set_error_literal (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_INTERACTIVE_NOT_SUPPORTED,
- "Plugin does not implement ConnectInteractive()");
- return FALSE;
+ g_dbus_method_invocation_return_error (context,
+ NM_VPN_PLUGIN_ERROR,
+ NM_VPN_PLUGIN_ERROR_INTERACTIVE_NOT_SUPPORTED,
+ "Plugin does not implement ConnectInteractive()");
+ return;
}
nm_vpn_plugin_set_state (plugin, NM_VPN_SERVICE_STATE_STARTING);
if (details) {
priv->interactive = TRUE;
- success = vpn_class->connect_interactive (plugin, connection, details, error);
+ success = vpn_class->connect_interactive (plugin, connection, details, &error);
} else
- success = vpn_class->connect (plugin, connection, error);
+ success = vpn_class->connect (plugin, connection, &error);
if (success) {
+ g_dbus_method_invocation_return_value (context, NULL);
+
/* Add a timer to make sure we do not wait indefinitely for the successful connect. */
connect_timer_start (plugin);
} else {
+ g_dbus_method_invocation_take_error (context, error);
+
/* Stop the plugin from an idle handler so that the Connect
* method return gets sent before the STOP StateChanged signal.
*/
}
g_object_unref (connection);
- return success;
}
-static gboolean
+static void
impl_vpn_plugin_connect (NMVpnPlugin *plugin,
- GHashTable *connection,
- GError **error)
+ GDBusMethodInvocation *context,
+ GVariant *connection,
+ gpointer user_data)
{
- return _connect_generic (plugin, connection, NULL, error);
+ _connect_generic (plugin, context, connection, NULL);
}
-static gboolean
+static void
impl_vpn_plugin_connect_interactive (NMVpnPlugin *plugin,
- GHashTable *connection,
- GHashTable *details,
- GError **error)
+ GDBusMethodInvocation *context,
+ GVariant *connection,
+ GVariant *details,
+ gpointer user_data)
{
- return _connect_generic (plugin, connection, details, error);
+ _connect_generic (plugin, context, connection, details);
}
/***************************************************************/
-static gboolean
+static void
impl_vpn_plugin_need_secrets (NMVpnPlugin *plugin,
- GHashTable *properties,
- char **setting_name,
- GError **err)
+ GDBusMethodInvocation *context,
+ GVariant *properties,
+ gpointer user_data)
{
- gboolean ret = FALSE;
- GVariant *properties_dict;
NMConnection *connection;
- char *sn = NULL;
- GError *ns_err = NULL;
- gboolean needed = FALSE;
- GError *cnfh_err = NULL;
-
- g_return_val_if_fail (NM_IS_VPN_PLUGIN (plugin), FALSE);
- g_return_val_if_fail (properties != NULL, FALSE);
+ char *setting_name;
+ gboolean needed;
+ GError *error = NULL;
- properties_dict = _nm_utils_connection_hash_to_dict (properties);
- connection = nm_simple_connection_new_from_dbus (properties_dict, &cnfh_err);
- g_variant_unref (properties_dict);
+ connection = nm_simple_connection_new_from_dbus (properties, &error);
if (!connection) {
- g_set_error (err,
- NM_VPN_PLUGIN_ERROR,
- NM_VPN_PLUGIN_ERROR_CONNECTION_INVALID,
- "The connection was invalid: '%s' / '%s' invalid: %d.",
- g_type_name (nm_setting_lookup_type_by_quark (cnfh_err->domain)),
- cnfh_err->message, cnfh_err->code);
- g_error_free (cnfh_err);
- return FALSE;
+ g_dbus_method_invocation_return_error (context,
+ NM_VPN_PLUGIN_ERROR,
+ NM_VPN_PLUGIN_ERROR_CONNECTION_INVALID,
+ "The connection was invalid: '%s' / '%s' invalid: %d.",
+ g_type_name (nm_setting_lookup_type_by_quark (error->domain)),
+ error->message, error->code);
+ g_error_free (error);
+ return;
}
if (!NM_VPN_PLUGIN_GET_CLASS (plugin)->need_secrets) {
- *setting_name = "";
- ret = TRUE;
- goto out;
+ g_dbus_method_invocation_return_value (context,
+ g_variant_new ("(s)", ""));
+ return;
}
- needed = NM_VPN_PLUGIN_GET_CLASS (plugin)->need_secrets (plugin, connection, &sn, &ns_err);
- if (ns_err) {
- *err = g_error_copy (ns_err);
- g_error_free (ns_err);
- goto out;
+ needed = NM_VPN_PLUGIN_GET_CLASS (plugin)->need_secrets (plugin, connection, &setting_name, &error);
+ if (error) {
+ g_dbus_method_invocation_take_error (context, error);
+ return;
}
- ret = TRUE;
if (needed) {
- g_assert (sn);
- *setting_name = g_strdup (sn);
+ g_assert (setting_name);
+ g_dbus_method_invocation_return_value (context,
+ g_variant_new ("(s)", setting_name));
+ g_free (setting_name);
} else {
/* No secrets required */
- *setting_name = g_strdup ("");
+ g_dbus_method_invocation_return_value (context,
+ g_variant_new ("(s)", ""));
}
-
-out:
- return ret;
}
-static gboolean
+static void
impl_vpn_plugin_new_secrets (NMVpnPlugin *plugin,
- GHashTable *properties,
- GError **error)
+ GDBusMethodInvocation *context,
+ GVariant *properties,
+ gpointer user_data)
{
NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin);
- GVariant *properties_dict;
NMConnection *connection;
- GError *local = NULL;
+ GError *error = NULL;
gboolean success;
if (priv->state != NM_VPN_SERVICE_STATE_STARTING) {
- g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_WRONG_STATE,
- "Could not accept new secrets: wrong plugin state %d",
- priv->state);
- return FALSE;
+ g_dbus_method_invocation_return_error (context,
+ NM_VPN_PLUGIN_ERROR,
+ NM_VPN_PLUGIN_ERROR_WRONG_STATE,
+ "Could not accept new secrets: wrong plugin state %d",
+ priv->state);
+ return;
}
- properties_dict = _nm_utils_connection_hash_to_dict (properties);
- connection = nm_simple_connection_new_from_dbus (properties_dict, &local);
- g_variant_unref (properties_dict);
+ connection = nm_simple_connection_new_from_dbus (properties, &error);
if (!connection) {
- g_set_error (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
- "Invalid connection: (%d) %s",
- local->code, local->message);
- g_clear_error (&local);
- return FALSE;
+ g_dbus_method_invocation_return_error (context,
+ NM_VPN_PLUGIN_ERROR,
+ NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
+ "Invalid connection: (%d) %s",
+ error->code, error->message);
+ g_clear_error (&error);
+ return;
}
if (!NM_VPN_PLUGIN_GET_CLASS (plugin)->new_secrets) {
- g_set_error_literal (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_INTERACTIVE_NOT_SUPPORTED,
- "Could not accept new secrets: plugin cannot process interactive secrets");
+ g_dbus_method_invocation_return_error (context,
+ NM_VPN_PLUGIN_ERROR,
+ NM_VPN_PLUGIN_ERROR_INTERACTIVE_NOT_SUPPORTED,
+ "Could not accept new secrets: plugin cannot process interactive secrets");
g_object_unref (connection);
- return FALSE;
+ return;
}
- success = NM_VPN_PLUGIN_GET_CLASS (plugin)->new_secrets (plugin, connection, error);
+ success = NM_VPN_PLUGIN_GET_CLASS (plugin)->new_secrets (plugin, connection, &error);
if (success) {
+ g_dbus_method_invocation_return_value (context, NULL);
+
/* Add a timer to make sure we do not wait indefinitely for the successful connect. */
connect_timer_start (plugin);
} else {
+ g_dbus_method_invocation_take_error (context, error);
+
/* Stop the plugin from and idle handler so that the NewSecrets
* method return gets sent before the STOP StateChanged signal.
*/
}
g_object_unref (connection);
- return success;
}
/**
/***************************************************************/
-static gboolean
+static void
impl_vpn_plugin_disconnect (NMVpnPlugin *plugin,
- GError **err)
+ GDBusMethodInvocation *context,
+ gpointer user_data)
{
- return nm_vpn_plugin_disconnect (plugin, err);
+ GError *error = NULL;
+
+ if (nm_vpn_plugin_disconnect (plugin, &error))
+ g_dbus_method_invocation_return_value (context, NULL);
+ else
+ g_dbus_method_invocation_take_error (context, error);
}
-static gboolean
+static void
impl_vpn_plugin_set_config (NMVpnPlugin *plugin,
- GHashTable *config,
- GError **err)
+ GDBusMethodInvocation *context,
+ GVariant *config,
+ gpointer user_data)
{
nm_vpn_plugin_set_config (plugin, config);
-
- return TRUE;
+ g_dbus_method_invocation_return_value (context, NULL);
}
-static gboolean
+static void
impl_vpn_plugin_set_ip4_config (NMVpnPlugin *plugin,
- GHashTable *config,
- GError **err)
+ GDBusMethodInvocation *context,
+ GVariant *config,
+ gpointer user_data)
{
nm_vpn_plugin_set_ip4_config (plugin, config);
-
- return TRUE;
+ g_dbus_method_invocation_return_value (context, NULL);
}
-static gboolean
+static void
impl_vpn_plugin_set_ip6_config (NMVpnPlugin *plugin,
- GHashTable *config,
- GError **err)
+ GDBusMethodInvocation *context,
+ GVariant *config,
+ gpointer user_data)
{
nm_vpn_plugin_set_ip6_config (plugin, config);
-
- return TRUE;
+ g_dbus_method_invocation_return_value (context, NULL);
}
-static gboolean
+static void
impl_vpn_plugin_set_failure (NMVpnPlugin *plugin,
+ GDBusMethodInvocation *context,
char *reason,
- GError **err)
+ gpointer user_data)
{
nm_vpn_plugin_failure (plugin, NM_VPN_PLUGIN_FAILURE_BAD_IP_CONFIG);
-
- return TRUE;
+ g_dbus_method_invocation_return_value (context, NULL);
}
/*********************************************************************/
static gboolean
init_sync (GInitable *initable, GCancellable *cancellable, GError **error)
{
- NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (initable);
- NMVpnPlugin *plugin;
- DBusGConnection *connection;
- DBusGProxy *proxy;
- guint request_name_result;
+ NMVpnPlugin *plugin = NM_VPN_PLUGIN (initable);
+ NMVpnPluginPrivate *priv = NM_VPN_PLUGIN_GET_PRIVATE (plugin);
+ GDBusConnection *connection = NULL;
+ GDBusProxy *proxy;
+ GVariant *ret;
+ gboolean success = FALSE;
if (!priv->dbus_service_name) {
g_set_error_literal (error, NM_VPN_PLUGIN_ERROR, NM_VPN_PLUGIN_ERROR_BAD_ARGUMENTS,
return FALSE;
}
- connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, error);
+ connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, error);
if (!connection)
return FALSE;
- proxy = dbus_g_proxy_new_for_name (connection,
- DBUS_SERVICE_DBUS,
- DBUS_PATH_DBUS,
- DBUS_INTERFACE_DBUS);
-
- if (!dbus_g_proxy_call (proxy, "RequestName", error,
- G_TYPE_STRING, priv->dbus_service_name,
- G_TYPE_UINT, 0,
- G_TYPE_INVALID,
- G_TYPE_UINT, &request_name_result,
- G_TYPE_INVALID)) {
- g_object_unref (proxy);
- return FALSE;
- }
+ proxy = g_dbus_proxy_new_sync (connection,
+ G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |
+ G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,
+ NULL,
+ DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ cancellable, error);
+ if (!proxy)
+ goto out;
+
+ ret = g_dbus_proxy_call_sync (proxy,
+ "RequestName",
+ g_variant_new ("(s)", priv->dbus_service_name),
+ G_DBUS_CALL_FLAGS_NONE, 0,
+ cancellable, error);
g_object_unref (proxy);
+ if (!ret)
+ goto out;
+ g_variant_unref (ret);
- dbus_g_connection_register_g_object (connection,
- NM_VPN_DBUS_PLUGIN_PATH,
- G_OBJECT (initable));
+ priv->dbus_vpn_plugin = nmdbus_vpn_plugin_skeleton_new ();
+ if (!g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (priv->dbus_vpn_plugin),
+ connection,
+ NM_VPN_DBUS_PLUGIN_PATH,
+ error))
+ goto out;
- plugin = NM_VPN_PLUGIN (initable);
+ _nm_dbus_bind_properties (plugin, priv->dbus_vpn_plugin);
+ _nm_dbus_bind_methods (plugin, priv->dbus_vpn_plugin,
+ "Connect", impl_vpn_plugin_connect,
+ "ConnectInteractive", impl_vpn_plugin_connect_interactive,
+ "NeedSecrets", impl_vpn_plugin_need_secrets,
+ "NewSecrets", impl_vpn_plugin_new_secrets,
+ "Disconnect", impl_vpn_plugin_disconnect,
+ "SetConfig", impl_vpn_plugin_set_config,
+ "SetIp4Config", impl_vpn_plugin_set_ip4_config,
+ "SetIp6Config", impl_vpn_plugin_set_ip6_config,
+ "SetFailure", impl_vpn_plugin_set_failure,
+ NULL);
nm_vpn_plugin_set_connection (plugin, connection);
nm_vpn_plugin_set_state (plugin, NM_VPN_SERVICE_STATE_INIT);
- return TRUE;
+ success = TRUE;
+
+ out:
+ g_clear_object (&connection);
+
+ return success;
}
static void
nm_vpn_plugin_set_connection (plugin, NULL);
g_free (priv->dbus_service_name);
- if (G_IS_VALUE (&priv->banner))
- g_value_unset (&priv->banner);
- if (G_IS_VALUE (&priv->tundev))
- g_value_unset (&priv->tundev);
- if (G_IS_VALUE (&priv->gateway))
- g_value_unset (&priv->gateway);
- if (G_IS_VALUE (&priv->mtu))
- g_value_unset (&priv->mtu);
+ g_clear_pointer (&priv->banner, g_free);
+ g_clear_pointer (&priv->tundev, g_free);
+ g_clear_pointer (&priv->gateway, g_free);
+ g_clear_pointer (&priv->mtu, g_free);
G_OBJECT_CLASS (nm_vpn_plugin_parent_class)->finalize (object);
}
g_type_class_add_private (object_class, sizeof (NMVpnPluginPrivate));
- dbus_g_object_type_install_info (G_TYPE_FROM_CLASS (plugin_class),
- &dbus_glib_nm_vpn_plugin_object_info);
-
/* virtual methods */
object_class->set_property = set_property;
object_class->get_property = get_property;
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMVpnPluginClass, state_changed),
NULL, NULL,
- g_cclosure_marshal_VOID__UINT,
+ NULL,
G_TYPE_NONE, 1,
G_TYPE_UINT);
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMVpnPluginClass, config),
NULL, NULL,
- g_cclosure_marshal_VOID__BOXED,
+ NULL,
G_TYPE_NONE, 1,
- DBUS_TYPE_G_MAP_OF_VARIANT);
+ G_TYPE_VARIANT);
signals[IP4_CONFIG] =
g_signal_new ("ip4-config",
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMVpnPluginClass, ip4_config),
NULL, NULL,
- g_cclosure_marshal_VOID__BOXED,
+ NULL,
G_TYPE_NONE, 1,
- DBUS_TYPE_G_MAP_OF_VARIANT);
+ G_TYPE_VARIANT);
signals[IP6_CONFIG] =
g_signal_new ("ip6-config",
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMVpnPluginClass, ip6_config),
NULL, NULL,
- g_cclosure_marshal_VOID__BOXED,
+ NULL,
G_TYPE_NONE, 1,
- DBUS_TYPE_G_MAP_OF_VARIANT);
+ G_TYPE_VARIANT);
signals[LOGIN_BANNER] =
g_signal_new ("login-banner",
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMVpnPluginClass, login_banner),
NULL, NULL,
- g_cclosure_marshal_VOID__STRING,
+ NULL,
G_TYPE_NONE, 1,
G_TYPE_STRING);
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMVpnPluginClass, failure),
NULL, NULL,
- g_cclosure_marshal_VOID__UINT,
+ NULL,
G_TYPE_NONE, 1,
G_TYPE_UINT);
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMVpnPluginClass, quit),
NULL, NULL,
- g_cclosure_marshal_VOID__VOID,
+ NULL,
G_TYPE_NONE, 0,
G_TYPE_NONE);
- dbus_g_error_domain_register (NM_VPN_PLUGIN_ERROR,
- NM_DBUS_VPN_ERROR_PREFIX,
- NM_TYPE_VPN_PLUGIN_ERROR);
+ _nm_dbus_register_error_domain (NM_VPN_PLUGIN_ERROR,
+ NM_DBUS_VPN_ERROR_PREFIX,
+ NM_TYPE_VPN_PLUGIN_ERROR);
setup_unix_signal_handler ();
}
#error "Only <NetworkManager.h> can be included directly."
#endif
-#include <glib.h>
-#include <glib-object.h>
-#include <dbus/dbus-glib.h>
+#include <gio/gio.h>
#include <nm-vpn-dbus-interface.h>
#include <nm-connection.h>
NMVpnServiceState state);
void (*ip4_config) (NMVpnPlugin *plugin,
- GHashTable *ip4_config);
+ GVariant *ip4_config);
void (*login_banner) (NMVpnPlugin *plugin,
const char *banner);
void (*quit) (NMVpnPlugin *plugin);
void (*config) (NMVpnPlugin *plugin,
- GHashTable *config);
+ GVariant *config);
void (*ip6_config) (NMVpnPlugin *plugin,
- GHashTable *config);
+ GVariant *config);
/* virtual methods */
gboolean (*connect) (NMVpnPlugin *plugin,
gboolean (*connect_interactive) (NMVpnPlugin *plugin,
NMConnection *connection,
- GHashTable *details,
+ GVariant *details,
GError **error);
/*< private >*/
GType nm_vpn_plugin_get_type (void);
GQuark nm_vpn_plugin_error_quark (void);
-DBusGConnection *nm_vpn_plugin_get_connection (NMVpnPlugin *plugin);
+GDBusConnection *nm_vpn_plugin_get_connection (NMVpnPlugin *plugin);
NMVpnServiceState nm_vpn_plugin_get_state (NMVpnPlugin *plugin);
void nm_vpn_plugin_set_state (NMVpnPlugin *plugin,
NMVpnServiceState state);
NMVpnPluginFailure reason);
void nm_vpn_plugin_set_config (NMVpnPlugin *plugin,
- GHashTable *config);
+ GVariant *config);
void nm_vpn_plugin_set_ip4_config (NMVpnPlugin *plugin,
- GHashTable *ip4_config);
+ GVariant *ip4_config);
void nm_vpn_plugin_set_ip6_config (NMVpnPlugin *plugin,
- GHashTable *ip6_config);
+ GVariant *ip6_config);
gboolean nm_vpn_plugin_disconnect (NMVpnPlugin *plugin,
GError **err);
-DNETWORKMANAGER_COMPILATION \
-DNM_VERSION_MAX_ALLOWED=NM_VERSION_NEXT_STABLE \
-DTEST_NM_SERVICE=\"$(abs_top_srcdir)/tools/test-networkmanager-service.py\" \
- $(GLIB_CFLAGS) \
- $(DBUS_CFLAGS)
+ $(GLIB_CFLAGS)
LDADD = \
$(top_builddir)/libnm/libnm.la \
- $(GLIB_LIBS) \
- $(DBUS_LIBS)
+ $(GLIB_LIBS)
noinst_PROGRAMS = $(TESTS)
gboolean exists = FALSE;
reply = g_dbus_connection_call_sync (c,
- DBUS_SERVICE_DBUS,
- DBUS_PATH_DBUS,
- DBUS_INTERFACE_DBUS,
+ "org.freedesktop.DBus",
+ "/org/freedesktop/DBus",
+ "org.freedesktop.DBus",
"GetNameOwner",
g_variant_new ("(s)", name),
NULL,
*
*/
-#include <dbus/dbus.h>
-#include <dbus/dbus-glib.h>
-#include <dbus/dbus-glib-lowlevel.h>
#include <glib.h>
#include <string.h>
#include <sys/types.h>
*
*/
-#include <dbus/dbus.h>
-#include <dbus/dbus-glib.h>
-#include <dbus/dbus-glib-lowlevel.h>
#include <glib.h>
#include <string.h>
#include <sys/types.h>
static NMTestServiceInfo *sinfo;
static NMRemoteSettings *settings = NULL;
-DBusGConnection *bus = NULL;
+GDBusConnection *bus = NULL;
NMRemoteConnection *remote = NULL;
/*******************************************************************/
/*******************************************************************/
static void
-set_visible_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+set_visible_cb (GObject *proxy,
+ GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
- gboolean success;
+ GVariant *ret;
- success = dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
+ ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, &error);
g_assert_no_error (error);
- g_assert (success == TRUE);
+ g_variant_unref (ret);
}
static void
{
time_t start, now;
GSList *list, *iter;
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
gboolean visible_changed = FALSE, connection_removed = FALSE;
gboolean has_settings = FALSE;
char *path;
g_signal_connect (settings, "connection-removed", G_CALLBACK (connection_removed_cb), &connection_removed);
path = g_strdup (nm_connection_get_path (NM_CONNECTION (remote)));
- proxy = dbus_g_proxy_new_for_name (bus,
- NM_DBUS_SERVICE,
- path,
- NM_DBUS_INTERFACE_SETTINGS_CONNECTION);
+ proxy = g_dbus_proxy_new_sync (bus,
+ G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
+ NULL,
+ NM_DBUS_SERVICE,
+ path,
+ NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+ NULL,
+ NULL);
g_assert (proxy != NULL);
/* Bypass the NMRemoteSettings object so we can test it independently */
- dbus_g_proxy_begin_call (proxy, "SetVisible", set_visible_cb, NULL, NULL,
- G_TYPE_BOOLEAN, FALSE, G_TYPE_INVALID);
+ g_dbus_proxy_call (proxy,
+ "SetVisible",
+ g_variant_new ("(b)", FALSE),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL,
+ set_visible_cb, NULL);
/* Wait for the connection to be removed */
start = time (NULL);
{
time_t start, now;
GSList *list, *iter;
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
gboolean found = FALSE;
char *path;
NMRemoteConnection *new = NULL;
G_CALLBACK (vis_new_connection_cb), &new);
path = g_strdup (nm_connection_get_path (NM_CONNECTION (remote)));
- proxy = dbus_g_proxy_new_for_name (bus,
- NM_DBUS_SERVICE,
- path,
- NM_DBUS_INTERFACE_SETTINGS_CONNECTION);
+ proxy = g_dbus_proxy_new_sync (bus,
+ G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
+ NULL,
+ NM_DBUS_SERVICE,
+ path,
+ NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+ NULL,
+ NULL);
g_assert (proxy != NULL);
/* Bypass the NMRemoteSettings object so we can test it independently */
- dbus_g_proxy_begin_call (proxy, "SetVisible", set_visible_cb, NULL, NULL,
- G_TYPE_BOOLEAN, TRUE, G_TYPE_INVALID);
-
+ g_dbus_proxy_call (proxy,
+ "SetVisible",
+ g_variant_new ("(b)", TRUE),
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL,
+ set_visible_cb, NULL);
/* Wait for the settings service to announce the connection again */
start = time (NULL);
/*******************************************************************/
static void
-deleted_cb (DBusGProxy *proxy,
- DBusGProxyCall *call,
+deleted_cb (GObject *proxy,
+ GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
- gboolean success;
+ GVariant *ret;
- success = dbus_g_proxy_end_call (proxy, call, &error, G_TYPE_INVALID);
+ ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), result, &error);
g_assert_no_error (error);
- g_assert (success == TRUE);
+ g_variant_unref (ret);
}
static void
NMRemoteConnection *connection;
time_t start, now;
GSList *list, *iter;
- DBusGProxy *proxy;
+ GDBusProxy *proxy;
gboolean done = FALSE;
char *path;
path = g_strdup (nm_connection_get_path (NM_CONNECTION (connection)));
g_signal_connect (settings, "connection-removed", G_CALLBACK (removed_cb), &done);
- proxy = dbus_g_proxy_new_for_name (bus,
- NM_DBUS_SERVICE,
- path,
- NM_DBUS_INTERFACE_SETTINGS_CONNECTION);
+ proxy = g_dbus_proxy_new_sync (bus,
+ G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
+ NULL,
+ NM_DBUS_SERVICE,
+ path,
+ NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+ NULL,
+ NULL);
g_assert (proxy != NULL);
/* Bypass the NMRemoteSettings object so we can test it independently */
- dbus_g_proxy_begin_call (proxy, "Delete", deleted_cb, NULL, NULL, G_TYPE_INVALID);
+ g_dbus_proxy_call (proxy,
+ "Delete",
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE, -1,
+ NULL,
+ deleted_cb, NULL);
start = time (NULL);
do {
g_test_init (&argc, &argv, NULL);
- bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
+ bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
g_assert_no_error (error);
sinfo = nm_test_service_init ();
nm_test_service_cleanup (sinfo);
g_object_unref (settings);
- dbus_g_connection_unref (bus);
+ g_object_unref (bus);
return ret;
}
TestSecretAgentData *sadata = user_data;
g_assert (error != NULL);
+ g_dbus_error_strip_remote_error (error);
g_assert_cmpstr (error->message, ==, "No secret agent available");
g_main_loop_quit (sadata->loop);
TestSecretAgentData *sadata = user_data;
g_assert (error != NULL);
+ g_dbus_error_strip_remote_error (error);
g_assert_cmpstr (error->message, ==, "No secrets provided");
g_main_loop_quit (sadata->loop);
TestSecretAgentData *sadata = user_data;
g_assert (error != NULL);
+ g_dbus_error_strip_remote_error (error);
g_assert_cmpstr (error->message, ==, "User canceled");
g_main_loop_quit (sadata->loop);
* other tests won't get to).
*/
g_assert (error != NULL);
+ g_dbus_error_strip_remote_error (error);
g_assert_cmpstr (error->message, ==, "Not yet implemented");
g_main_loop_quit (sadata->loop);
#include "nm-setting-wireless-security.h"
#include "nm-manager-auth.h"
#include "nm-posix-signals.h"
+#include "nm-dbus-glib-types.h"
/*
* Some toolchains (E.G. uClibc 0.9.33 and earlier) don't export
memcpy (iid, addr->s6_addr + 8, 8);
}
+/**
+ * nm_utils_connection_hash_to_dict:
+ * @hash: a hashed #NMConnection
+ *
+ * Returns: a (floating) #GVariant equivalent to @hash.
+ */
+GVariant *
+nm_utils_connection_hash_to_dict (GHashTable *hash)
+{
+ GValue val = { 0, };
+ GVariant *variant;
+
+ if (!hash)
+ return NULL;
+
+ g_value_init (&val, DBUS_TYPE_G_MAP_OF_MAP_OF_VARIANT);
+ g_value_set_boxed (&val, hash);
+ variant = dbus_g_value_build_g_variant (&val);
+ g_value_unset (&val);
+
+ return variant;
+}
+
+/**
+ * nm_utils_connection_dict_to_hash:
+ * @dict: a #GVariant-serialized #NMConnection
+ *
+ * Returns: a #GHashTable equivalent to @dict.
+ */
+GHashTable *
+nm_utils_connection_dict_to_hash (GVariant *dict)
+{
+ GValue val = { 0, };
+
+ if (!dict)
+ return NULL;
+
+ dbus_g_value_parse_g_variant (dict, &val);
+ return g_value_get_boxed (&val);
+}
+
+GSList *
+nm_utils_ip4_routes_from_gvalue (const GValue *value)
+{
+ GPtrArray *routes;
+ int i;
+ GSList *list = NULL;
+
+ routes = (GPtrArray *) g_value_get_boxed (value);
+ for (i = 0; routes && (i < routes->len); i++) {
+ GArray *array = (GArray *) g_ptr_array_index (routes, i);
+ NMIP4Route *route;
+
+ if (array->len < 4) {
+ g_warning ("Ignoring invalid IP4 route");
+ continue;
+ }
+
+ route = nm_ip4_route_new ();
+ nm_ip4_route_set_dest (route, g_array_index (array, guint32, 0));
+ nm_ip4_route_set_prefix (route, g_array_index (array, guint32, 1));
+ nm_ip4_route_set_next_hop (route, g_array_index (array, guint32, 2));
+ nm_ip4_route_set_metric (route, g_array_index (array, guint32, 3));
+ list = g_slist_prepend (list, route);
+ }
+
+ return g_slist_reverse (list);
+}
+
+static gboolean
+_nm_utils_gvalue_array_validate (GValueArray *elements, guint n_expected, ...)
+{
+ va_list args;
+ GValue *tmp;
+ int i;
+ gboolean valid = FALSE;
+
+ if (n_expected != elements->n_values)
+ return FALSE;
+
+ va_start (args, n_expected);
+ for (i = 0; i < n_expected; i++) {
+ tmp = g_value_array_get_nth (elements, i);
+ if (G_VALUE_TYPE (tmp) != va_arg (args, GType))
+ goto done;
+ }
+ valid = TRUE;
+
+done:
+ va_end (args);
+ return valid;
+}
+
+GSList *
+nm_utils_ip6_routes_from_gvalue (const GValue *value)
+{
+ GPtrArray *routes;
+ int i;
+ GSList *list = NULL;
+
+ routes = (GPtrArray *) g_value_get_boxed (value);
+ for (i = 0; routes && (i < routes->len); i++) {
+ GValueArray *route_values = (GValueArray *) g_ptr_array_index (routes, i);
+ GByteArray *dest, *next_hop;
+ guint prefix, metric;
+ NMIP6Route *route;
+
+ if (!_nm_utils_gvalue_array_validate (route_values, 4,
+ DBUS_TYPE_G_UCHAR_ARRAY,
+ G_TYPE_UINT,
+ DBUS_TYPE_G_UCHAR_ARRAY,
+ G_TYPE_UINT)) {
+ g_warning ("Ignoring invalid IP6 route");
+ continue;
+ }
+
+ dest = g_value_get_boxed (g_value_array_get_nth (route_values, 0));
+ if (dest->len != 16) {
+ g_warning ("%s: ignoring invalid IP6 dest address of length %d",
+ __func__, dest->len);
+ continue;
+ }
+
+ prefix = g_value_get_uint (g_value_array_get_nth (route_values, 1));
+
+ next_hop = g_value_get_boxed (g_value_array_get_nth (route_values, 2));
+ if (next_hop->len != 16) {
+ g_warning ("%s: ignoring invalid IP6 next_hop address of length %d",
+ __func__, next_hop->len);
+ continue;
+ }
+
+ metric = g_value_get_uint (g_value_array_get_nth (route_values, 3));
+
+ route = nm_ip6_route_new ();
+ nm_ip6_route_set_dest (route, (struct in6_addr *)dest->data);
+ nm_ip6_route_set_prefix (route, prefix);
+ nm_ip6_route_set_next_hop (route, (struct in6_addr *)next_hop->data);
+ nm_ip6_route_set_metric (route, metric);
+ list = g_slist_prepend (list, route);
+ }
+
+ return g_slist_reverse (list);
+}
void nm_utils_ipv6_interface_identfier_get_from_addr (NMUtilsIPv6IfaceId *iid,
const struct in6_addr *addr);
+GVariant *nm_utils_connection_hash_to_dict (GHashTable *hash);
+GHashTable *nm_utils_connection_dict_to_hash (GVariant *dict);
+
+GSList *nm_utils_ip4_routes_from_gvalue (const GValue *value);
+GSList *nm_utils_ip6_routes_from_gvalue (const GValue *value);
+
#endif /* __NETWORKMANAGER_UTILS_H__ */
#include "nm-dispatcher-api.h"
#include "NetworkManagerUtils.h"
#include "nm-utils.h"
-#include "nm-utils-private.h"
#include "nm-logging.h"
#include "nm-dbus-manager.h"
#include "nm-device.h"
GVariant *connection_dict;
connection_dict = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_NO_SECRETS);
- connection_hash = _nm_utils_connection_dict_to_hash (connection_dict);
+ connection_hash = nm_utils_connection_dict_to_hash (connection_dict);
g_variant_unref (connection_dict);
connection_props = value_hash_create ();
#include "nm-manager-auth.h"
#include "NetworkManagerUtils.h"
#include "nm-utils.h"
-#include "nm-utils-private.h"
#include "nm-device-factory.h"
#include "nm-enum-types.h"
#include "nm-sleep-monitor.h"
*/
connection = nm_simple_connection_new ();
if (settings && g_hash_table_size (settings)) {
- GVariant *settings_dict = _nm_utils_connection_hash_to_dict (settings);
+ GVariant *settings_dict = nm_utils_connection_hash_to_dict (settings);
nm_connection_replace_settings (connection, settings_dict, NULL);
g_variant_unref (settings_dict);
#include "nm-dbus-manager.h"
#include "nm-session-monitor.h"
#include "nm-simple-connection.h"
-#include "nm-utils-private.h"
+#include "NetworkManagerUtils.h"
G_DEFINE_TYPE (NMAgentManager, nm_agent_manager, G_TYPE_OBJECT)
if (req->existing_secrets) {
GVariant *secrets_dict;
- secrets_dict = _nm_utils_connection_hash_to_dict (req->existing_secrets);
+ secrets_dict = nm_utils_connection_hash_to_dict (req->existing_secrets);
(void) nm_connection_update_secrets (tmp, req->setting_name, secrets_dict, NULL);
g_variant_unref (secrets_dict);
}
tmp = nm_simple_connection_new_clone (req->connection);
g_assert (tmp);
- secrets_dict = _nm_utils_connection_hash_to_dict (req->existing_secrets);
+ secrets_dict = nm_utils_connection_hash_to_dict (req->existing_secrets);
if (!nm_connection_update_secrets (tmp, req->setting_name, secrets_dict, &error)) {
req_complete_error (parent, error);
g_clear_error (&error);
#include "nm-logging.h"
#include "nm-auth-subject.h"
#include "nm-simple-connection.h"
-#include "nm-utils-private.h"
+#include "NetworkManagerUtils.h"
G_DEFINE_TYPE (NMSecretAgent, nm_secret_agent, G_TYPE_OBJECT)
g_return_val_if_fail (priv->proxy != NULL, NULL);
dict = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
- hash = _nm_utils_connection_dict_to_hash (dict);
+ hash = nm_utils_connection_dict_to_hash (dict);
g_variant_unref (dict);
/* Mask off the private ONLY_SYSTEM flag if present */
const char *cpath = nm_connection_get_path (connection);
dict = nm_connection_to_dbus (connection, flags);
- hash = _nm_utils_connection_dict_to_hash (dict);
+ hash = nm_utils_connection_dict_to_hash (dict);
g_variant_unref (dict);
r = request_new (self, cpath, NULL, callback, callback_data);
#include <nm-setting-vpn.h>
#include <nm-setting-wireless.h>
#include <nm-utils.h>
-#include "nm-core-internal.h"
#include "nm-settings-connection.h"
#include "nm-session-monitor.h"
* will have been authenticated, so those secrets can replace the existing
* system secrets.
*/
- secrets_dict = _nm_utils_connection_hash_to_dict (secrets);
+ secrets_dict = nm_utils_connection_hash_to_dict (secrets);
if (nm_connection_update_secrets (NM_CONNECTION (self), setting_name, secrets_dict, &local)) {
/* Now that all secrets are updated, copy and cache new secrets,
* then save them to backing storage.
}
existing_secrets = nm_connection_to_dbus (priv->system_secrets, NM_CONNECTION_SERIALIZE_ONLY_SECRETS);
- existing_secrets_hash = _nm_utils_connection_dict_to_hash (existing_secrets);
+ existing_secrets_hash = nm_utils_connection_dict_to_hash (existing_secrets);
call_id = nm_agent_manager_get_secrets (priv->agent_mgr,
NM_CONNECTION (self),
subject,
*/
settings = nm_connection_to_dbus (NM_CONNECTION (dupl_con), NM_CONNECTION_SERIALIZE_NO_SECRETS);
g_assert (settings);
- settings_hash = _nm_utils_connection_dict_to_hash (settings);
+ settings_hash = nm_utils_connection_dict_to_hash (settings);
dbus_g_method_return (context, settings_hash);
g_hash_table_destroy (settings_hash);
g_variant_unref (settings);
/* Check if the settings are valid first */
if (new_settings) {
- GVariant *new_settings_dict = _nm_utils_connection_hash_to_dict (new_settings);
+ GVariant *new_settings_dict = nm_utils_connection_hash_to_dict (new_settings);
tmp = nm_simple_connection_new_from_dbus (new_settings_dict, &error);
g_variant_unref (new_settings_dict);
*/
dict = nm_connection_to_dbus (NM_CONNECTION (self), NM_CONNECTION_SERIALIZE_ONLY_SECRETS);
if (dict)
- hash = _nm_utils_connection_dict_to_hash (dict);
+ hash = nm_utils_connection_dict_to_hash (dict);
else
hash = g_hash_table_new (NULL, NULL);
dbus_g_method_return (context, hash);
GVariant *dict;
GError *error = NULL;
- dict = _nm_utils_connection_hash_to_dict (settings);
+ dict = nm_utils_connection_hash_to_dict (settings);
connection = nm_simple_connection_new_from_dbus (dict, &error);
g_variant_unref (dict);
if (connection) {
#include "nm-platform.h"
#include "nm-logging.h"
#include "nm-utils.h"
-#include "nm-utils-private.h"
#include "nm-active-connection.h"
#include "nm-dbus-glib-types.h"
#include "NetworkManagerUtils.h"
existing = nm_setting_vpn_get_user_name (s_vpn);
if (username == NULL || existing) {
dict = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
- hash = _nm_utils_connection_dict_to_hash (dict);
+ hash = nm_utils_connection_dict_to_hash (dict);
g_variant_unref (dict);
return hash;
}
dict = nm_connection_to_dbus (dup, NM_CONNECTION_SERIALIZE_ALL);
g_object_unref (dup);
- hash = _nm_utils_connection_dict_to_hash (dict);
+ hash = nm_utils_connection_dict_to_hash (dict);
g_variant_unref (dict);
return hash;
}
projects / NetworkManager.git / commitdiff