summaryrefslogtreecommitdiff
path: root/libnm-core/nm-param-spec-dbus.c
diff options
context:
space:
mode:
Diffstat (limited to 'libnm-core/nm-param-spec-dbus.c')
-rw-r--r--libnm-core/nm-param-spec-dbus.c584
1 files changed, 76 insertions, 508 deletions
diff --git a/libnm-core/nm-param-spec-dbus.c b/libnm-core/nm-param-spec-dbus.c
index 035a147c4f..7ce6d71201 100644
--- a/libnm-core/nm-param-spec-dbus.c
+++ b/libnm-core/nm-param-spec-dbus.c
@@ -23,487 +23,77 @@
#include <string.h>
#include <math.h>
#include <netinet/in.h>
-#include <dbus/dbus-glib.h>
+#include <gio/gio.h>
#include "nm-param-spec-dbus.h"
#include "nm-glib-compat.h"
-#include "nm-dbus-glib-types.h"
/***********************************************************/
/* _gvalues_compare */
-static gint _gvalues_compare (const GValue *value1, const GValue *value2);
-
-static gboolean
-type_is_fixed_size (GType type, gsize *tsize)
-{
- switch (type) {
- case G_TYPE_CHAR:
- if (tsize) *tsize = sizeof (char);
- return TRUE;
- case G_TYPE_UCHAR:
- if (tsize) *tsize = sizeof (guchar);
- return TRUE;
- case G_TYPE_BOOLEAN:
- if (tsize) *tsize = sizeof (gboolean);
- return TRUE;
- case G_TYPE_LONG:
- if (tsize) *tsize = sizeof (glong);
- return TRUE;
- case G_TYPE_ULONG:
- if (tsize) *tsize = sizeof (gulong);
- return TRUE;
- case G_TYPE_INT:
- if (tsize) *tsize = sizeof (gint);
- return TRUE;
- case G_TYPE_UINT:
- if (tsize) *tsize = sizeof (guint);
- return TRUE;
- case G_TYPE_INT64:
- if (tsize) *tsize = sizeof (gint64);
- return TRUE;
- case G_TYPE_UINT64:
- if (tsize) *tsize = sizeof (guint64);
- return TRUE;
- case G_TYPE_FLOAT:
- if (tsize) *tsize = sizeof (gfloat);
- return TRUE;
- case G_TYPE_DOUBLE:
- if (tsize) *tsize = sizeof (gdouble);
- return TRUE;
- default:
- return FALSE;
- }
-}
-
-#define FLOAT_FACTOR 0.00000001
-
-static gint
-_gvalues_compare_fixed (const GValue *value1, const GValue *value2)
-{
- int ret = 0;
-
- switch (G_VALUE_TYPE (value1)) {
- case G_TYPE_CHAR: {
- gchar val1 = g_value_get_schar (value1);
- gchar val2 = g_value_get_schar (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_UCHAR: {
- guchar val1 = g_value_get_uchar (value1);
- guchar val2 = g_value_get_uchar (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_BOOLEAN: {
- gboolean val1 = g_value_get_boolean (value1);
- gboolean val2 = g_value_get_boolean (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_LONG: {
- glong val1 = g_value_get_long (value1);
- glong val2 = g_value_get_long (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_ULONG: {
- gulong val1 = g_value_get_ulong (value1);
- gulong val2 = g_value_get_ulong (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_INT: {
- gint val1 = g_value_get_int (value1);
- gint val2 = g_value_get_int (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_UINT: {
- guint val1 = g_value_get_uint (value1);
- guint val2 = g_value_get_uint (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_INT64: {
- gint64 val1 = g_value_get_int64 (value1);
- gint64 val2 = g_value_get_int64 (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_UINT64: {
- guint64 val1 = g_value_get_uint64 (value1);
- guint64 val2 = g_value_get_uint64 (value2);
- if (val1 != val2)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_FLOAT: {
- gfloat val1 = g_value_get_float (value1);
- gfloat val2 = g_value_get_float (value2);
- /* Can't use == or != here due to inexactness of FP */
- if (fabsf (val1 - val2) > FLOAT_FACTOR)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- case G_TYPE_DOUBLE: {
- gdouble val1 = g_value_get_double (value1);
- gdouble val2 = g_value_get_double (value2);
- if (fabs (val1 - val2) > FLOAT_FACTOR)
- ret = val1 < val2 ? -1 : val1 > val2;
- break;
- }
- default:
- g_warning ("Unhandled fixed size type '%s'", G_VALUE_TYPE_NAME (value1));
- }
-
- return ret;
-}
+static gint _nm_variant_compare (GVariant *value1, GVariant *value2);
static gint
-_gvalues_compare_string (const GValue *value1, const GValue *value2)
+_nm_variant_compare_collection (GVariant *value1, GVariant *value2)
{
- const char *str1 = g_value_get_string (value1);
- const char *str2 = g_value_get_string (value2);
+ GVariant *child1, *child2;
+ int i, len1, len2;
+ int ret;
- if (str1 == str2)
- return 0;
-
- if (!str1)
- return 1;
- if (!str2)
- return -1;
+ len1 = g_variant_n_children (value1);
+ len2 = g_variant_n_children (value2);
- return strcmp (str1, str2);
-}
+ if (len1 != len2)
+ return len1 < len2 ? -1 : len1 > len2;
-static gint
-_gvalues_compare_strv (const GValue *value1, const GValue *value2)
-{
- char **strv1;
- char **strv2;
- gint ret;
- guint i = 0;
+ for (i = 0; i < len1; i++) {
+ child1 = g_variant_get_child_value (value1, i);
+ child2 = g_variant_get_child_value (value2, i);
- strv1 = (char **) g_value_get_boxed (value1);
- strv2 = (char **) g_value_get_boxed (value2);
+ ret = _nm_variant_compare (child1, child2);
+ g_variant_unref (child1);
+ g_variant_unref (child2);
- while (strv1[i] && strv2[i]) {
- ret = strcmp (strv1[i], strv2[i]);
if (ret)
return ret;
- i++;
- }
-
- if (strv1[i] == NULL && strv2[i] == NULL)
- return 0;
-
- if (strv1[i])
- return 1;
-
- return -1;
-}
-
-static void
-_gvalue_destroy (gpointer data)
-{
- GValue *value = (GValue *) data;
-
- g_value_unset (value);
- g_slice_free (GValue, value);
-}
-
-static GValue *
-_gvalue_dup (const GValue *value)
-{
- GValue *dup;
-
- dup = g_slice_new0 (GValue);
- g_value_init (dup, G_VALUE_TYPE (value));
- g_value_copy (value, dup);
-
- return dup;
-}
-
-static void
-iterate_collection (const GValue *value, gpointer user_data)
-{
- GSList **list = (GSList **) user_data;
-
- *list = g_slist_prepend (*list, _gvalue_dup (value));
-}
-
-static gint
-_gvalues_compare_collection (const GValue *value1, const GValue *value2)
-{
- gint ret;
- guint len1;
- guint len2;
- GType value_type = dbus_g_type_get_collection_specialization (G_VALUE_TYPE (value1));
- gsize element_size = 0;
-
- if (type_is_fixed_size (value_type, &element_size)) {
- gpointer data1 = NULL;
- gpointer data2 = NULL;
-
- dbus_g_type_collection_get_fixed ((GValue *) value1, &data1, &len1);
- dbus_g_type_collection_get_fixed ((GValue *) value2, &data2, &len2);
-
- if (len1 != len2)
- ret = len1 < len2 ? -1 : len1 > len2;
- else
- ret = memcmp (data1, data2, len1 * element_size);
- } else {
- GSList *list1 = NULL;
- GSList *list2 = NULL;
-
- dbus_g_type_collection_value_iterate (value1, iterate_collection, &list1);
- len1 = g_slist_length (list1);
- dbus_g_type_collection_value_iterate (value2, iterate_collection, &list2);
- len2 = g_slist_length (list2);
-
- if (len1 != len2)
- ret = len1 < len2 ? -1 : len1 > len2;
- else {
- GSList *iter1;
- GSList *iter2;
-
- for (iter1 = list1, iter2 = list2, ret = 0;
- ret == 0 && iter1 && iter2;
- iter1 = iter1->next, iter2 = iter2->next)
- ret = _gvalues_compare ((GValue *) iter1->data, (GValue *) iter2->data);
- }
-
- g_slist_free_full (list1, _gvalue_destroy);
- g_slist_free_full (list2, _gvalue_destroy);
}
- return ret;
-}
-
-static void
-iterate_map (const GValue *key_val,
- const GValue *value_val,
- gpointer user_data)
-{
- GHashTable **hash = (GHashTable **) user_data;
-
- g_hash_table_insert (*hash, g_value_dup_string (key_val), _gvalue_dup (value_val));
-}
-
-typedef struct {
- GHashTable *hash2;
- gint ret;
-} CompareMapInfo;
-
-static void
-compare_one_map_item (gpointer key, gpointer val, gpointer user_data)
-{
- CompareMapInfo *info = (CompareMapInfo *) user_data;
- GValue *value2;
-
- if (info->ret)
- return;
-
- value2 = (GValue *) g_hash_table_lookup (info->hash2, key);
- if (value2)
- info->ret = _gvalues_compare ((GValue *) val, value2);
- else
- info->ret = 1;
+ return 0;
}
static gint
-_gvalues_compare_map (const GValue *value1, const GValue *value2)
+_nm_variant_compare_strdict (GVariant *value1, GVariant *value2)
{
- GHashTable *hash1 = NULL;
- GHashTable *hash2 = NULL;
- guint len1;
- guint len2;
- gint ret = 0;
-
- if (dbus_g_type_get_map_key_specialization (G_VALUE_TYPE (value1)) != G_TYPE_STRING) {
- g_warning ("Can not compare maps with '%s' for keys",
- g_type_name (dbus_g_type_get_map_key_specialization (G_VALUE_TYPE (value1))));
- return 0;
- }
+ GVariantIter iter;
+ int len1, len2;
+ const char *key, *val1, *val2;
+ int ret;
- hash1 = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, _gvalue_destroy);
- dbus_g_type_map_value_iterate (value1, iterate_map, &hash1);
- len1 = g_hash_table_size (hash1);
-
- hash2 = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, _gvalue_destroy);
- dbus_g_type_map_value_iterate (value2, iterate_map, &hash2);
- len2 = g_hash_table_size (hash2);
+ len1 = g_variant_n_children (value1);
+ len2 = g_variant_n_children (value2);
if (len1 != len2)
- ret = len1 < len2 ? -1 : len1 > len2;
- else {
- CompareMapInfo info;
-
- info.ret = 0;
- info.hash2 = hash2;
- g_hash_table_foreach (hash1, compare_one_map_item, &info);
- ret = info.ret;
- }
+ return len1 < len2 ? -1 : len1 > len2;
- g_hash_table_destroy (hash1);
- g_hash_table_destroy (hash2);
-
- return ret;
-}
+ g_variant_iter_init (&iter, value1);
+ while (g_variant_iter_next (&iter, "{&s&s}", &key, &val1)) {
+ if (!g_variant_lookup (value2, key, "&s", &val2))
+ return -1;
-static gint
-_gvalue_ip6_address_compare (const GValue *value1, const GValue *value2)
-{
- GValueArray *values1, *values2;
- GValue *tmp_val;
- GByteArray *addr1, *addr2;
- guint32 prefix1, prefix2;
- GByteArray *gw1, *gw2;
- gint ret = 0;
- int i;
-
- /* IP6 addresses are GValueArrays (see nm-dbus-glib-types.h) */
- values1 = g_value_get_boxed (value1);
- values2 = g_value_get_boxed (value2);
-
- /* Since they are NM IPv6 address structures, we expect both
- * to contain two elements as specified in nm-dbus-glib-types.h.
- */
- g_return_val_if_fail (values1->n_values == 3, 0);
- g_return_val_if_fail (values2->n_values == 3, 0);
-
- /* First struct IPv6 address */
- tmp_val = g_value_array_get_nth (values1, 0);
- addr1 = g_value_get_boxed (tmp_val);
- /* First struct IPv6 prefix */
- tmp_val = g_value_array_get_nth (values1, 1);
- prefix1 = g_value_get_uint (tmp_val);
- /* First struct IPv6 gateway */
- tmp_val = g_value_array_get_nth (values1, 2);
- gw1 = g_value_get_boxed (tmp_val);
-
- /* Second struct IPv6 address */
- tmp_val = g_value_array_get_nth (values2, 0);
- addr2 = g_value_get_boxed (tmp_val);
- /* Second struct IPv6 prefix */
- tmp_val = g_value_array_get_nth (values2, 1);
- prefix2 = g_value_get_uint (tmp_val);
- /* Second struct IPv6 gateway */
- tmp_val = g_value_array_get_nth (values2, 2);
- gw2 = g_value_get_boxed (tmp_val);
-
- /* Compare IPv6 addresses */
- if (prefix1 != prefix2)
- return prefix1 < prefix2 ? -1 : prefix1 > prefix2;
-
- if (!IN6_ARE_ADDR_EQUAL ((struct in6_addr *)addr1->data, (struct in6_addr *)addr2->data)) {
- for (i = 0; ret == 0 && i < addr1->len; i++)
- ret = addr1->data[i] < addr2->data[i] ? -1 : addr1->data[i] > addr2->data[i];
- }
-
- if (!IN6_ARE_ADDR_EQUAL ((struct in6_addr *) gw1->data, (struct in6_addr *) gw2->data)) {
- for (i = 0; ret == 0 && i < gw1->len; i++)
- ret = gw1->data[i] < gw2->data[i] ? -1 : gw1->data[i] > gw2->data[i];
- }
-
- return ret;
-}
-
-static gint
-_gvalue_ip6_route_compare (const GValue *value1, const GValue *value2)
-{
- GValueArray *values1, *values2;
- GValue *tmp_val;
- GByteArray *dest1, *dest2;
- GByteArray *next_hop1, *next_hop2;
- guint32 prefix1, prefix2;
- guint32 metric1, metric2;
- gint ret = 0;
- int i;
-
- /* IP6 routes are GValueArrays (see nm-dbus-glib-types.h) */
- values1 = g_value_get_boxed (value1);
- values2 = g_value_get_boxed (value2);
-
- /* Since they are NM IPv6 route structures, we expect both
- * to contain 4 elements as specified in nm-dbus-glib-types.h.
- */
- g_return_val_if_fail (values1->n_values == 4, 0);
- g_return_val_if_fail (values2->n_values == 4, 0);
-
- /* First struct IPv6 route */
- tmp_val = g_value_array_get_nth (values1, 0);
- dest1 = g_value_get_boxed (tmp_val);
- tmp_val = g_value_array_get_nth (values1, 1);
- prefix1 = g_value_get_uint (tmp_val);
- tmp_val = g_value_array_get_nth (values1, 2);
- next_hop1 = g_value_get_boxed (tmp_val);
- tmp_val = g_value_array_get_nth (values1, 3);
- metric1 = g_value_get_uint (tmp_val);
-
- /* Second struct IPv6 route */
- tmp_val = g_value_array_get_nth (values2, 0);
- dest2 = g_value_get_boxed (tmp_val);
- tmp_val = g_value_array_get_nth (values2, 1);
- prefix2 = g_value_get_uint (tmp_val);
- tmp_val = g_value_array_get_nth (values2, 2);
- next_hop2 = g_value_get_boxed (tmp_val);
- tmp_val = g_value_array_get_nth (values2, 3);
- metric2 = g_value_get_uint (tmp_val);
-
- /* Compare the routes */
- if (prefix1 != prefix2)
- return prefix1 < prefix2 ? -1 : prefix1 > prefix2;
-
- if (!IN6_ARE_ADDR_EQUAL ((struct in6_addr *)dest1->data, (struct in6_addr *)dest2->data)) {
- for (i = 0; ret == 0 && i < dest1->len; i++)
- ret = dest1->data[i] < dest2->data[i] ? -1 : dest1->data[i] > dest2->data[i];
- }
-
- if (!IN6_ARE_ADDR_EQUAL ((struct in6_addr *)next_hop1->data, (struct in6_addr *)next_hop2->data)) {
- for (i = 0; ret == 0 && i < next_hop1->len; i++)
- ret = next_hop1->data[i] < next_hop2->data[i] ? -1 : next_hop1->data[i] > next_hop2->data[i];
+ ret = strcmp (val1, val2);
+ if (ret)
+ return ret;
}
- if (metric1 != metric2)
- ret = metric1 < metric2 ? -1 : metric1 > metric2;
-
- return ret;
+ return 0;
}
static gint
-_gvalues_compare_struct (const GValue *value1, const GValue *value2)
-{
- /* value1 and value2 must contain the same type since
- * _gvalues_compare() enforced that already.
- */
-
- if (G_VALUE_HOLDS (value1, DBUS_TYPE_G_IP6_ADDRESS)) {
- return _gvalue_ip6_address_compare (value1, value2);
- } else if (G_VALUE_HOLDS (value1, DBUS_TYPE_G_IP6_ROUTE)) {
- return _gvalue_ip6_route_compare (value1, value2);
- } else {
- g_warning ("Don't know how to compare structures");
- return (value1 == value2);
- }
-}
-
-gint
-_gvalues_compare (const GValue *value1, const GValue *value2)
+_nm_variant_compare (GVariant *value1, GVariant *value2)
{
- GType type1;
- GType type2;
+ const GVariantType *type1;
+ const GVariantType *type2;
gint ret;
if (value1 == value2)
@@ -513,42 +103,22 @@ _gvalues_compare (const GValue *value1, const GValue *value2)
if (!value2)
return -1;
- type1 = G_VALUE_TYPE (value1);
- type2 = G_VALUE_TYPE (value2);
+ type1 = g_variant_get_type (value1);
+ type2 = g_variant_get_type (value2);
- if (type1 != type2)
+ if (!g_variant_type_equal (type1, type2))
return type1 < type2 ? -1 : type1 > type2;
- if (type_is_fixed_size (type1, NULL))
- ret = _gvalues_compare_fixed (value1, value2);
- else if (type1 == G_TYPE_STRING)
- ret = _gvalues_compare_string (value1, value2);
- else if (G_VALUE_HOLDS_BOXED (value1)) {
- gpointer p1 = g_value_get_boxed (value1);
- gpointer p2 = g_value_get_boxed (value2);
-
- if (p1 == p2)
- ret = 0; /* Exactly the same values */
- else if (!p1)
- ret = 1; /* The comparision functions below don't handle NULLs */
- else if (!p2)
- ret = -1; /* The comparision functions below don't handle NULLs */
- else if (type1 == G_TYPE_STRV)
- ret = _gvalues_compare_strv (value1, value2);
- else if (dbus_g_type_is_collection (type1))
- ret = _gvalues_compare_collection (value1, value2);
- else if (dbus_g_type_is_map (type1))
- ret = _gvalues_compare_map (value1, value2);
- else if (dbus_g_type_is_struct (type1))
- ret = _gvalues_compare_struct (value1, value2);
- else if (type1 == G_TYPE_VALUE)
- ret = _gvalues_compare ((GValue *) g_value_get_boxed (value1), (GValue *) g_value_get_boxed (value2));
- else {
- g_warning ("Don't know how to compare boxed types '%s'", g_type_name (type1));
- ret = value1 == value2;
- }
- } else {
- g_warning ("Don't know how to compare types '%s'", g_type_name (type1));
+ if (g_variant_type_is_basic (type1))
+ ret = g_variant_compare (value1, value2);
+ else if (g_variant_is_of_type (value1, G_VARIANT_TYPE ("a{ss}")))
+ ret = _nm_variant_compare_strdict (value1, value2);
+ else if (g_variant_type_is_array (type1))
+ ret = _nm_variant_compare_collection (value1, value2);
+ else if (g_variant_type_is_tuple (type1))
+ ret = _nm_variant_compare_collection (value1, value2);
+ else {
+ g_warning ("Don't know how to compare variant type '%s'", (const char *) type1);
ret = value1 == value2;
}
@@ -560,9 +130,9 @@ _gvalues_compare (const GValue *value1, const GValue *value2)
struct _NMParamSpecDbus {
GParamSpec parent;
- GType dbus_type;
- NMParamSpecDbusTransformFunc to_dbus;
- NMParamSpecDbusTransformFunc from_dbus;
+ const GVariantType *dbus_type;
+ NMParamSpecDbusTransformToFunc to_dbus;
+ NMParamSpecDbusTransformFromFunc from_dbus;
};
static void
@@ -596,20 +166,17 @@ param_dbus_values_cmp (GParamSpec *pspec,
const GValue *value2)
{
NMParamSpecDbus *pspec_dbus = NM_PARAM_SPEC_DBUS (pspec);
- GValue dbus_value1 = { 0, };
- GValue dbus_value2 = { 0, };
+ GVariant *dbus_value1;
+ GVariant *dbus_value2;
int cmp;
- g_value_init (&dbus_value1, pspec_dbus->dbus_type);
- pspec_dbus->to_dbus (value1, &dbus_value1);
-
- g_value_init (&dbus_value2, pspec_dbus->dbus_type);
- pspec_dbus->to_dbus (value2, &dbus_value2);
+ dbus_value1 = _nm_param_spec_dbus_value_to_dbus (pspec_dbus, value1);
+ dbus_value2 = _nm_param_spec_dbus_value_to_dbus (pspec_dbus, value2);
- cmp = _gvalues_compare (&dbus_value1, &dbus_value2);
+ cmp = _nm_variant_compare (dbus_value1, dbus_value2);
- g_value_unset (&dbus_value1);
- g_value_unset (&dbus_value2);
+ g_variant_unref (dbus_value1);
+ g_variant_unref (dbus_value2);
return cmp;
}
@@ -641,47 +208,48 @@ _nm_param_spec_dbus (const char *name,
const char *nick,
const char *blurb,
GType property_type,
- GType dbus_type,
- NMParamSpecDbusTransformFunc to_dbus,
- NMParamSpecDbusTransformFunc from_dbus,
+ const GVariantType *dbus_type,
+ NMParamSpecDbusTransformToFunc to_dbus,
+ NMParamSpecDbusTransformFromFunc from_dbus,
GParamFlags flags)
{
NMParamSpecDbus *pspec;
- g_return_val_if_fail (g_type_is_a (dbus_type, G_TYPE_BOXED), NULL);
-
pspec = g_param_spec_internal (NM_TYPE_PARAM_SPEC_DBUS,
name, nick, blurb, flags);
G_PARAM_SPEC (pspec)->value_type = property_type;
pspec->dbus_type = dbus_type;
- pspec->to_dbus = to_dbus ? to_dbus : g_value_copy;
- pspec->from_dbus = from_dbus ? from_dbus : g_value_copy;
+ pspec->to_dbus = to_dbus;
+ pspec->from_dbus = from_dbus;
return G_PARAM_SPEC (pspec);
}
void
_nm_param_spec_dbus_value_from_dbus (NMParamSpecDbus *pspec_dbus,
- const GValue *dbus_value,
+ GVariant *dbus_value,
GValue *prop_value)
{
g_return_if_fail (NM_IS_PARAM_SPEC_DBUS (pspec_dbus));
- g_return_if_fail (G_VALUE_HOLDS (dbus_value, pspec_dbus->dbus_type));
+ g_return_if_fail (g_variant_is_of_type (dbus_value, pspec_dbus->dbus_type));
g_return_if_fail (G_VALUE_HOLDS (prop_value, pspec_dbus->parent.value_type));
- pspec_dbus->from_dbus (dbus_value, prop_value);
+ if (pspec_dbus->from_dbus)
+ pspec_dbus->from_dbus (dbus_value, prop_value);
+ else
+ g_dbus_gvariant_to_gvalue (dbus_value, prop_value);
}
-void
+GVariant *
_nm_param_spec_dbus_value_to_dbus (NMParamSpecDbus *pspec_dbus,
- const GValue *prop_value,
- GValue *dbus_value)
+ const GValue *prop_value)
{
g_return_if_fail (NM_IS_PARAM_SPEC_DBUS (pspec_dbus));
g_return_if_fail (G_VALUE_HOLDS (prop_value, pspec_dbus->parent.value_type));
- g_return_if_fail (!G_IS_VALUE (dbus_value));
- g_value_init (dbus_value, pspec_dbus->dbus_type);
- pspec_dbus->to_dbus (prop_value, dbus_value);
+ if (pspec_dbus->to_dbus)
+ return pspec_dbus->to_dbus (prop_value);
+ else
+ return g_dbus_gvalue_to_gvariant (prop_value, pspec_dbus->dbus_type);
}