diff options
| author | Sebastien Bacher <seb128@ubuntu.com> | 2021-01-11 18:07:03 +0100 |
|---|---|---|
| committer | Sebastien Bacher <seb128@ubuntu.com> | 2021-01-11 18:15:57 +0100 |
| commit | 2567f558da3eb9911678227d4aeb15162e707d89 (patch) | |
| tree | 13c80b0e091c8ba585b14b966cda998f95f1936d /libnm-core/nm-setting.c | |
| parent | 02d99ffd62ede29cffcb45fcbe33d044b7406d3a (diff) | |
| parent | f54032b30e1ddd84f10a339e0caf493772e049a7 (diff) | |
Merge branch 'debian/master' into ubuntu/master
Diffstat (limited to 'libnm-core/nm-setting.c')
| -rw-r--r-- | libnm-core/nm-setting.c | 3976 |
1 files changed, 1979 insertions, 1997 deletions
diff --git a/libnm-core/nm-setting.c b/libnm-core/nm-setting.c index dfb2bed9..0f621289 100644 --- a/libnm-core/nm-setting.c +++ b/libnm-core/nm-setting.c @@ -1,4 +1,4 @@ -// SPDX-License-Identifier: LGPL-2.1+ +/* SPDX-License-Identifier: LGPL-2.1+ */ /* * Copyright (C) 2007 - 2011 Red Hat, Inc. * Copyright (C) 2007 - 2008 Novell, Inc. @@ -29,81 +29,78 @@ /*****************************************************************************/ typedef struct { - GHashTable *hash; - const char **names; - GVariant **values; + GHashTable * hash; + const char **names; + GVariant ** values; } GenData; typedef struct { - const char *name; - GType type; - NMSettingPriority priority; + const char * name; + GType type; + NMSettingPriority priority; } SettingInfo; -NM_GOBJECT_PROPERTIES_DEFINE (NMSetting, - PROP_NAME, -); +NM_GOBJECT_PROPERTIES_DEFINE(NMSetting, PROP_NAME, ); typedef struct { - GenData *gendata; + GenData *gendata; } NMSettingPrivate; -G_DEFINE_ABSTRACT_TYPE (NMSetting, nm_setting, G_TYPE_OBJECT) +G_DEFINE_ABSTRACT_TYPE(NMSetting, nm_setting, G_TYPE_OBJECT) -#define NM_SETTING_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING, NMSettingPrivate)) +#define NM_SETTING_GET_PRIVATE(o) \ + (G_TYPE_INSTANCE_GET_PRIVATE((o), NM_TYPE_SETTING, NMSettingPrivate)) /*****************************************************************************/ -static GenData *_gendata_hash (NMSetting *setting, gboolean create_if_necessary); +static GenData *_gendata_hash(NMSetting *setting, gboolean create_if_necessary); /*****************************************************************************/ static NMSettingPriority -_get_base_type_priority (const NMMetaSettingInfo *setting_info, - GType gtype) +_get_base_type_priority(const NMMetaSettingInfo *setting_info, GType gtype) { - /* Historical oddity: PPPoE is a base-type even though it's not - * priority 1. It needs to be sorted *after* lower-level stuff like - * Wi-Fi security or 802.1x for secrets, but it's still allowed as a - * base type. - */ + /* Historical oddity: PPPoE is a base-type even though it's not + * priority 1. It needs to be sorted *after* lower-level stuff like + * Wi-Fi security or 802.1x for secrets, but it's still allowed as a + * base type. + */ - if (setting_info) { - if ( NM_IN_SET (setting_info->setting_priority, - NM_SETTING_PRIORITY_HW_BASE, - NM_SETTING_PRIORITY_HW_NON_BASE) - || gtype == NM_TYPE_SETTING_PPPOE) - return setting_info->setting_priority; - } + if (setting_info) { + if (NM_IN_SET(setting_info->setting_priority, + NM_SETTING_PRIORITY_HW_BASE, + NM_SETTING_PRIORITY_HW_NON_BASE) + || gtype == NM_TYPE_SETTING_PPPOE) + return setting_info->setting_priority; + } - return NM_SETTING_PRIORITY_INVALID; + return NM_SETTING_PRIORITY_INVALID; } NMSettingPriority -_nm_setting_get_setting_priority (NMSetting *setting) +_nm_setting_get_setting_priority(NMSetting *setting) { - const NMMetaSettingInfo *setting_info; + const NMMetaSettingInfo *setting_info; - g_return_val_if_fail (NM_IS_SETTING (setting), NM_SETTING_PRIORITY_INVALID); + g_return_val_if_fail(NM_IS_SETTING(setting), NM_SETTING_PRIORITY_INVALID); - setting_info = NM_SETTING_GET_CLASS (setting)->setting_info; - return setting_info ? setting_info->setting_priority : NM_SETTING_PRIORITY_INVALID; + setting_info = NM_SETTING_GET_CLASS(setting)->setting_info; + return setting_info ? setting_info->setting_priority : NM_SETTING_PRIORITY_INVALID; } NMSettingPriority -_nm_setting_type_get_base_type_priority (GType type) +_nm_setting_type_get_base_type_priority(GType type) { - return _get_base_type_priority (nm_meta_setting_infos_by_gtype (type), - type); + return _get_base_type_priority(nm_meta_setting_infos_by_gtype(type), type); } NMSettingPriority -_nm_setting_get_base_type_priority (NMSetting *setting) +_nm_setting_get_base_type_priority(NMSetting *setting) { - g_return_val_if_fail (NM_IS_SETTING (setting), NM_SETTING_PRIORITY_INVALID); + g_return_val_if_fail(NM_IS_SETTING(setting), NM_SETTING_PRIORITY_INVALID); - return _get_base_type_priority (NM_SETTING_GET_CLASS (setting)->setting_info, - G_OBJECT_TYPE (setting)); + return _get_base_type_priority(NM_SETTING_GET_CLASS(setting)->setting_info, + G_OBJECT_TYPE(setting)); } /** @@ -116,570 +113,583 @@ _nm_setting_get_base_type_priority (NMSetting *setting) * @name is not recognized. **/ GType -nm_setting_lookup_type (const char *name) +nm_setting_lookup_type(const char *name) { - const NMMetaSettingInfo *setting_info; + const NMMetaSettingInfo *setting_info; - g_return_val_if_fail (name, G_TYPE_INVALID); + g_return_val_if_fail(name, G_TYPE_INVALID); - setting_info = nm_meta_setting_infos_by_name (name); - return setting_info ? setting_info->get_setting_gtype () : G_TYPE_INVALID; + setting_info = nm_meta_setting_infos_by_name(name); + return setting_info ? setting_info->get_setting_gtype() : G_TYPE_INVALID; } int -_nm_setting_compare_priority (gconstpointer a, gconstpointer b) +_nm_setting_compare_priority(gconstpointer a, gconstpointer b) { - NMSettingPriority prio_a, prio_b; + NMSettingPriority prio_a, prio_b; - prio_a = _nm_setting_get_setting_priority ((NMSetting *) a); - prio_b = _nm_setting_get_setting_priority ((NMSetting *) b); + prio_a = _nm_setting_get_setting_priority((NMSetting *) a); + prio_b = _nm_setting_get_setting_priority((NMSetting *) b); - if (prio_a < prio_b) - return -1; - else if (prio_a == prio_b) - return 0; - return 1; + if (prio_a < prio_b) + return -1; + else if (prio_a == prio_b) + return 0; + return 1; } /*****************************************************************************/ gboolean -_nm_setting_slave_type_is_valid (const char *slave_type, const char **out_port_type) -{ - const char *port_type = NULL; - gboolean found = TRUE; - - if (!slave_type) - found = FALSE; - else if (NM_IN_STRSET (slave_type, - NM_SETTING_BOND_SETTING_NAME, - NM_SETTING_VRF_SETTING_NAME)) { - /* pass */ - } - else if (nm_streq (slave_type, NM_SETTING_BRIDGE_SETTING_NAME)) - port_type = NM_SETTING_BRIDGE_PORT_SETTING_NAME; - else if (nm_streq (slave_type, NM_SETTING_OVS_BRIDGE_SETTING_NAME)) - port_type = NM_SETTING_OVS_PORT_SETTING_NAME; - else if (nm_streq (slave_type, NM_SETTING_OVS_PORT_SETTING_NAME)) - port_type = NM_SETTING_OVS_INTERFACE_SETTING_NAME; - else if (nm_streq (slave_type, NM_SETTING_TEAM_SETTING_NAME)) - port_type = NM_SETTING_TEAM_PORT_SETTING_NAME; - else - found = FALSE; - - if (out_port_type) - *out_port_type = port_type; - return found; +_nm_setting_slave_type_is_valid(const char *slave_type, const char **out_port_type) +{ + const char *port_type = NULL; + gboolean found = TRUE; + + if (!slave_type) + found = FALSE; + else if (NM_IN_STRSET(slave_type, NM_SETTING_BOND_SETTING_NAME, NM_SETTING_VRF_SETTING_NAME)) { + /* pass */ + } else if (nm_streq(slave_type, NM_SETTING_BRIDGE_SETTING_NAME)) + port_type = NM_SETTING_BRIDGE_PORT_SETTING_NAME; + else if (nm_streq(slave_type, NM_SETTING_OVS_BRIDGE_SETTING_NAME)) + port_type = NM_SETTING_OVS_PORT_SETTING_NAME; + else if (nm_streq(slave_type, NM_SETTING_OVS_PORT_SETTING_NAME)) + port_type = NM_SETTING_OVS_INTERFACE_SETTING_NAME; + else if (nm_streq(slave_type, NM_SETTING_TEAM_SETTING_NAME)) + port_type = NM_SETTING_TEAM_PORT_SETTING_NAME; + else + found = FALSE; + + if (out_port_type) + *out_port_type = port_type; + return found; } /*****************************************************************************/ static const NMSettInfoProperty * -_nm_sett_info_property_find_in_array (const NMSettInfoProperty *properties, guint len, const char *name) +_nm_sett_info_property_find_in_array(const NMSettInfoProperty *properties, + guint len, + const char * name) { - guint i; + guint i; - for (i = 0; i < len; i++) { - if (nm_streq (name, properties[i].name)) - return &properties[i]; - } - return NULL; + for (i = 0; i < len; i++) { + if (nm_streq(name, properties[i].name)) + return &properties[i]; + } + return NULL; } static GVariant * -_gprop_to_dbus_fcn_bytes (const GValue *val) +_gprop_to_dbus_fcn_bytes(const GValue *val) { - nm_assert (G_VALUE_HOLDS (val, G_TYPE_BYTES)); - return nm_utils_gbytes_to_variant_ay (g_value_get_boxed (val)); + nm_assert(G_VALUE_HOLDS(val, G_TYPE_BYTES)); + return nm_utils_gbytes_to_variant_ay(g_value_get_boxed(val)); } static GVariant * -_gprop_to_dbus_fcn_enum (const GValue *val) +_gprop_to_dbus_fcn_enum(const GValue *val) { - return g_variant_new_int32 (g_value_get_enum (val)); + return g_variant_new_int32(g_value_get_enum(val)); } static GVariant * -_gprop_to_dbus_fcn_flags (const GValue *val) +_gprop_to_dbus_fcn_flags(const GValue *val) { - return g_variant_new_uint32 (g_value_get_flags (val)); + return g_variant_new_uint32(g_value_get_flags(val)); } gboolean -_nm_properties_override_assert (const NMSettInfoProperty *prop_info) +_nm_properties_override_assert(const NMSettInfoProperty *prop_info) { - nm_assert (prop_info); - nm_assert ((!!prop_info->name) != (!!prop_info->param_spec)); - nm_assert (!prop_info->param_spec || !prop_info->name || nm_streq0 (prop_info->name, prop_info->param_spec->name)); + nm_assert(prop_info); + nm_assert((!!prop_info->name) != (!!prop_info->param_spec)); + nm_assert(!prop_info->param_spec || !prop_info->name + || nm_streq0(prop_info->name, prop_info->param_spec->name)); -#define _PROPERT_EXTRA(prop_info, member) \ - ({ \ - const NMSettInfoProperty *_prop_info = (prop_info); \ - \ - (_prop_info->property_type ? _prop_info->property_type->member : 0); \ - }) +#define _PROPERT_EXTRA(prop_info, member) \ + ({ \ + const NMSettInfoProperty *_prop_info = (prop_info); \ + \ + (_prop_info->property_type ? _prop_info->property_type->member : 0); \ + }) - nm_assert (!_PROPERT_EXTRA (prop_info, gprop_from_dbus_fcn) || _PROPERT_EXTRA (prop_info, dbus_type)); - nm_assert (!_PROPERT_EXTRA (prop_info, from_dbus_fcn) || _PROPERT_EXTRA (prop_info, dbus_type)); - nm_assert (!_PROPERT_EXTRA (prop_info, to_dbus_fcn) || _PROPERT_EXTRA (prop_info, dbus_type)); + nm_assert(!_PROPERT_EXTRA(prop_info, gprop_from_dbus_fcn) + || _PROPERT_EXTRA(prop_info, dbus_type)); + nm_assert(!_PROPERT_EXTRA(prop_info, from_dbus_fcn) || _PROPERT_EXTRA(prop_info, dbus_type)); + nm_assert(!_PROPERT_EXTRA(prop_info, to_dbus_fcn) || _PROPERT_EXTRA(prop_info, dbus_type)); - nm_assert (!_PROPERT_EXTRA (prop_info, to_dbus_fcn) || !_PROPERT_EXTRA (prop_info, gprop_to_dbus_fcn)); - nm_assert (!_PROPERT_EXTRA (prop_info, from_dbus_fcn) || !_PROPERT_EXTRA (prop_info, gprop_from_dbus_fcn)); + nm_assert(!_PROPERT_EXTRA(prop_info, to_dbus_fcn) + || !_PROPERT_EXTRA(prop_info, gprop_to_dbus_fcn)); + nm_assert(!_PROPERT_EXTRA(prop_info, from_dbus_fcn) + || !_PROPERT_EXTRA(prop_info, gprop_from_dbus_fcn)); - nm_assert (!_PROPERT_EXTRA (prop_info, gprop_to_dbus_fcn) || prop_info->param_spec); - nm_assert (!_PROPERT_EXTRA (prop_info, gprop_from_dbus_fcn) || prop_info->param_spec); + nm_assert(!_PROPERT_EXTRA(prop_info, gprop_to_dbus_fcn) || prop_info->param_spec); + nm_assert(!_PROPERT_EXTRA(prop_info, gprop_from_dbus_fcn) || prop_info->param_spec); #undef _PROPERT_EXTRA - return TRUE; + return TRUE; } static NMSettInfoSetting _sett_info_settings[_NM_META_SETTING_TYPE_NUM]; const NMSettInfoSetting * -nmtst_sett_info_settings (void) +nmtst_sett_info_settings(void) { - return _sett_info_settings; + return _sett_info_settings; } static int -_property_infos_sort_cmp_setting_connection (gconstpointer p_a, - gconstpointer p_b, - gpointer user_data) -{ - const NMSettInfoProperty *a = *((const NMSettInfoProperty *const*) p_a); - const NMSettInfoProperty *b = *((const NMSettInfoProperty *const*) p_b); - int c_name; - - c_name = strcmp (a->name, b->name); - nm_assert (c_name != 0); - -#define CMP_AND_RETURN(n_a, n_b, name) \ - G_STMT_START { \ - gboolean _is = nm_streq (n_a, ""name); \ - \ - if ( _is \ - || nm_streq (n_b, ""name)) \ - return _is ? -1 : 1; \ - } G_STMT_END - - /* for [connection], report first id, uuid, type in that order. */ - if (c_name != 0) { - CMP_AND_RETURN (a->name, b->name, NM_SETTING_CONNECTION_ID); - CMP_AND_RETURN (a->name, b->name, NM_SETTING_CONNECTION_UUID); - CMP_AND_RETURN (a->name, b->name, NM_SETTING_CONNECTION_TYPE); - } +_property_infos_sort_cmp_setting_connection(gconstpointer p_a, + gconstpointer p_b, + gpointer user_data) +{ + const NMSettInfoProperty *a = *((const NMSettInfoProperty *const *) p_a); + const NMSettInfoProperty *b = *((const NMSettInfoProperty *const *) p_b); + int c_name; + + c_name = strcmp(a->name, b->name); + nm_assert(c_name != 0); + +#define CMP_AND_RETURN(n_a, n_b, name) \ + G_STMT_START \ + { \ + gboolean _is = nm_streq(n_a, "" name); \ + \ + if (_is || nm_streq(n_b, "" name)) \ + return _is ? -1 : 1; \ + } \ + G_STMT_END + + /* for [connection], report first id, uuid, type in that order. */ + if (c_name != 0) { + CMP_AND_RETURN(a->name, b->name, NM_SETTING_CONNECTION_ID); + CMP_AND_RETURN(a->name, b->name, NM_SETTING_CONNECTION_UUID); + CMP_AND_RETURN(a->name, b->name, NM_SETTING_CONNECTION_TYPE); + } #undef CMP_AND_RETURN - return c_name; + return c_name; } -static const NMSettInfoProperty *const* -_property_infos_sort (const NMSettInfoProperty *property_infos, - guint property_infos_len, - NMSettingClass *setting_class) +static const NMSettInfoProperty *const * +_property_infos_sort(const NMSettInfoProperty *property_infos, + guint property_infos_len, + NMSettingClass * setting_class) { - const NMSettInfoProperty **arr; - guint i; + const NMSettInfoProperty **arr; + guint i; #if NM_MORE_ASSERTS > 5 - /* assert that the property names are all unique and sorted. */ - for (i = 0; i < property_infos_len; i++) { - if (property_infos[i].param_spec) - nm_assert (nm_streq (property_infos[i].name, property_infos[i].param_spec->name)); - if (i > 0) - nm_assert (strcmp (property_infos[i - 1].name, property_infos[i].name) < 0); - } + /* assert that the property names are all unique and sorted. */ + for (i = 0; i < property_infos_len; i++) { + if (property_infos[i].param_spec) + nm_assert(nm_streq(property_infos[i].name, property_infos[i].param_spec->name)); + if (i > 0) + nm_assert(strcmp(property_infos[i - 1].name, property_infos[i].name) < 0); + } #endif - if (property_infos_len <= 1) - return NULL; - if (G_TYPE_FROM_CLASS (setting_class) != NM_TYPE_SETTING_CONNECTION) { - /* we only do something special for certain setting types. This one, - * has just alphabetical sorting. */ - return NULL; - } + if (property_infos_len <= 1) + return NULL; + if (G_TYPE_FROM_CLASS(setting_class) != NM_TYPE_SETTING_CONNECTION) { + /* we only do something special for certain setting types. This one, + * has just alphabetical sorting. */ + return NULL; + } - arr = g_new (const NMSettInfoProperty *, property_infos_len); - for (i = 0; i < property_infos_len; i++) - arr[i] = &property_infos[i]; + arr = g_new(const NMSettInfoProperty *, property_infos_len); + for (i = 0; i < property_infos_len; i++) + arr[i] = &property_infos[i]; - g_qsort_with_data (arr, - property_infos_len, - sizeof (const NMSettInfoProperty *), - _property_infos_sort_cmp_setting_connection, - NULL); - return arr; + g_qsort_with_data(arr, + property_infos_len, + sizeof(const NMSettInfoProperty *), + _property_infos_sort_cmp_setting_connection, + NULL); + return arr; } void -_nm_setting_class_commit_full (NMSettingClass *setting_class, - NMMetaSettingType meta_type, - const NMSettInfoSettDetail *detail, - GArray *properties_override) +_nm_setting_class_commit_full(NMSettingClass * setting_class, + NMMetaSettingType meta_type, + const NMSettInfoSettDetail *detail, + GArray * properties_override) { - NMSettInfoSetting *sett_info; - gs_free GParamSpec **property_specs = NULL; - guint i, n_property_specs, override_len; + NMSettInfoSetting *sett_info; + gs_free GParamSpec **property_specs = NULL; + guint i, n_property_specs, override_len; - nm_assert (NM_IS_SETTING_CLASS (setting_class)); - nm_assert (!setting_class->setting_info); + nm_assert(NM_IS_SETTING_CLASS(setting_class)); + nm_assert(!setting_class->setting_info); - nm_assert (meta_type < G_N_ELEMENTS (_sett_info_settings)); + nm_assert(meta_type < G_N_ELEMENTS(_sett_info_settings)); - sett_info = &_sett_info_settings[meta_type]; + sett_info = &_sett_info_settings[meta_type]; - nm_assert (!sett_info->setting_class); - nm_assert (!sett_info->property_infos_len); - nm_assert (!sett_info->property_infos); + nm_assert(!sett_info->setting_class); + nm_assert(!sett_info->property_infos_len); + nm_assert(!sett_info->property_infos); - if (!properties_override) { - override_len = 0; - properties_override = _nm_sett_info_property_override_create_array (); - } else - override_len = properties_override->len; + if (!properties_override) { + override_len = 0; + properties_override = _nm_sett_info_property_override_create_array(); + } else + override_len = properties_override->len; - property_specs = g_object_class_list_properties (G_OBJECT_CLASS (setting_class), - &n_property_specs); + property_specs = + g_object_class_list_properties(G_OBJECT_CLASS(setting_class), &n_property_specs); - for (i = 0; i < properties_override->len; i++) { - NMSettInfoProperty *p = &g_array_index (properties_override, NMSettInfoProperty, i); + for (i = 0; i < properties_override->len; i++) { + NMSettInfoProperty *p = &g_array_index(properties_override, NMSettInfoProperty, i); - nm_assert ((!!p->name) != (!!p->param_spec)); + nm_assert((!!p->name) != (!!p->param_spec)); - if (!p->name) { - nm_assert (p->param_spec); - p->name = p->param_spec->name; - } else - nm_assert (!p->param_spec); - } + if (!p->name) { + nm_assert(p->param_spec); + p->name = p->param_spec->name; + } else + nm_assert(!p->param_spec); + } #if NM_MORE_ASSERTS > 10 - /* assert that properties_override is constructed consistently. */ - for (i = 0; i < override_len; i++) { - const NMSettInfoProperty *p = &g_array_index (properties_override, NMSettInfoProperty, i); - gboolean found = FALSE; - guint j; - - nm_assert (!_nm_sett_info_property_find_in_array ((NMSettInfoProperty *) properties_override->data, - i, - p->name)); - for (j = 0; j < n_property_specs; j++) { - if (!nm_streq (property_specs[j]->name, p->name)) - continue; - nm_assert (!found); - found = TRUE; - nm_assert (p->param_spec == property_specs[j]); - } - nm_assert (found == (p->param_spec != NULL)); - } + /* assert that properties_override is constructed consistently. */ + for (i = 0; i < override_len; i++) { + const NMSettInfoProperty *p = &g_array_index(properties_override, NMSettInfoProperty, i); + gboolean found = FALSE; + guint j; + + nm_assert( + !_nm_sett_info_property_find_in_array((NMSettInfoProperty *) properties_override->data, + i, + p->name)); + for (j = 0; j < n_property_specs; j++) { + if (!nm_streq(property_specs[j]->name, p->name)) + continue; + nm_assert(!found); + found = TRUE; + nm_assert(p->param_spec == property_specs[j]); + } + nm_assert(found == (p->param_spec != NULL)); + } #endif - for (i = 0; i < n_property_specs; i++) { - const char *name = property_specs[i]->name; - NMSettInfoProperty *p; - - if (_nm_sett_info_property_find_in_array ((NMSettInfoProperty *) properties_override->data, - override_len, - name)) - continue; - - g_array_set_size (properties_override, properties_override->len + 1); - p = &g_array_index (properties_override, NMSettInfoProperty, properties_override->len - 1); - memset (p, 0, sizeof (*p)); - p->name = name; - p->param_spec = property_specs[i]; - } - - for (i = 0; i < properties_override->len; i++) { - NMSettInfoProperty *p = &g_array_index (properties_override, NMSettInfoProperty, i); - GType vtype; - - if (p->property_type) - goto has_property_type; - - nm_assert (p->param_spec); - - vtype = p->param_spec->value_type; - if (vtype == G_TYPE_BOOLEAN) - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_BOOLEAN); - else if (vtype == G_TYPE_UCHAR) - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_BYTE); - else if (vtype == G_TYPE_INT) - p->property_type = &nm_sett_info_propert_type_plain_i; - else if (vtype == G_TYPE_UINT) - p->property_type = &nm_sett_info_propert_type_plain_u; - else if (vtype == G_TYPE_INT64) - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_INT64); - else if (vtype == G_TYPE_UINT64) - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_UINT64); - else if (vtype == G_TYPE_STRING) - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_STRING); - else if (vtype == G_TYPE_DOUBLE) - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_DOUBLE); - else if (vtype == G_TYPE_STRV) - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_STRING_ARRAY); - else if (vtype == G_TYPE_BYTES) { - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_BYTESTRING, - .gprop_to_dbus_fcn = _gprop_to_dbus_fcn_bytes); - } else if (g_type_is_a (vtype, G_TYPE_ENUM)) { - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_INT32, - .gprop_to_dbus_fcn = _gprop_to_dbus_fcn_enum); - } else if (g_type_is_a (vtype, G_TYPE_FLAGS)) { - p->property_type = NM_SETT_INFO_PROPERT_TYPE (.dbus_type = G_VARIANT_TYPE_UINT32, - .gprop_to_dbus_fcn = _gprop_to_dbus_fcn_flags); - } else - nm_assert_not_reached (); + for (i = 0; i < n_property_specs; i++) { + const char * name = property_specs[i]->name; + NMSettInfoProperty *p; + + if (_nm_sett_info_property_find_in_array((NMSettInfoProperty *) properties_override->data, + override_len, + name)) + continue; + + g_array_set_size(properties_override, properties_override->len + 1); + p = &g_array_index(properties_override, NMSettInfoProperty, properties_override->len - 1); + memset(p, 0, sizeof(*p)); + p->name = name; + p->param_spec = property_specs[i]; + } + + for (i = 0; i < properties_override->len; i++) { + NMSettInfoProperty *p = &g_array_index(properties_override, NMSettInfoProperty, i); + GType vtype; + + if (p->property_type) + goto has_property_type; + + nm_assert(p->param_spec); + + vtype = p->param_spec->value_type; + if (vtype == G_TYPE_BOOLEAN) + p->property_type = NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_BOOLEAN); + else if (vtype == G_TYPE_UCHAR) + p->property_type = NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_BYTE); + else if (vtype == G_TYPE_INT) + p->property_type = &nm_sett_info_propert_type_plain_i; + else if (vtype == G_TYPE_UINT) + p->property_type = &nm_sett_info_propert_type_plain_u; + else if (vtype == G_TYPE_INT64) + p->property_type = NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_INT64); + else if (vtype == G_TYPE_UINT64) + p->property_type = NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_UINT64); + else if (vtype == G_TYPE_STRING) + p->property_type = NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_STRING); + else if (vtype == G_TYPE_DOUBLE) + p->property_type = NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_DOUBLE); + else if (vtype == G_TYPE_STRV) + p->property_type = NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_STRING_ARRAY); + else if (vtype == G_TYPE_BYTES) { + p->property_type = + NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_BYTESTRING, + .gprop_to_dbus_fcn = _gprop_to_dbus_fcn_bytes); + } else if (g_type_is_a(vtype, G_TYPE_ENUM)) { + p->property_type = + NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_INT32, + .gprop_to_dbus_fcn = _gprop_to_dbus_fcn_enum); + } else if (g_type_is_a(vtype, G_TYPE_FLAGS)) { + p->property_type = + NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_UINT32, + .gprop_to_dbus_fcn = _gprop_to_dbus_fcn_flags); + } else + nm_assert_not_reached(); has_property_type: - nm_assert (p->property_type); - nm_assert (p->property_type->dbus_type); - nm_assert (g_variant_type_string_is_valid ((const char *) p->property_type->dbus_type)); - } + nm_assert(p->property_type); + nm_assert(p->property_type->dbus_type); + nm_assert(g_variant_type_string_is_valid((const char *) p->property_type->dbus_type)); + } - G_STATIC_ASSERT_EXPR (G_STRUCT_OFFSET (NMSettInfoProperty, name) == 0); - g_array_sort (properties_override, nm_strcmp_p); + G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(NMSettInfoProperty, name) == 0); + g_array_sort(properties_override, nm_strcmp_p); - setting_class->setting_info = &nm_meta_setting_infos[meta_type]; - sett_info->setting_class = setting_class; - if (detail) - sett_info->detail = *detail; - nm_assert (properties_override->len > 0); - sett_info->property_infos_len = properties_override->len; - sett_info->property_infos = nm_memdup (properties_override->data, sizeof (NMSettInfoProperty) * properties_override->len); + setting_class->setting_info = &nm_meta_setting_infos[meta_type]; + sett_info->setting_class = setting_class; + if (detail) + sett_info->detail = *detail; + nm_assert(properties_override->len > 0); + sett_info->property_infos_len = properties_override->len; + sett_info->property_infos = + nm_memdup(properties_override->data, sizeof(NMSettInfoProperty) * properties_override->len); - sett_info->property_infos_sorted = _property_infos_sort (sett_info->property_infos, - sett_info->property_infos_len, - setting_class); + sett_info->property_infos_sorted = _property_infos_sort(sett_info->property_infos, + sett_info->property_infos_len, + setting_class); - g_array_free (properties_override, TRUE); + g_array_free(properties_override, TRUE); } const NMSettInfoProperty * -_nm_sett_info_setting_get_property_info (const NMSettInfoSetting *sett_info, - const char *property_name) +_nm_sett_info_setting_get_property_info(const NMSettInfoSetting *sett_info, + const char * property_name) { - const NMSettInfoProperty *property; - gssize idx; + const NMSettInfoProperty *property; + gssize idx; - nm_assert (property_name); + nm_assert(property_name); - if (!sett_info) - return NULL; + if (!sett_info) + return NULL; - G_STATIC_ASSERT_EXPR (G_STRUCT_OFFSET (NMSettInfoProperty, name) == 0); - idx = nm_utils_array_find_binary_search (sett_info->property_infos, - sizeof (NMSettInfoProperty), - sett_info->property_infos_len, - &property_name, - nm_strcmp_p_with_data, - NULL); + G_STATIC_ASSERT_EXPR(G_STRUCT_OFFSET(NMSettInfoProperty, name) == 0); + idx = nm_utils_array_find_binary_search(sett_info->property_infos, + sizeof(NMSettInfoProperty), + sett_info->property_infos_len, + &property_name, + nm_strcmp_p_with_data, + NULL); - if (idx < 0) - return NULL; + if (idx < 0) + return NULL; - property = &sett_info->property_infos[idx]; + property = &sett_info->property_infos[idx]; - nm_assert (idx == 0 || strcmp (property[-1].name, property[0].name) < 0); - nm_assert (idx == sett_info->property_infos_len - 1 || strcmp (property[0].name, property[1].name) < 0); + nm_assert(idx == 0 || strcmp(property[-1].name, property[0].name) < 0); + nm_assert(idx == sett_info->property_infos_len - 1 + || strcmp(property[0].name, property[1].name) < 0); - return property; + return property; } const NMSettInfoSetting * -_nm_setting_class_get_sett_info (NMSettingClass *setting_class) +_nm_setting_class_get_sett_info(NMSettingClass *setting_class) { - const NMSettInfoSetting *sett_info; + const NMSettInfoSetting *sett_info; - if ( !NM_IS_SETTING_CLASS (setting_class) - || !setting_class->setting_info) - return NULL; + if (!NM_IS_SETTING_CLASS(setting_class) || !setting_class->setting_info) + return NULL; - nm_assert (setting_class->setting_info->meta_type < G_N_ELEMENTS (_sett_info_settings)); - sett_info = &_sett_info_settings[setting_class->setting_info->meta_type]; - nm_assert (sett_info->setting_class == setting_class); - return sett_info; + nm_assert(setting_class->setting_info->meta_type < G_N_ELEMENTS(_sett_info_settings)); + sett_info = &_sett_info_settings[setting_class->setting_info->meta_type]; + nm_assert(sett_info->setting_class == setting_class); + return sett_info; } /*****************************************************************************/ void -_nm_setting_emit_property_changed (NMSetting *setting) -{ - /* Some settings have "properties" that are not implemented as GObject properties. - * - * For example: - * - * - gendata-base settings like NMSettingEthtool. Here properties are just - * GVariant values in the gendata hash. - * - * - NMSettingWireGuard's peers are not backed by a GObject property. Instead - * there is C-API to access/modify peers. - * - * We still want to emit property-changed notifications for such properties, - * in particular because NMConnection registers to such signals to re-emit - * it as NM_CONNECTION_CHANGED signal. In fact, there are unlikely any other - * uses of such a property-changed signal, because generally it doesn't make - * too much sense. - * - * So, instead of adding yet another (artificial) signal "setting-changed", - * hijack the "notify" signal and just notify about changes of the "name". - * Of course, the "name" doesn't really ever change, because it's tied to - * the GObject's type. - */ - _notify (setting, PROP_NAME); +_nm_setting_emit_property_changed(NMSetting *setting) +{ + /* Some settings have "properties" that are not implemented as GObject properties. + * + * For example: + * + * - gendata-base settings like NMSettingEthtool. Here properties are just + * GVariant values in the gendata hash. + * + * - NMSettingWireGuard's peers are not backed by a GObject property. Instead + * there is C-API to access/modify peers. + * + * We still want to emit property-changed notifications for such properties, + * in particular because NMConnection registers to such signals to re-emit + * it as NM_CONNECTION_CHANGED signal. In fact, there are unlikely any other + * uses of such a property-changed signal, because generally it doesn't make + * too much sense. + * + * So, instead of adding yet another (artificial) signal "setting-changed", + * hijack the "notify" signal and just notify about changes of the "name". + * Of course, the "name" doesn't really ever change, because it's tied to + * the GObject's type. + */ + _notify(setting, PROP_NAME); } /*****************************************************************************/ gboolean -_nm_setting_use_legacy_property (NMSetting *setting, - GVariant *connection_dict, - const char *legacy_property, - const char *new_property) -{ - GVariant *setting_dict, *value; - - setting_dict = g_variant_lookup_value (connection_dict, nm_setting_get_name (NM_SETTING (setting)), NM_VARIANT_TYPE_SETTING); - g_return_val_if_fail (setting_dict != NULL, FALSE); - - /* If the new property isn't set, we have to use the legacy property. */ - value = g_variant_lookup_value (setting_dict, new_property, NULL); - if (!value) { - g_variant_unref (setting_dict); - return TRUE; - } - g_variant_unref (value); - - /* Otherwise, clients always prefer new properties sent from the daemon. */ - if (!_nm_utils_is_manager_process) { - g_variant_unref (setting_dict); - return FALSE; - } - - /* The daemon prefers the legacy property if it exists. */ - value = g_variant_lookup_value (setting_dict, legacy_property, NULL); - g_variant_unref (setting_dict); - - if (value) { - g_variant_unref (value); - return TRUE; - } else - return FALSE; +_nm_setting_use_legacy_property(NMSetting * setting, + GVariant * connection_dict, + const char *legacy_property, + const char *new_property) +{ + GVariant *setting_dict, *value; + + setting_dict = g_variant_lookup_value(connection_dict, + nm_setting_get_name(NM_SETTING(setting)), + NM_VARIANT_TYPE_SETTING); + g_return_val_if_fail(setting_dict != NULL, FALSE); + + /* If the new property isn't set, we have to use the legacy property. */ + value = g_variant_lookup_value(setting_dict, new_property, NULL); + if (!value) { + g_variant_unref(setting_dict); + return TRUE; + } + g_variant_unref(value); + + /* Otherwise, clients always prefer new properties sent from the daemon. */ + if (!_nm_utils_is_manager_process) { + g_variant_unref(setting_dict); + return FALSE; + } + + /* The daemon prefers the legacy property if it exists. */ + value = g_variant_lookup_value(setting_dict, legacy_property, NULL); + g_variant_unref(setting_dict); + + if (value) { + g_variant_unref(value); + return TRUE; + } else + return FALSE; } /*****************************************************************************/ static GVariant * -property_to_dbus (const NMSettInfoSetting *sett_info, - guint property_idx, - NMConnection *connection, - NMSetting *setting, - NMConnectionSerializationFlags flags, - const NMConnectionSerializationOptions *options, - gboolean ignore_flags, - gboolean ignore_default) -{ - const NMSettInfoProperty *property = &sett_info->property_infos[property_idx]; - GVariant *variant; - - nm_assert (property->property_type->dbus_type); - - if (!property->param_spec) { - if (!property->property_type->to_dbus_fcn) - return NULL; - } else if ( !ignore_flags - && !NM_FLAGS_HAS (property->param_spec->flags, NM_SETTING_PARAM_TO_DBUS_IGNORE_FLAGS)) { - if (!NM_FLAGS_HAS (property->param_spec->flags, G_PARAM_WRITABLE)) - return NULL; - - if ( NM_FLAGS_HAS (property->param_spec->flags, NM_SETTING_PARAM_LEGACY) - && !_nm_utils_is_manager_process) - return NULL; - - if (NM_FLAGS_HAS (property->param_spec->flags, NM_SETTING_PARAM_SECRET)) { - if (NM_FLAGS_HAS (flags, NM_CONNECTION_SERIALIZE_NO_SECRETS)) - return NULL; - - if (NM_FLAGS_HAS (flags, NM_CONNECTION_SERIALIZE_WITH_SECRETS_AGENT_OWNED)) { - NMSettingSecretFlags f; - - /* see also _nm_connection_serialize_secrets() */ - if (!nm_setting_get_secret_flags (setting, property->param_spec->name, &f, NULL)) - return NULL; - if (!NM_FLAGS_HAS (f, NM_SETTING_SECRET_FLAG_AGENT_OWNED)) - return NULL; - } - } else { - if (NM_FLAGS_HAS (flags, NM_CONNECTION_SERIALIZE_ONLY_SECRETS)) - return NULL; - } - } - - if (property->property_type->to_dbus_fcn) { - variant = property->property_type->to_dbus_fcn (sett_info, property_idx, connection, setting, flags, options); - nm_g_variant_take_ref (variant); - } else { - nm_auto_unset_gvalue GValue prop_value = { 0, }; - - nm_assert (property->param_spec); - - g_value_init (&prop_value, property->param_spec->value_type); - - g_object_get_property (G_OBJECT (setting), property->param_spec->name, &prop_value); - - if ( ignore_default - && g_param_value_defaults (property->param_spec, &prop_value)) - return NULL; - - if (property->property_type->gprop_to_dbus_fcn) { - variant = property->property_type->gprop_to_dbus_fcn (&prop_value); - nm_g_variant_take_ref (variant); - } else - variant = g_dbus_gvalue_to_gvariant (&prop_value, property->property_type->dbus_type); - } - - nm_assert (!variant || !g_variant_is_floating (variant)); - nm_assert (!variant || g_variant_is_of_type (variant, property->property_type->dbus_type)); - - return variant; +property_to_dbus(const NMSettInfoSetting * sett_info, + guint property_idx, + NMConnection * connection, + NMSetting * setting, + NMConnectionSerializationFlags flags, + const NMConnectionSerializationOptions *options, + gboolean ignore_flags, + gboolean ignore_default) +{ + const NMSettInfoProperty *property = &sett_info->property_infos[property_idx]; + GVariant * variant; + + nm_assert(property->property_type->dbus_type); + + if (!property->param_spec) { + if (!property->property_type->to_dbus_fcn) + return NULL; + } else if (!ignore_flags + && !NM_FLAGS_HAS(property->param_spec->flags, + NM_SETTING_PARAM_TO_DBUS_IGNORE_FLAGS)) { + if (!NM_FLAGS_HAS(property->param_spec->flags, G_PARAM_WRITABLE)) + return NULL; + + if (NM_FLAGS_HAS(property->param_spec->flags, NM_SETTING_PARAM_LEGACY) + && !_nm_utils_is_manager_process) + return NULL; + + if (NM_FLAGS_HAS(property->param_spec->flags, NM_SETTING_PARAM_SECRET)) { + if (NM_FLAGS_HAS(flags, NM_CONNECTION_SERIALIZE_NO_SECRETS)) + return NULL; + + if (NM_FLAGS_HAS(flags, NM_CONNECTION_SERIALIZE_WITH_SECRETS_AGENT_OWNED)) { + NMSettingSecretFlags f; + + /* see also _nm_connection_serialize_secrets() */ + if (!nm_setting_get_secret_flags(setting, property->param_spec->name, &f, NULL)) + return NULL; + if (!NM_FLAGS_HAS(f, NM_SETTING_SECRET_FLAG_AGENT_OWNED)) + return NULL; + } + } else { + if (NM_FLAGS_HAS(flags, NM_CONNECTION_SERIALIZE_ONLY_SECRETS)) + return NULL; + } + } + + if (property->property_type->to_dbus_fcn) { + variant = property->property_type + ->to_dbus_fcn(sett_info, property_idx, connection, setting, flags, options); + nm_g_variant_take_ref(variant); + } else { + nm_auto_unset_gvalue GValue prop_value = { + 0, + }; + + nm_assert(property->param_spec); + + g_value_init(&prop_value, property->param_spec->value_type); + + g_object_get_property(G_OBJECT(setting), property->param_spec->name, &prop_value); + + if (ignore_default && g_param_value_defaults(property->param_spec, &prop_value)) + return NULL; + + if (property->property_type->gprop_to_dbus_fcn) { + variant = property->property_type->gprop_to_dbus_fcn(&prop_value); + nm_g_variant_take_ref(variant); + } else + variant = g_dbus_gvalue_to_gvariant(&prop_value, property->property_type->dbus_type); + } + + nm_assert(!variant || !g_variant_is_floating(variant)); + nm_assert(!variant || g_variant_is_of_type(variant, property->property_type->dbus_type)); + + return variant; } static gboolean -set_property_from_dbus (const NMSettInfoProperty *property, - GVariant *src_value, - GValue *dst_value) +set_property_from_dbus(const NMSettInfoProperty *property, GVariant *src_value, GValue *dst_value) { - nm_assert (property->param_spec); - nm_assert (property->property_type->dbus_type); + nm_assert(property->param_spec); + nm_assert(property->property_type->dbus_type); - if (property->property_type->gprop_from_dbus_fcn) { - if (!g_variant_type_equal (g_variant_get_type (src_value), property->property_type->dbus_type)) - return FALSE; - property->property_type->gprop_from_dbus_fcn (src_value, dst_value); - } else if (dst_value->g_type == G_TYPE_BYTES) { - if (!g_variant_is_of_type (src_value, G_VARIANT_TYPE_BYTESTRING)) - return FALSE; + if (property->property_type->gprop_from_dbus_fcn) { + if (!g_variant_type_equal(g_variant_get_type(src_value), + property->property_type->dbus_type)) + return FALSE; + property->property_type->gprop_from_dbus_fcn(src_value, dst_value); + } else if (dst_value->g_type == G_TYPE_BYTES) { + if (!g_variant_is_of_type(src_value, G_VARIANT_TYPE_BYTESTRING)) + return FALSE; - _nm_utils_bytes_from_dbus (src_value, dst_value); - } else { - GValue tmp = G_VALUE_INIT; + _nm_utils_bytes_from_dbus(src_value, dst_value); + } else { + GValue tmp = G_VALUE_INIT; - g_dbus_gvariant_to_gvalue (src_value, &tmp); - if (G_VALUE_TYPE (&tmp) == G_VALUE_TYPE (dst_value)) - *dst_value = tmp; - else { - gboolean success; + g_dbus_gvariant_to_gvalue(src_value, &tmp); + if (G_VALUE_TYPE(&tmp) == G_VALUE_TYPE(dst_value)) + *dst_value = tmp; + else { + gboolean success; - success = g_value_transform (&tmp, dst_value); - g_value_unset (&tmp); - if (!success) - return FALSE; - } - } + success = g_value_transform(&tmp, dst_value); + g_value_unset(&tmp); + if (!success) + return FALSE; + } + } - return TRUE; + return TRUE; } /** @@ -698,45 +708,43 @@ set_property_from_dbus (const NMSettInfoProperty *property, * properties **/ GVariant * -_nm_setting_to_dbus (NMSetting *setting, - NMConnection *connection, - NMConnectionSerializationFlags flags, - const NMConnectionSerializationOptions *options) +_nm_setting_to_dbus(NMSetting * setting, + NMConnection * connection, + NMConnectionSerializationFlags flags, + const NMConnectionSerializationOptions *options) { - NMSettingPrivate *priv; - GVariantBuilder builder; - const NMSettInfoSetting *sett_info; - guint n_properties, i; - const char *const*gendata_keys; + NMSettingPrivate * priv; + GVariantBuilder builder; + const NMSettInfoSetting *sett_info; + guint n_properties, i; + const char *const * gendata_keys; - g_return_val_if_fail (NM_IS_SETTING (setting), NULL); + g_return_val_if_fail(NM_IS_SETTING(setting), NULL); - priv = NM_SETTING_GET_PRIVATE (setting); + priv = NM_SETTING_GET_PRIVATE(setting); - g_variant_builder_init (&builder, NM_VARIANT_TYPE_SETTING); + g_variant_builder_init(&builder, NM_VARIANT_TYPE_SETTING); - n_properties = _nm_setting_option_get_all (setting, &gendata_keys, NULL); - for (i = 0; i < n_properties; i++) { - g_variant_builder_add (&builder, - "{sv}", - gendata_keys[i], - g_hash_table_lookup (priv->gendata->hash, gendata_keys[i])); - } + n_properties = _nm_setting_option_get_all(setting, &gendata_keys, NULL); + for (i = 0; i < n_properties; i++) { + g_variant_builder_add(&builder, + "{sv}", + gendata_keys[i], + g_hash_table_lookup(priv->gendata->hash, gendata_keys[i])); + } - sett_info = _nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (setting)); - for (i = 0; i < sett_info->property_infos_len; i++) { - gs_unref_variant GVariant *dbus_value = NULL; + sett_info = _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(setting)); + for (i = 0; i < sett_info->property_infos_len; i++) { + gs_unref_variant GVariant *dbus_value = NULL; - dbus_value = property_to_dbus (sett_info, i, connection, setting, flags, options, FALSE, TRUE); - if (dbus_value) { - g_variant_builder_add (&builder, - "{sv}", - sett_info->property_infos[i].name, - dbus_value); - } - } + dbus_value = + property_to_dbus(sett_info, i, connection, setting, flags, options, FALSE, TRUE); + if (dbus_value) { + g_variant_builder_add(&builder, "{sv}", sett_info->property_infos[i].name, dbus_value); + } + } - return g_variant_builder_end (&builder); + return g_variant_builder_end(&builder); } /** @@ -760,230 +768,240 @@ _nm_setting_to_dbus (NMSetting *setting, * hash table, or %NULL if @setting_hash could not be deserialized. **/ NMSetting * -_nm_setting_new_from_dbus (GType setting_type, - GVariant *setting_dict, - GVariant *connection_dict, - NMSettingParseFlags parse_flags, - GError **error) -{ - gs_unref_ptrarray GPtrArray *keys_keep_variant = NULL; - gs_unref_object NMSetting *setting = NULL; - gs_unref_hashtable GHashTable *keys = NULL; - - g_return_val_if_fail (G_TYPE_IS_INSTANTIATABLE (setting_type), NULL); - g_return_val_if_fail (g_variant_is_of_type (setting_dict, NM_VARIANT_TYPE_SETTING), NULL); - - nm_assert (!NM_FLAGS_ANY (parse_flags, ~NM_SETTING_PARSE_FLAGS_ALL)); - nm_assert (!NM_FLAGS_ALL (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT | NM_SETTING_PARSE_FLAGS_BEST_EFFORT)); - - /* connection_dict is not technically optional, but some tests in test-general - * don't bother with it in cases where they know it's not needed. - */ - if (connection_dict) - g_return_val_if_fail (g_variant_is_of_type (connection_dict, NM_VARIANT_TYPE_CONNECTION), NULL); - - /* Build the setting object from the properties we know about; we assume - * that any propreties in @setting_dict that we don't know about can - * either be ignored or else has a backward-compatibility equivalent - * that we do know about. - */ - setting = (NMSetting *) g_object_new (setting_type, NULL); - - if (NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) { - GVariantIter iter; - GVariant *entry, *entry_key; - const char *key; - - keys_keep_variant = g_ptr_array_new_with_free_func ((GDestroyNotify) g_variant_unref); - keys = g_hash_table_new (nm_str_hash, g_str_equal); - - g_variant_iter_init (&iter, setting_dict); - while ((entry = g_variant_iter_next_value (&iter))) { - entry_key = g_variant_get_child_value (entry, 0); - g_ptr_array_add (keys_keep_variant, entry_key); - g_variant_unref (entry); - - key = g_variant_get_string (entry_key, NULL); - if (!g_hash_table_add (keys, (char *) key)) { - g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_SETTING, - _("duplicate property")); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), key); - return NULL; - } - } - } - - if (!NM_SETTING_GET_CLASS (setting)->init_from_dbus (setting, - keys, - setting_dict, - connection_dict, - parse_flags, - error)) - return NULL; - - if ( NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT) - && g_hash_table_size (keys) > 0) { - GHashTableIter iter; - const char *key; - - g_hash_table_iter_init (&iter, keys); - if (g_hash_table_iter_next (&iter, (gpointer *) &key, NULL)) { - g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, - _("unknown property")); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), key); - return NULL; - } - } - - return g_steal_pointer (&setting); +_nm_setting_new_from_dbus(GType setting_type, + GVariant * setting_dict, + GVariant * connection_dict, + NMSettingParseFlags parse_flags, + GError ** error) +{ + gs_unref_ptrarray GPtrArray *keys_keep_variant = NULL; + gs_unref_object NMSetting *setting = NULL; + gs_unref_hashtable GHashTable *keys = NULL; + + g_return_val_if_fail(G_TYPE_IS_INSTANTIATABLE(setting_type), NULL); + g_return_val_if_fail(g_variant_is_of_type(setting_dict, NM_VARIANT_TYPE_SETTING), NULL); + + nm_assert(!NM_FLAGS_ANY(parse_flags, ~NM_SETTING_PARSE_FLAGS_ALL)); + nm_assert(!NM_FLAGS_ALL(parse_flags, + NM_SETTING_PARSE_FLAGS_STRICT | NM_SETTING_PARSE_FLAGS_BEST_EFFORT)); + + /* connection_dict is not technically optional, but some tests in test-general + * don't bother with it in cases where they know it's not needed. + */ + if (connection_dict) + g_return_val_if_fail(g_variant_is_of_type(connection_dict, NM_VARIANT_TYPE_CONNECTION), + NULL); + + /* Build the setting object from the properties we know about; we assume + * that any propreties in @setting_dict that we don't know about can + * either be ignored or else has a backward-compatibility equivalent + * that we do know about. + */ + setting = (NMSetting *) g_object_new(setting_type, NULL); + + if (NM_FLAGS_HAS(parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) { + GVariantIter iter; + GVariant * entry, *entry_key; + const char * key; + + keys_keep_variant = g_ptr_array_new_with_free_func((GDestroyNotify) g_variant_unref); + keys = g_hash_table_new(nm_str_hash, g_str_equal); + + g_variant_iter_init(&iter, setting_dict); + while ((entry = g_variant_iter_next_value(&iter))) { + entry_key = g_variant_get_child_value(entry, 0); + g_ptr_array_add(keys_keep_variant, entry_key); + g_variant_unref(entry); + + key = g_variant_get_string(entry_key, NULL); + if (!g_hash_table_add(keys, (char *) key)) { + g_set_error(error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_INVALID_SETTING, + _("duplicate property")); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), key); + return NULL; + } + } + } + + if (!NM_SETTING_GET_CLASS(setting) + ->init_from_dbus(setting, keys, setting_dict, connection_dict, parse_flags, error)) + return NULL; + + if (NM_FLAGS_HAS(parse_flags, NM_SETTING_PARSE_FLAGS_STRICT) && g_hash_table_size(keys) > 0) { + GHashTableIter iter; + const char * key; + + g_hash_table_iter_init(&iter, keys); + if (g_hash_table_iter_next(&iter, (gpointer *) &key, NULL)) { + g_set_error(error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_INVALID_PROPERTY, + _("unknown property")); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), key); + return NULL; + } + } + + return g_steal_pointer(&setting); } static gboolean -init_from_dbus (NMSetting *setting, - GHashTable *keys, - GVariant *setting_dict, - GVariant *connection_dict, - guint /* NMSettingParseFlags */ parse_flags, - GError **error) -{ - const NMSettInfoSetting *sett_info; - - guint i; - - nm_assert (NM_IS_SETTING (setting)); - nm_assert (!NM_FLAGS_ANY (parse_flags, ~NM_SETTING_PARSE_FLAGS_ALL)); - nm_assert (!NM_FLAGS_ALL (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT | NM_SETTING_PARSE_FLAGS_BEST_EFFORT)); - - sett_info = _nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (setting)); - - if (sett_info->detail.gendata_info) { - GHashTable *hash; - GVariantIter iter; - char *key; - GVariant *val; - - hash = _gendata_hash (setting, TRUE)->hash; - - g_variant_iter_init (&iter, setting_dict); - while (g_variant_iter_next (&iter, "{sv}", &key, &val)) { - g_hash_table_insert (hash, - key, - val); - if (keys) - g_hash_table_remove (keys, key); - } - - _nm_setting_option_notify (setting, TRUE); - - /* Currently, only NMSettingEthtool supports gendata based options, and - * that one has no other properties (except "name"). That means, we - * consumed all options above. - * - * In the future it may be interesting to have settings that are both - * based on gendata and regular properties. In that case, we would need - * to handle this case differently. */ - nm_assert (nm_streq (G_OBJECT_TYPE_NAME (setting), "NMSettingEthtool")); - nm_assert (sett_info->property_infos_len == 1); - - return TRUE; - } - - for (i = 0; i < sett_info->property_infos_len; i++) { - const NMSettInfoProperty *property_info = &sett_info->property_infos[i]; - gs_unref_variant GVariant *value = NULL; - gs_free_error GError *local = NULL; - - if ( property_info->param_spec - && !(property_info->param_spec->flags & G_PARAM_WRITABLE)) - continue; - - value = g_variant_lookup_value (setting_dict, property_info->name, NULL); - - if ( value - && keys) - g_hash_table_remove (keys, property_info->name); - - if ( value - && property_info->property_type->from_dbus_fcn) { - - if (!g_variant_type_equal (g_variant_get_type (value), property_info->property_type->dbus_type)) { - /* for backward behavior, fail unless best-effort is chosen. */ - if (NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_BEST_EFFORT)) - continue; - g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, - _("can't set property of type '%s' from value of type '%s'"), - property_info->property_type->dbus_type ? - g_variant_type_peek_string (property_info->property_type->dbus_type) : - property_info->param_spec ? - g_type_name (property_info->param_spec->value_type) : "(unknown)", - g_variant_get_type_string (value)); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), property_info->name); - return FALSE; - } - - if (!property_info->property_type->from_dbus_fcn (setting, - connection_dict, - property_info->name, - value, - parse_flags, - &local)) { - if (!NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) - continue; - g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, - _("failed to set property: %s"), - local->message); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), property_info->name); - return FALSE; - } - } else if ( !value - && property_info->property_type->missing_from_dbus_fcn) { - if (!property_info->property_type->missing_from_dbus_fcn (setting, - connection_dict, - property_info->name, - parse_flags, - &local)) { - if (!NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) - continue; - g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, - _("failed to set property: %s"), - local->message); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), property_info->name); - return FALSE; - } - } else if ( value - && property_info->param_spec) { - nm_auto_unset_gvalue GValue object_value = G_VALUE_INIT; - - g_value_init (&object_value, property_info->param_spec->value_type); - if (!set_property_from_dbus (property_info, value, &object_value)) { - /* for backward behavior, fail unless best-effort is chosen. */ - if (NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_BEST_EFFORT)) - continue; - g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, - _("can't set property of type '%s' from value of type '%s'"), - property_info->property_type->dbus_type - ? g_variant_type_peek_string (property_info->property_type->dbus_type) - : ( property_info->param_spec - ? g_type_name (property_info->param_spec->value_type) - : "(unknown)"), - g_variant_get_type_string (value)); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), property_info->name); - return FALSE; - } - - if (!nm_g_object_set_property (G_OBJECT (setting), property_info->param_spec->name, &object_value, &local)) { - if (!NM_FLAGS_HAS (parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) - continue; - g_set_error (error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, - _("can not set property: %s"), - local->message); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), property_info->name); - return FALSE; - } - } - } - - return TRUE; +init_from_dbus(NMSetting * setting, + GHashTable * keys, + GVariant * setting_dict, + GVariant * connection_dict, + guint /* NMSettingParseFlags */ parse_flags, + GError ** error) +{ + const NMSettInfoSetting *sett_info; + + guint i; + + nm_assert(NM_IS_SETTING(setting)); + nm_assert(!NM_FLAGS_ANY(parse_flags, ~NM_SETTING_PARSE_FLAGS_ALL)); + nm_assert(!NM_FLAGS_ALL(parse_flags, + NM_SETTING_PARSE_FLAGS_STRICT | NM_SETTING_PARSE_FLAGS_BEST_EFFORT)); + + sett_info = _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(setting)); + + if (sett_info->detail.gendata_info) { + GHashTable * hash; + GVariantIter iter; + char * key; + GVariant * val; + + hash = _gendata_hash(setting, TRUE)->hash; + + g_variant_iter_init(&iter, setting_dict); + while (g_variant_iter_next(&iter, "{sv}", &key, &val)) { + g_hash_table_insert(hash, key, val); + if (keys) + g_hash_table_remove(keys, key); + } + + _nm_setting_option_notify(setting, TRUE); + + /* Currently, only NMSettingEthtool supports gendata based options, and + * that one has no other properties (except "name"). That means, we + * consumed all options above. + * + * In the future it may be interesting to have settings that are both + * based on gendata and regular properties. In that case, we would need + * to handle this case differently. */ + nm_assert(nm_streq(G_OBJECT_TYPE_NAME(setting), "NMSettingEthtool")); + nm_assert(sett_info->property_infos_len == 1); + + return TRUE; + } + + for (i = 0; i < sett_info->property_infos_len; i++) { + const NMSettInfoProperty *property_info = &sett_info->property_infos[i]; + gs_unref_variant GVariant *value = NULL; + gs_free_error GError *local = NULL; + + if (property_info->param_spec && !(property_info->param_spec->flags & G_PARAM_WRITABLE)) + continue; + + value = g_variant_lookup_value(setting_dict, property_info->name, NULL); + + if (value && keys) + g_hash_table_remove(keys, property_info->name); + + if (value && property_info->property_type->from_dbus_fcn) { + if (!g_variant_type_equal(g_variant_get_type(value), + property_info->property_type->dbus_type)) { + /* for backward behavior, fail unless best-effort is chosen. */ + if (NM_FLAGS_HAS(parse_flags, NM_SETTING_PARSE_FLAGS_BEST_EFFORT)) + continue; + g_set_error( + error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_INVALID_PROPERTY, + _("can't set property of type '%s' from value of type '%s'"), + property_info->property_type->dbus_type + ? g_variant_type_peek_string(property_info->property_type->dbus_type) + : property_info->param_spec ? g_type_name(property_info->param_spec->value_type) + : "(unknown)", + g_variant_get_type_string(value)); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), property_info->name); + return FALSE; + } + + if (!property_info->property_type->from_dbus_fcn(setting, + connection_dict, + property_info->name, + value, + parse_flags, + &local)) { + if (!NM_FLAGS_HAS(parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) + continue; + g_set_error(error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_INVALID_PROPERTY, + _("failed to set property: %s"), + local->message); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), property_info->name); + return FALSE; + } + } else if (!value && property_info->property_type->missing_from_dbus_fcn) { + if (!property_info->property_type->missing_from_dbus_fcn(setting, + connection_dict, + property_info->name, + parse_flags, + &local)) { + if (!NM_FLAGS_HAS(parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) + continue; + g_set_error(error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_INVALID_PROPERTY, + _("failed to set property: %s"), + local->message); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), property_info->name); + return FALSE; + } + } else if (value && property_info->param_spec) { + nm_auto_unset_gvalue GValue object_value = G_VALUE_INIT; + + g_value_init(&object_value, property_info->param_spec->value_type); + if (!set_property_from_dbus(property_info, value, &object_value)) { + /* for backward behavior, fail unless best-effort is chosen. */ + if (NM_FLAGS_HAS(parse_flags, NM_SETTING_PARSE_FLAGS_BEST_EFFORT)) + continue; + g_set_error( + error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_INVALID_PROPERTY, + _("can't set property of type '%s' from value of type '%s'"), + property_info->property_type->dbus_type + ? g_variant_type_peek_string(property_info->property_type->dbus_type) + : (property_info->param_spec + ? g_type_name(property_info->param_spec->value_type) + : "(unknown)"), + g_variant_get_type_string(value)); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), property_info->name); + return FALSE; + } + + if (!nm_g_object_set_property(G_OBJECT(setting), + property_info->param_spec->name, + &object_value, + &local)) { + if (!NM_FLAGS_HAS(parse_flags, NM_SETTING_PARSE_FLAGS_STRICT)) + continue; + g_set_error(error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_INVALID_PROPERTY, + _("can not set property: %s"), + local->message); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), property_info->name); + return FALSE; + } + } + } + + return TRUE; } /** @@ -997,132 +1015,123 @@ init_from_dbus (NMSetting *setting, * Returns: the D-Bus marshalling type of @property on @setting. */ const GVariantType * -nm_setting_get_dbus_property_type (NMSetting *setting, - const char *property_name) +nm_setting_get_dbus_property_type(NMSetting *setting, const char *property_name) { - const NMSettInfoProperty *property; + const NMSettInfoProperty *property; - g_return_val_if_fail (NM_IS_SETTING (setting), NULL); - g_return_val_if_fail (property_name != NULL, NULL); + g_return_val_if_fail(NM_IS_SETTING(setting), NULL); + g_return_val_if_fail(property_name != NULL, NULL); - property = _nm_setting_class_get_property_info (NM_SETTING_GET_CLASS (setting), property_name); + property = _nm_setting_class_get_property_info(NM_SETTING_GET_CLASS(setting), property_name); - g_return_val_if_fail (property != NULL, NULL); + g_return_val_if_fail(property != NULL, NULL); - nm_assert (property->property_type); - nm_assert (g_variant_type_string_is_valid ((const char *) property->property_type->dbus_type)); + nm_assert(property->property_type); + nm_assert(g_variant_type_string_is_valid((const char *) property->property_type->dbus_type)); - return property->property_type->dbus_type; + return property->property_type->dbus_type; } gboolean -_nm_setting_get_property (NMSetting *setting, const char *property_name, GValue *value) +_nm_setting_get_property(NMSetting *setting, const char *property_name, GValue *value) { - const NMSettInfoSetting *sett_info; - const NMSettInfoProperty *property_info; + const NMSettInfoSetting * sett_info; + const NMSettInfoProperty *property_info; - g_return_val_if_fail (NM_IS_SETTING (setting), FALSE); - g_return_val_if_fail (property_name, FALSE); - g_return_val_if_fail (value, FALSE); + g_return_val_if_fail(NM_IS_SETTING(setting), FALSE); + g_return_val_if_fail(property_name, FALSE); + g_return_val_if_fail(value, FALSE); - sett_info = _nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (setting)); + sett_info = _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(setting)); - if (sett_info->detail.gendata_info) { - GVariant *variant; - GenData *gendata = _gendata_hash (setting, FALSE); + if (sett_info->detail.gendata_info) { + GVariant *variant; + GenData * gendata = _gendata_hash(setting, FALSE); - variant = gendata ? g_hash_table_lookup (gendata->hash, property_name) : NULL; + variant = gendata ? g_hash_table_lookup(gendata->hash, property_name) : NULL; - if (!variant) { - g_value_unset (value); - return FALSE; - } + if (!variant) { + g_value_unset(value); + return FALSE; + } - g_value_init (value, G_TYPE_VARIANT); - g_value_set_variant (value, variant); - return TRUE; - } + g_value_init(value, G_TYPE_VARIANT); + g_value_set_variant(value, variant); + return TRUE; + } - property_info = _nm_sett_info_setting_get_property_info (sett_info, property_name); - if ( !property_info - || !property_info->param_spec) { - g_value_unset (value); - return FALSE; - } + property_info = _nm_sett_info_setting_get_property_info(sett_info, property_name); + if (!property_info || !property_info->param_spec) { + g_value_unset(value); + return FALSE; + } - g_value_init (value, property_info->param_spec->value_type); - g_object_get_property (G_OBJECT (setting), property_name, value); - return TRUE; + g_value_init(value, property_info->param_spec->value_type); + g_object_get_property(G_OBJECT(setting), property_name, value); + return TRUE; } static void -_gobject_copy_property (GObject *src, - GObject *dst, - const char *property_name, - GType gtype) +_gobject_copy_property(GObject *src, GObject *dst, const char *property_name, GType gtype) { - nm_auto_unset_gvalue GValue value = G_VALUE_INIT; + nm_auto_unset_gvalue GValue value = G_VALUE_INIT; - nm_assert (G_IS_OBJECT (src)); - nm_assert (G_IS_OBJECT (dst)); + nm_assert(G_IS_OBJECT(src)); + nm_assert(G_IS_OBJECT(dst)); - g_value_init (&value, gtype); - g_object_get_property (src, property_name, &value); - g_object_set_property (dst, property_name, &value); + g_value_init(&value, gtype); + g_object_get_property(src, property_name, &value); + g_object_set_property(dst, property_name, &value); } static void -duplicate_copy_properties (const NMSettInfoSetting *sett_info, - NMSetting *src, - NMSetting *dst) -{ - if (sett_info->detail.gendata_info) { - GenData *gendata = _gendata_hash (src, FALSE); - - nm_assert (!_gendata_hash (dst, FALSE)); - - if ( gendata - && g_hash_table_size (gendata->hash) > 0) { - GHashTableIter iter; - GHashTable *h = _gendata_hash (dst, TRUE)->hash; - const char *key; - GVariant *val; - - g_hash_table_iter_init (&iter, gendata->hash); - while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &val)) { - g_hash_table_insert (h, - g_strdup (key), - g_variant_ref (val)); - } - } - } - - if (sett_info->property_infos_len > 0) { - gboolean frozen = FALSE; - guint i; - - for (i = 0; i < sett_info->property_infos_len; i++) { - const NMSettInfoProperty *property_info = &sett_info->property_infos[i]; - - if (property_info->param_spec) { - if ((property_info->param_spec->flags & (G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)) != G_PARAM_WRITABLE) - continue; - - if (!frozen) { - g_object_freeze_notify (G_OBJECT (dst)); - frozen = TRUE; - } - _gobject_copy_property (G_OBJECT (src), - G_OBJECT (dst), - property_info->param_spec->name, - G_PARAM_SPEC_VALUE_TYPE (property_info->param_spec)); - continue; - } - } - - if (frozen) - g_object_thaw_notify (G_OBJECT (dst)); - } +duplicate_copy_properties(const NMSettInfoSetting *sett_info, NMSetting *src, NMSetting *dst) +{ + if (sett_info->detail.gendata_info) { + GenData *gendata = _gendata_hash(src, FALSE); + + nm_assert(!_gendata_hash(dst, FALSE)); + + if (gendata && g_hash_table_size(gendata->hash) > 0) { + GHashTableIter iter; + GHashTable * h = _gendata_hash(dst, TRUE)->hash; + const char * key; + GVariant * val; + + g_hash_table_iter_init(&iter, gendata->hash); + while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &val)) { + g_hash_table_insert(h, g_strdup(key), g_variant_ref(val)); + } + } + } + + if (sett_info->property_infos_len > 0) { + gboolean frozen = FALSE; + guint i; + + for (i = 0; i < sett_info->property_infos_len; i++) { + const NMSettInfoProperty *property_info = &sett_info->property_infos[i]; + + if (property_info->param_spec) { + if ((property_info->param_spec->flags & (G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY)) + != G_PARAM_WRITABLE) + continue; + + if (!frozen) { + g_object_freeze_notify(G_OBJECT(dst)); + frozen = TRUE; + } + _gobject_copy_property(G_OBJECT(src), + G_OBJECT(dst), + property_info->param_spec->name, + G_PARAM_SPEC_VALUE_TYPE(property_info->param_spec)); + continue; + } + } + + if (frozen) + g_object_thaw_notify(G_OBJECT(dst)); + } } /** @@ -1135,25 +1144,25 @@ duplicate_copy_properties (const NMSettInfoSetting *sett_info, * source #NMSetting **/ NMSetting * -nm_setting_duplicate (NMSetting *setting) +nm_setting_duplicate(NMSetting *setting) { - const NMSettInfoSetting *sett_info; - NMSettingClass *klass; - NMSetting *dst; + const NMSettInfoSetting *sett_info; + NMSettingClass * klass; + NMSetting * dst; - g_return_val_if_fail (NM_IS_SETTING (setting), NULL); + g_return_val_if_fail(NM_IS_SETTING(setting), NULL); - klass = NM_SETTING_GET_CLASS (setting); - nm_assert (NM_IS_SETTING_CLASS (klass)); - nm_assert (klass->duplicate_copy_properties); + klass = NM_SETTING_GET_CLASS(setting); + nm_assert(NM_IS_SETTING_CLASS(klass)); + nm_assert(klass->duplicate_copy_properties); - dst = g_object_new (G_TYPE_FROM_CLASS (klass), NULL); + dst = g_object_new(G_TYPE_FROM_CLASS(klass), NULL); - sett_info = _nm_setting_class_get_sett_info (klass); - nm_assert (sett_info); + sett_info = _nm_setting_class_get_sett_info(klass); + nm_assert(sett_info); - klass->duplicate_copy_properties (sett_info, setting, dst); - return dst; + klass->duplicate_copy_properties(sett_info, setting, dst); + return dst; } /** @@ -1166,14 +1175,14 @@ nm_setting_duplicate (NMSetting *setting) * like 'ppp' or 'wireless' or 'wired'. **/ const char * -nm_setting_get_name (NMSetting *setting) +nm_setting_get_name(NMSetting *setting) { - const NMMetaSettingInfo *setting_info; + const NMMetaSettingInfo *setting_info; - g_return_val_if_fail (NM_IS_SETTING (setting), NULL); + g_return_val_if_fail(NM_IS_SETTING(setting), NULL); - setting_info = NM_SETTING_GET_CLASS (setting)->setting_info; - return setting_info ? setting_info->setting_name : NULL; + setting_info = NM_SETTING_GET_CLASS(setting)->setting_info; + return setting_info ? setting_info->setting_name : NULL; } /** @@ -1191,27 +1200,27 @@ nm_setting_get_name (NMSetting *setting) * Returns: %TRUE if the setting is valid, %FALSE if it is not **/ gboolean -nm_setting_verify (NMSetting *setting, NMConnection *connection, GError **error) +nm_setting_verify(NMSetting *setting, NMConnection *connection, GError **error) { - NMSettingVerifyResult result = _nm_setting_verify (setting, connection, error); + NMSettingVerifyResult result = _nm_setting_verify(setting, connection, error); - if (result == NM_SETTING_VERIFY_NORMALIZABLE) - g_clear_error (error); + if (result == NM_SETTING_VERIFY_NORMALIZABLE) + g_clear_error(error); - return result == NM_SETTING_VERIFY_SUCCESS || result == NM_SETTING_VERIFY_NORMALIZABLE; + return result == NM_SETTING_VERIFY_SUCCESS || result == NM_SETTING_VERIFY_NORMALIZABLE; } NMSettingVerifyResult -_nm_setting_verify (NMSetting *setting, NMConnection *connection, GError **error) +_nm_setting_verify(NMSetting *setting, NMConnection *connection, GError **error) { - g_return_val_if_fail (NM_IS_SETTING (setting), NM_SETTING_VERIFY_ERROR); - g_return_val_if_fail (!connection || NM_IS_CONNECTION (connection), NM_SETTING_VERIFY_ERROR); - g_return_val_if_fail (!error || *error == NULL, NM_SETTING_VERIFY_ERROR); + g_return_val_if_fail(NM_IS_SETTING(setting), NM_SETTING_VERIFY_ERROR); + g_return_val_if_fail(!connection || NM_IS_CONNECTION(connection), NM_SETTING_VERIFY_ERROR); + g_return_val_if_fail(!error || *error == NULL, NM_SETTING_VERIFY_ERROR); - if (NM_SETTING_GET_CLASS (setting)->verify) - return NM_SETTING_GET_CLASS (setting)->verify (setting, connection, error); + if (NM_SETTING_GET_CLASS(setting)->verify) + return NM_SETTING_GET_CLASS(setting)->verify(setting, connection, error); - return NM_SETTING_VERIFY_SUCCESS; + return NM_SETTING_VERIFY_SUCCESS; } /** @@ -1232,194 +1241,200 @@ _nm_setting_verify (NMSetting *setting, NMConnection *connection, GError **error * Since: 1.2 **/ gboolean -nm_setting_verify_secrets (NMSetting *setting, NMConnection *connection, GError **error) +nm_setting_verify_secrets(NMSetting *setting, NMConnection *connection, GError **error) { - g_return_val_if_fail (NM_IS_SETTING (setting), NM_SETTING_VERIFY_ERROR); - g_return_val_if_fail (!connection || NM_IS_CONNECTION (connection), NM_SETTING_VERIFY_ERROR); - g_return_val_if_fail (!error || *error == NULL, NM_SETTING_VERIFY_ERROR); + g_return_val_if_fail(NM_IS_SETTING(setting), NM_SETTING_VERIFY_ERROR); + g_return_val_if_fail(!connection || NM_IS_CONNECTION(connection), NM_SETTING_VERIFY_ERROR); + g_return_val_if_fail(!error || *error == NULL, NM_SETTING_VERIFY_ERROR); - if (NM_SETTING_GET_CLASS (setting)->verify_secrets) - return NM_SETTING_GET_CLASS (setting)->verify_secrets (setting, connection, error); + if (NM_SETTING_GET_CLASS(setting)->verify_secrets) + return NM_SETTING_GET_CLASS(setting)->verify_secrets(setting, connection, error); - return NM_SETTING_VERIFY_SUCCESS; + return NM_SETTING_VERIFY_SUCCESS; } gboolean -_nm_setting_verify_secret_string (const char *str, - const char *setting_name, - const char *property, - GError **error) -{ - if (str && !*str) { - g_set_error_literal (error, - NM_CONNECTION_ERROR, - NM_CONNECTION_ERROR_INVALID_PROPERTY, - _("property is empty")); - g_prefix_error (error, "%s.%s: ", setting_name, property); - return FALSE; - } - return TRUE; +_nm_setting_verify_secret_string(const char *str, + const char *setting_name, + const char *property, + GError ** error) +{ + if (str && !*str) { + g_set_error_literal(error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_INVALID_PROPERTY, + _("property is empty")); + g_prefix_error(error, "%s.%s: ", setting_name, property); + return FALSE; + } + return TRUE; } gboolean -_nm_setting_should_compare_secret_property (NMSetting *setting, - NMSetting *other, - const char *secret_name, - NMSettingCompareFlags flags) -{ - NMSettingSecretFlags a_secret_flags = NM_SETTING_SECRET_FLAG_NONE; - NMSettingSecretFlags b_secret_flags = NM_SETTING_SECRET_FLAG_NONE; - - nm_assert (NM_IS_SETTING (setting)); - nm_assert (!other || G_OBJECT_TYPE (setting) == G_OBJECT_TYPE (other)); - - /* secret_name must be a valid secret for @setting. */ - nm_assert (nm_setting_get_secret_flags (setting, secret_name, NULL, NULL)); - - if (!NM_FLAGS_ANY (flags, NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS - | NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS)) - return TRUE; - - nm_setting_get_secret_flags (setting, secret_name, &a_secret_flags, NULL); - if (other) { - if (!nm_setting_get_secret_flags (other, secret_name, &b_secret_flags, NULL)) { - /* secret-name may not be a valid secret for @other. That is fine, we ignore that - * and treat @b_secret_flags as NM_SETTING_SECRET_FLAG_NONE. - * - * This can happen with VPN secrets, where the caller knows that @secret_name - * is a secret for setting, but it may not be a secret for @other. Accept that. - * - * Mark @other as missing. */ - other = NULL; - } - } - - /* when @setting has the secret-flags that should be ignored, - * we skip the comparison if: - * - * - @other is not present, - * - @other does not have a secret named @secret_name - * - @other also has the secret flat to be ignored. - * - * This makes the check symmetric (aside the fact that @setting must - * have the secret while @other may not -- which is asymmetric). */ - if ( NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS) - && NM_FLAGS_HAS (a_secret_flags, NM_SETTING_SECRET_FLAG_AGENT_OWNED) - && ( !other - || NM_FLAGS_HAS (b_secret_flags, NM_SETTING_SECRET_FLAG_AGENT_OWNED))) - return FALSE; - - if ( NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS) - && NM_FLAGS_HAS (a_secret_flags, NM_SETTING_SECRET_FLAG_NOT_SAVED) - && ( !other - || NM_FLAGS_HAS (b_secret_flags, NM_SETTING_SECRET_FLAG_NOT_SAVED))) - return FALSE; - - return TRUE; +_nm_setting_should_compare_secret_property(NMSetting * setting, + NMSetting * other, + const char * secret_name, + NMSettingCompareFlags flags) +{ + NMSettingSecretFlags a_secret_flags = NM_SETTING_SECRET_FLAG_NONE; + NMSettingSecretFlags b_secret_flags = NM_SETTING_SECRET_FLAG_NONE; + + nm_assert(NM_IS_SETTING(setting)); + nm_assert(!other || G_OBJECT_TYPE(setting) == G_OBJECT_TYPE(other)); + + /* secret_name must be a valid secret for @setting. */ + nm_assert(nm_setting_get_secret_flags(setting, secret_name, NULL, NULL)); + + if (!NM_FLAGS_ANY(flags, + NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS + | NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS)) + return TRUE; + + nm_setting_get_secret_flags(setting, secret_name, &a_secret_flags, NULL); + if (other) { + if (!nm_setting_get_secret_flags(other, secret_name, &b_secret_flags, NULL)) { + /* secret-name may not be a valid secret for @other. That is fine, we ignore that + * and treat @b_secret_flags as NM_SETTING_SECRET_FLAG_NONE. + * + * This can happen with VPN secrets, where the caller knows that @secret_name + * is a secret for setting, but it may not be a secret for @other. Accept that. + * + * Mark @other as missing. */ + other = NULL; + } + } + + /* when @setting has the secret-flags that should be ignored, + * we skip the comparison if: + * + * - @other is not present, + * - @other does not have a secret named @secret_name + * - @other also has the secret flat to be ignored. + * + * This makes the check symmetric (aside the fact that @setting must + * have the secret while @other may not -- which is asymmetric). */ + if (NM_FLAGS_HAS(flags, NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS) + && NM_FLAGS_HAS(a_secret_flags, NM_SETTING_SECRET_FLAG_AGENT_OWNED) + && (!other || NM_FLAGS_HAS(b_secret_flags, NM_SETTING_SECRET_FLAG_AGENT_OWNED))) + return FALSE; + + if (NM_FLAGS_HAS(flags, NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS) + && NM_FLAGS_HAS(a_secret_flags, NM_SETTING_SECRET_FLAG_NOT_SAVED) + && (!other || NM_FLAGS_HAS(b_secret_flags, NM_SETTING_SECRET_FLAG_NOT_SAVED))) + return FALSE; + + return TRUE; } static NMTernary -compare_property (const NMSettInfoSetting *sett_info, - guint property_idx, - NMConnection *con_a, - NMSetting *set_a, - NMConnection *con_b, - NMSetting *set_b, - NMSettingCompareFlags flags) -{ - const NMSettInfoProperty *property_info = &sett_info->property_infos[property_idx]; - const GParamSpec *param_spec = property_info->param_spec; - - if (!param_spec) - return NM_TERNARY_DEFAULT; - - if ( NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_FUZZY) - && NM_FLAGS_ANY (param_spec->flags, NM_SETTING_PARAM_FUZZY_IGNORE | NM_SETTING_PARAM_SECRET)) - return NM_TERNARY_DEFAULT; - - if ( NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_INFERRABLE) - && !NM_FLAGS_HAS (param_spec->flags, NM_SETTING_PARAM_INFERRABLE)) - return NM_TERNARY_DEFAULT; - - if ( NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_IGNORE_REAPPLY_IMMEDIATELY) - && NM_FLAGS_HAS (param_spec->flags, NM_SETTING_PARAM_REAPPLY_IMMEDIATELY)) - return NM_TERNARY_DEFAULT; - - if ( NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS) - && NM_FLAGS_HAS (param_spec->flags, NM_SETTING_PARAM_SECRET)) - return NM_TERNARY_DEFAULT; - - if (nm_streq (param_spec->name, NM_SETTING_NAME)) - return NM_TERNARY_DEFAULT; - - if ( NM_FLAGS_HAS (param_spec->flags, NM_SETTING_PARAM_SECRET) - && !_nm_setting_should_compare_secret_property (set_a, - set_b, - param_spec->name, - flags)) - return NM_TERNARY_DEFAULT; - - if (set_b) { - gs_unref_variant GVariant *value1 = NULL; - gs_unref_variant GVariant *value2 = NULL; - - value1 = property_to_dbus (sett_info, property_idx, con_a, set_a, NM_CONNECTION_SERIALIZE_ALL, NULL, TRUE, TRUE); - value2 = property_to_dbus (sett_info, property_idx, con_b, set_b, NM_CONNECTION_SERIALIZE_ALL, NULL, TRUE, TRUE); - if (nm_property_compare (value1, value2) != 0) - return NM_TERNARY_FALSE; - } - - return NM_TERNARY_TRUE; +compare_property(const NMSettInfoSetting *sett_info, + guint property_idx, + NMConnection * con_a, + NMSetting * set_a, + NMConnection * con_b, + NMSetting * set_b, + NMSettingCompareFlags flags) +{ + const NMSettInfoProperty *property_info = &sett_info->property_infos[property_idx]; + const GParamSpec * param_spec = property_info->param_spec; + + if (!param_spec) + return NM_TERNARY_DEFAULT; + + if (NM_FLAGS_HAS(flags, NM_SETTING_COMPARE_FLAG_FUZZY) + && NM_FLAGS_ANY(param_spec->flags, NM_SETTING_PARAM_FUZZY_IGNORE | NM_SETTING_PARAM_SECRET)) + return NM_TERNARY_DEFAULT; + + if (NM_FLAGS_HAS(flags, NM_SETTING_COMPARE_FLAG_INFERRABLE) + && !NM_FLAGS_HAS(param_spec->flags, NM_SETTING_PARAM_INFERRABLE)) + return NM_TERNARY_DEFAULT; + + if (NM_FLAGS_HAS(flags, NM_SETTING_COMPARE_FLAG_IGNORE_REAPPLY_IMMEDIATELY) + && NM_FLAGS_HAS(param_spec->flags, NM_SETTING_PARAM_REAPPLY_IMMEDIATELY)) + return NM_TERNARY_DEFAULT; + + if (NM_FLAGS_HAS(flags, NM_SETTING_COMPARE_FLAG_IGNORE_SECRETS) + && NM_FLAGS_HAS(param_spec->flags, NM_SETTING_PARAM_SECRET)) + return NM_TERNARY_DEFAULT; + + if (nm_streq(param_spec->name, NM_SETTING_NAME)) + return NM_TERNARY_DEFAULT; + + if (NM_FLAGS_HAS(param_spec->flags, NM_SETTING_PARAM_SECRET) + && !_nm_setting_should_compare_secret_property(set_a, set_b, param_spec->name, flags)) + return NM_TERNARY_DEFAULT; + + if (set_b) { + gs_unref_variant GVariant *value1 = NULL; + gs_unref_variant GVariant *value2 = NULL; + + value1 = property_to_dbus(sett_info, + property_idx, + con_a, + set_a, + NM_CONNECTION_SERIALIZE_ALL, + NULL, + TRUE, + TRUE); + value2 = property_to_dbus(sett_info, + property_idx, + con_b, + set_b, + NM_CONNECTION_SERIALIZE_ALL, + NULL, + TRUE, + TRUE); + if (nm_property_compare(value1, value2) != 0) + return NM_TERNARY_FALSE; + } + + return NM_TERNARY_TRUE; } static NMTernary -_compare_property (const NMSettInfoSetting *sett_info, - guint property_idx, - NMConnection *con_a, - NMSetting *set_a, - NMConnection *con_b, - NMSetting *set_b, - NMSettingCompareFlags flags) -{ - NMTernary compare_result; - - nm_assert (sett_info); - nm_assert (NM_IS_SETTING_CLASS (sett_info->setting_class)); - nm_assert (property_idx < sett_info->property_infos_len); - nm_assert (NM_SETTING_GET_CLASS (set_a) == sett_info->setting_class); - nm_assert (!set_b || NM_SETTING_GET_CLASS (set_b) == sett_info->setting_class); - - compare_result = NM_SETTING_GET_CLASS (set_a)->compare_property (sett_info, - property_idx, - con_a, - set_a, - con_b, - set_b, - flags); - - nm_assert (NM_IN_SET (compare_result, NM_TERNARY_DEFAULT, - NM_TERNARY_FALSE, - NM_TERNARY_TRUE)); - - /* check that the inferable flag and the GObject property flag corresponds. */ - nm_assert ( !NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_INFERRABLE) - || !sett_info->property_infos[property_idx].param_spec - || NM_FLAGS_HAS (sett_info->property_infos[property_idx].param_spec->flags, NM_SETTING_PARAM_INFERRABLE) - || compare_result == NM_TERNARY_DEFAULT); +_compare_property(const NMSettInfoSetting *sett_info, + guint property_idx, + NMConnection * con_a, + NMSetting * set_a, + NMConnection * con_b, + NMSetting * set_b, + NMSettingCompareFlags flags) +{ + NMTernary compare_result; + + nm_assert(sett_info); + nm_assert(NM_IS_SETTING_CLASS(sett_info->setting_class)); + nm_assert(property_idx < sett_info->property_infos_len); + nm_assert(NM_SETTING_GET_CLASS(set_a) == sett_info->setting_class); + nm_assert(!set_b || NM_SETTING_GET_CLASS(set_b) == sett_info->setting_class); + + compare_result = + NM_SETTING_GET_CLASS(set_a) + ->compare_property(sett_info, property_idx, con_a, set_a, con_b, set_b, flags); + + nm_assert(NM_IN_SET(compare_result, NM_TERNARY_DEFAULT, NM_TERNARY_FALSE, NM_TERNARY_TRUE)); + + /* check that the inferable flag and the GObject property flag corresponds. */ + nm_assert(!NM_FLAGS_HAS(flags, NM_SETTING_COMPARE_FLAG_INFERRABLE) + || !sett_info->property_infos[property_idx].param_spec + || NM_FLAGS_HAS(sett_info->property_infos[property_idx].param_spec->flags, + NM_SETTING_PARAM_INFERRABLE) + || compare_result == NM_TERNARY_DEFAULT); #if NM_MORE_ASSERTS > 10 - /* assert that compare_property() is symeric. */ - nm_assert ( !set_b - || compare_result == NM_SETTING_GET_CLASS (set_a)->compare_property (sett_info, - property_idx, - con_b, - set_b, - con_a, - set_a, - flags)); + /* assert that compare_property() is symeric. */ + nm_assert(!set_b + || compare_result + == NM_SETTING_GET_CLASS(set_a)->compare_property(sett_info, + property_idx, + con_b, + set_b, + con_a, + set_a, + flags)); #endif - return compare_result; + return compare_result; } /** @@ -1435,66 +1450,66 @@ _compare_property (const NMSettInfoSetting *sett_info, * Returns: %TRUE if the comparison succeeds, %FALSE if it does not **/ gboolean -nm_setting_compare (NMSetting *a, - NMSetting *b, - NMSettingCompareFlags flags) +nm_setting_compare(NMSetting *a, NMSetting *b, NMSettingCompareFlags flags) { - return _nm_setting_compare (NULL, a, NULL, b, flags); + return _nm_setting_compare(NULL, a, NULL, b, flags); } gboolean -_nm_setting_compare (NMConnection *con_a, - NMSetting *a, - NMConnection *con_b, - NMSetting *b, - NMSettingCompareFlags flags) +_nm_setting_compare(NMConnection * con_a, + NMSetting * a, + NMConnection * con_b, + NMSetting * b, + NMSettingCompareFlags flags) { - const NMSettInfoSetting *sett_info; - guint i; + const NMSettInfoSetting *sett_info; + guint i; - g_return_val_if_fail (NM_IS_SETTING (a), FALSE); - g_return_val_if_fail (NM_IS_SETTING (b), FALSE); + g_return_val_if_fail(NM_IS_SETTING(a), FALSE); + g_return_val_if_fail(NM_IS_SETTING(b), FALSE); - nm_assert (!con_a || NM_IS_CONNECTION (con_a)); - nm_assert (!con_b || NM_IS_CONNECTION (con_b)); + nm_assert(!con_a || NM_IS_CONNECTION(con_a)); + nm_assert(!con_b || NM_IS_CONNECTION(con_b)); - /* First check that both have the same type */ - if (G_OBJECT_TYPE (a) != G_OBJECT_TYPE (b)) - return FALSE; + /* First check that both have the same type */ + if (G_OBJECT_TYPE(a) != G_OBJECT_TYPE(b)) + return FALSE; - sett_info = _nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (a)); + sett_info = _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(a)); - if (sett_info->detail.gendata_info) { - GenData *a_gendata = _gendata_hash (a, FALSE); - GenData *b_gendata = _gendata_hash (b, FALSE); + if (sett_info->detail.gendata_info) { + GenData *a_gendata = _gendata_hash(a, FALSE); + GenData *b_gendata = _gendata_hash(b, FALSE); - return nm_utils_hash_table_equal (a_gendata ? a_gendata->hash : NULL, - b_gendata ? b_gendata->hash : NULL, - TRUE, - g_variant_equal); - } + return nm_utils_hash_table_equal(a_gendata ? a_gendata->hash : NULL, + b_gendata ? b_gendata->hash : NULL, + TRUE, + g_variant_equal); + } - for (i = 0; i < sett_info->property_infos_len; i++) { - if (_compare_property (sett_info, i, con_a, a, con_b, b, flags) == NM_TERNARY_FALSE) - return FALSE; - } + for (i = 0; i < sett_info->property_infos_len; i++) { + if (_compare_property(sett_info, i, con_a, a, con_b, b, flags) == NM_TERNARY_FALSE) + return FALSE; + } - return TRUE; + return TRUE; } static void -_setting_diff_add_result (GHashTable *results, const char *prop_name, NMSettingDiffResult r) +_setting_diff_add_result(GHashTable *results, const char *prop_name, NMSettingDiffResult r) { - void *p; + void *p; - if (r == NM_SETTING_DIFF_RESULT_UNKNOWN) - return; + if (r == NM_SETTING_DIFF_RESULT_UNKNOWN) + return; - if (g_hash_table_lookup_extended (results, prop_name, NULL, &p)) { - if (!NM_FLAGS_ALL ((guint) r, GPOINTER_TO_UINT (p))) - g_hash_table_insert (results, g_strdup (prop_name), GUINT_TO_POINTER (((guint) r) | GPOINTER_TO_UINT (p))); - } else - g_hash_table_insert (results, g_strdup (prop_name), GUINT_TO_POINTER (r)); + if (g_hash_table_lookup_extended(results, prop_name, NULL, &p)) { + if (!NM_FLAGS_ALL((guint) r, GPOINTER_TO_UINT(p))) + g_hash_table_insert(results, + g_strdup(prop_name), + GUINT_TO_POINTER(((guint) r) | GPOINTER_TO_UINT(p))); + } else + g_hash_table_insert(results, g_strdup(prop_name), GUINT_TO_POINTER(r)); } /** @@ -1519,248 +1534,254 @@ _setting_diff_add_result (GHashTable *results, const char *prop_name, NMSettingD * Returns: %TRUE if the settings contain the same values, %FALSE if they do not **/ gboolean -nm_setting_diff (NMSetting *a, - NMSetting *b, - NMSettingCompareFlags flags, - gboolean invert_results, - GHashTable **results) +nm_setting_diff(NMSetting * a, + NMSetting * b, + NMSettingCompareFlags flags, + gboolean invert_results, + GHashTable ** results) { - return _nm_setting_diff (NULL, a, NULL, b, flags, invert_results, results); + return _nm_setting_diff(NULL, a, NULL, b, flags, invert_results, results); } gboolean -_nm_setting_diff (NMConnection *con_a, - NMSetting *a, - NMConnection *con_b, - NMSetting *b, - NMSettingCompareFlags flags, - gboolean invert_results, - GHashTable **results) -{ - const NMSettInfoSetting *sett_info; - guint i; - NMSettingDiffResult a_result = NM_SETTING_DIFF_RESULT_IN_A; - NMSettingDiffResult b_result = NM_SETTING_DIFF_RESULT_IN_B; - NMSettingDiffResult a_result_default = NM_SETTING_DIFF_RESULT_IN_A_DEFAULT; - NMSettingDiffResult b_result_default = NM_SETTING_DIFF_RESULT_IN_B_DEFAULT; - gboolean results_created = FALSE; - gboolean compared_any = FALSE; - gboolean diff_found = FALSE; - - g_return_val_if_fail (results != NULL, FALSE); - g_return_val_if_fail (NM_IS_SETTING (a), FALSE); - if (b) { - g_return_val_if_fail (NM_IS_SETTING (b), FALSE); - g_return_val_if_fail (G_OBJECT_TYPE (a) == G_OBJECT_TYPE (b), FALSE); - } - - nm_assert (!con_a || NM_IS_CONNECTION (con_a)); - nm_assert (!con_b || NM_IS_CONNECTION (con_b)); - - if ((flags & (NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT)) == - (NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT)) { - /* conflicting flags: default to WITH_DEFAULT (clearing NO_DEFAULT). */ - flags &= ~NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT; - } - - /* If the caller is calling this function in a pattern like this to get - * complete diffs: - * - * nm_setting_diff (A, B, FALSE, &results); - * nm_setting_diff (B, A, TRUE, &results); - * - * and wants us to invert the results so that the second invocation comes - * out correctly, do that here. - */ - if (invert_results) { - a_result = NM_SETTING_DIFF_RESULT_IN_B; - b_result = NM_SETTING_DIFF_RESULT_IN_A; - a_result_default = NM_SETTING_DIFF_RESULT_IN_B_DEFAULT; - b_result_default = NM_SETTING_DIFF_RESULT_IN_A_DEFAULT; - } - - if (*results == NULL) { - *results = g_hash_table_new_full (nm_str_hash, g_str_equal, g_free, NULL); - results_created = TRUE; - } - - sett_info = _nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (a)); - - if (sett_info->detail.gendata_info) { - const char *key; - GVariant *val, *val2; - GHashTableIter iter; - GenData *a_gendata = _gendata_hash (a, FALSE); - GenData *b_gendata = b ? _gendata_hash (b, FALSE) : NULL; - - if (!a_gendata || !b_gendata) { - if (a_gendata || b_gendata) { - NMSettingDiffResult one_sided_result; - - one_sided_result = a_gendata ? a_result : b_result; - g_hash_table_iter_init (&iter, a_gendata ? a_gendata->hash : b_gendata->hash); - while (g_hash_table_iter_next (&iter, (gpointer *) &key, NULL)) { - diff_found = TRUE; - _setting_diff_add_result (*results, key, one_sided_result); - } - } - } else { - g_hash_table_iter_init (&iter, a_gendata->hash); - while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &val)) { - val2 = g_hash_table_lookup (b_gendata->hash, key); - compared_any = TRUE; - if ( !val2 - || !g_variant_equal (val, val2)) { - diff_found = TRUE; - _setting_diff_add_result (*results, key, a_result); - } - } - g_hash_table_iter_init (&iter, b_gendata->hash); - while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &val)) { - val2 = g_hash_table_lookup (a_gendata->hash, key); - compared_any = TRUE; - if ( !val2 - || !g_variant_equal (val, val2)) { - diff_found = TRUE; - _setting_diff_add_result (*results, key, b_result); - } - } - } - } else { - for (i = 0; i < sett_info->property_infos_len; i++) { - NMSettingDiffResult r = NM_SETTING_DIFF_RESULT_UNKNOWN; - const NMSettInfoProperty *property_info; - NMTernary compare_result; - GParamSpec *prop_spec; - - compare_result = _compare_property (sett_info, i, con_a, a, con_b, b, flags); - if (compare_result == NM_TERNARY_DEFAULT) - continue; - - if ( NM_FLAGS_ANY (flags, NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS - | NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS) - && b - && compare_result == NM_TERNARY_FALSE) { - /* we have setting @b and the property is not the same. But we also are instructed - * to ignore secrets based on the flags. - * - * Note that compare_property() called with two settings will ignore secrets - * based on the flags, but it will do so if *both* settings have the flag we - * look for. So that is symmetric behavior and good. - * - * But for the purpose of diff(), we do a asymmetric comparison because and - * we want to skip testing the property if setting @a alone indicates to do - * so. - * - * We need to double-check whether the property should be ignored by - * looking at @a alone. */ - if (_compare_property (sett_info, i, con_a, a, NULL, NULL, flags) == NM_TERNARY_DEFAULT) - continue; - } - - compared_any = TRUE; - - property_info = &sett_info->property_infos[i]; - prop_spec = property_info->param_spec; - - if (b) { - if (compare_result == NM_TERNARY_FALSE) { - if (prop_spec) { - gboolean a_is_default, b_is_default; - GValue value = G_VALUE_INIT; - - g_value_init (&value, prop_spec->value_type); - g_object_get_property (G_OBJECT (a), prop_spec->name, &value); - a_is_default = g_param_value_defaults (prop_spec, &value); - - g_value_reset (&value); - g_object_get_property (G_OBJECT (b), prop_spec->name, &value); - b_is_default = g_param_value_defaults (prop_spec, &value); - - g_value_unset (&value); - if (!NM_FLAGS_HAS (flags, NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT)) { - if (!a_is_default) - r |= a_result; - if (!b_is_default) - r |= b_result; - } else { - r |= a_result | b_result; - if (a_is_default) - r |= a_result_default; - if (b_is_default) - r |= b_result_default; - } - } else - r |= a_result | b_result; - } - } else if ((flags & (NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT)) == 0) - r = a_result; /* only in A */ - else { - if (prop_spec) { - GValue value = G_VALUE_INIT; - - g_value_init (&value, prop_spec->value_type); - g_object_get_property (G_OBJECT (a), prop_spec->name, &value); - if (!g_param_value_defaults (prop_spec, &value)) - r |= a_result; - else if (flags & NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT) - r |= a_result | a_result_default; - - g_value_unset (&value); - } else - r |= a_result; - } - - if (r != NM_SETTING_DIFF_RESULT_UNKNOWN) { - diff_found = TRUE; - _setting_diff_add_result (*results, property_info->name, r); - } - } - } - - if (!compared_any && !b) { - /* special case: the setting has no properties, and the opposite - * setting @b is not given. The settings differ, and we signal that - * by returning an empty results hash. */ - diff_found = TRUE; - } - - if (diff_found) { - /* if there is a difference, we always return FALSE. It also means, we might - * have allocated a new @results hash, and return it to the caller. */ - return FALSE; - } else { - if (results_created) { - /* the allocated hash is unused. Clear it again. */ - g_hash_table_destroy (*results); - *results = NULL; - } else { - /* we found no diff, and return false. However, the input - * @result is returned unmodified. */ - } - return TRUE; - } +_nm_setting_diff(NMConnection * con_a, + NMSetting * a, + NMConnection * con_b, + NMSetting * b, + NMSettingCompareFlags flags, + gboolean invert_results, + GHashTable ** results) +{ + const NMSettInfoSetting *sett_info; + guint i; + NMSettingDiffResult a_result = NM_SETTING_DIFF_RESULT_IN_A; + NMSettingDiffResult b_result = NM_SETTING_DIFF_RESULT_IN_B; + NMSettingDiffResult a_result_default = NM_SETTING_DIFF_RESULT_IN_A_DEFAULT; + NMSettingDiffResult b_result_default = NM_SETTING_DIFF_RESULT_IN_B_DEFAULT; + gboolean results_created = FALSE; + gboolean compared_any = FALSE; + gboolean diff_found = FALSE; + + g_return_val_if_fail(results != NULL, FALSE); + g_return_val_if_fail(NM_IS_SETTING(a), FALSE); + if (b) { + g_return_val_if_fail(NM_IS_SETTING(b), FALSE); + g_return_val_if_fail(G_OBJECT_TYPE(a) == G_OBJECT_TYPE(b), FALSE); + } + + nm_assert(!con_a || NM_IS_CONNECTION(con_a)); + nm_assert(!con_b || NM_IS_CONNECTION(con_b)); + + if ((flags + & (NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT + | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT)) + == (NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT + | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT)) { + /* conflicting flags: default to WITH_DEFAULT (clearing NO_DEFAULT). */ + flags &= ~NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT; + } + + /* If the caller is calling this function in a pattern like this to get + * complete diffs: + * + * nm_setting_diff (A, B, FALSE, &results); + * nm_setting_diff (B, A, TRUE, &results); + * + * and wants us to invert the results so that the second invocation comes + * out correctly, do that here. + */ + if (invert_results) { + a_result = NM_SETTING_DIFF_RESULT_IN_B; + b_result = NM_SETTING_DIFF_RESULT_IN_A; + a_result_default = NM_SETTING_DIFF_RESULT_IN_B_DEFAULT; + b_result_default = NM_SETTING_DIFF_RESULT_IN_A_DEFAULT; + } + + if (*results == NULL) { + *results = g_hash_table_new_full(nm_str_hash, g_str_equal, g_free, NULL); + results_created = TRUE; + } + + sett_info = _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(a)); + + if (sett_info->detail.gendata_info) { + const char * key; + GVariant * val, *val2; + GHashTableIter iter; + GenData * a_gendata = _gendata_hash(a, FALSE); + GenData * b_gendata = b ? _gendata_hash(b, FALSE) : NULL; + + if (!a_gendata || !b_gendata) { + if (a_gendata || b_gendata) { + NMSettingDiffResult one_sided_result; + + one_sided_result = a_gendata ? a_result : b_result; + g_hash_table_iter_init(&iter, a_gendata ? a_gendata->hash : b_gendata->hash); + while (g_hash_table_iter_next(&iter, (gpointer *) &key, NULL)) { + diff_found = TRUE; + _setting_diff_add_result(*results, key, one_sided_result); + } + } + } else { + g_hash_table_iter_init(&iter, a_gendata->hash); + while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &val)) { + val2 = g_hash_table_lookup(b_gendata->hash, key); + compared_any = TRUE; + if (!val2 || !g_variant_equal(val, val2)) { + diff_found = TRUE; + _setting_diff_add_result(*results, key, a_result); + } + } + g_hash_table_iter_init(&iter, b_gendata->hash); + while (g_hash_table_iter_next(&iter, (gpointer *) &key, (gpointer *) &val)) { + val2 = g_hash_table_lookup(a_gendata->hash, key); + compared_any = TRUE; + if (!val2 || !g_variant_equal(val, val2)) { + diff_found = TRUE; + _setting_diff_add_result(*results, key, b_result); + } + } + } + } else { + for (i = 0; i < sett_info->property_infos_len; i++) { + NMSettingDiffResult r = NM_SETTING_DIFF_RESULT_UNKNOWN; + const NMSettInfoProperty *property_info; + NMTernary compare_result; + GParamSpec * prop_spec; + + compare_result = _compare_property(sett_info, i, con_a, a, con_b, b, flags); + if (compare_result == NM_TERNARY_DEFAULT) + continue; + + if (NM_FLAGS_ANY(flags, + NM_SETTING_COMPARE_FLAG_IGNORE_AGENT_OWNED_SECRETS + | NM_SETTING_COMPARE_FLAG_IGNORE_NOT_SAVED_SECRETS) + && b && compare_result == NM_TERNARY_FALSE) { + /* we have setting @b and the property is not the same. But we also are instructed + * to ignore secrets based on the flags. + * + * Note that compare_property() called with two settings will ignore secrets + * based on the flags, but it will do so if *both* settings have the flag we + * look for. So that is symmetric behavior and good. + * + * But for the purpose of diff(), we do a asymmetric comparison because and + * we want to skip testing the property if setting @a alone indicates to do + * so. + * + * We need to double-check whether the property should be ignored by + * looking at @a alone. */ + if (_compare_property(sett_info, i, con_a, a, NULL, NULL, flags) + == NM_TERNARY_DEFAULT) + continue; + } + + compared_any = TRUE; + + property_info = &sett_info->property_infos[i]; + prop_spec = property_info->param_spec; + + if (b) { + if (compare_result == NM_TERNARY_FALSE) { + if (prop_spec) { + gboolean a_is_default, b_is_default; + GValue value = G_VALUE_INIT; + + g_value_init(&value, prop_spec->value_type); + g_object_get_property(G_OBJECT(a), prop_spec->name, &value); + a_is_default = g_param_value_defaults(prop_spec, &value); + + g_value_reset(&value); + g_object_get_property(G_OBJECT(b), prop_spec->name, &value); + b_is_default = g_param_value_defaults(prop_spec, &value); + + g_value_unset(&value); + if (!NM_FLAGS_HAS(flags, + NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT)) { + if (!a_is_default) + r |= a_result; + if (!b_is_default) + r |= b_result; + } else { + r |= a_result | b_result; + if (a_is_default) + r |= a_result_default; + if (b_is_default) + r |= b_result_default; + } + } else + r |= a_result | b_result; + } + } else if ((flags + & (NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT + | NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT)) + == 0) + r = a_result; /* only in A */ + else { + if (prop_spec) { + GValue value = G_VALUE_INIT; + + g_value_init(&value, prop_spec->value_type); + g_object_get_property(G_OBJECT(a), prop_spec->name, &value); + if (!g_param_value_defaults(prop_spec, &value)) + r |= a_result; + else if (flags & NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT) + r |= a_result | a_result_default; + + g_value_unset(&value); + } else + r |= a_result; + } + + if (r != NM_SETTING_DIFF_RESULT_UNKNOWN) { + diff_found = TRUE; + _setting_diff_add_result(*results, property_info->name, r); + } + } + } + + if (!compared_any && !b) { + /* special case: the setting has no properties, and the opposite + * setting @b is not given. The settings differ, and we signal that + * by returning an empty results hash. */ + diff_found = TRUE; + } + + if (diff_found) { + /* if there is a difference, we always return FALSE. It also means, we might + * have allocated a new @results hash, and return it to the caller. */ + return FALSE; + } else { + if (results_created) { + /* the allocated hash is unused. Clear it again. */ + g_hash_table_destroy(*results); + *results = NULL; + } else { + /* we found no diff, and return false. However, the input + * @result is returned unmodified. */ + } + return TRUE; + } } static void -enumerate_values (const NMSettInfoProperty *property_info, - NMSetting *setting, - NMSettingValueIterFn func, - gpointer user_data) +enumerate_values(const NMSettInfoProperty *property_info, + NMSetting * setting, + NMSettingValueIterFn func, + gpointer user_data) { - GValue value = G_VALUE_INIT; + GValue value = G_VALUE_INIT; - if (!property_info->param_spec) - return; + if (!property_info->param_spec) + return; - g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (property_info->param_spec)); - g_object_get_property (G_OBJECT (setting), property_info->param_spec->name, &value); - func (setting, - property_info->param_spec->name, - &value, - property_info->param_spec->flags, - user_data); - g_value_unset (&value); + g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(property_info->param_spec)); + g_object_get_property(G_OBJECT(setting), property_info->param_spec->name, &value); + func(setting, + property_info->param_spec->name, + &value, + property_info->param_spec->flags, + user_data); + g_value_unset(&value); } /** @@ -1773,110 +1794,105 @@ enumerate_values (const NMSettInfoProperty *property_info, * user function for each property. **/ void -nm_setting_enumerate_values (NMSetting *setting, - NMSettingValueIterFn func, - gpointer user_data) -{ - const NMSettInfoSetting *sett_info; - guint i; - - g_return_if_fail (NM_IS_SETTING (setting)); - g_return_if_fail (func != NULL); - - sett_info = _nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (setting)); - - if (sett_info->detail.gendata_info) { - const char *const*names; - guint n_properties; - - /* the properties of this setting are not real GObject properties. - * Hence, this API makes little sense (or does it?). Still, call - * @func with each value. */ - n_properties = _nm_setting_option_get_all (setting, &names, NULL); - if (n_properties > 0) { - gs_strfreev char **keys = g_strdupv ((char **) names); - GHashTable *h = _gendata_hash (setting, FALSE)->hash; - - for (i = 0; i < n_properties; i++) { - GValue value = G_VALUE_INIT; - GVariant *val = g_hash_table_lookup (h, keys[i]); - - if (!val) { - /* was deleted in the meantime? Skip */ - continue; - } - - g_value_init (&value, G_TYPE_VARIANT); - g_value_set_variant (&value, val); - /* call it will GParamFlags 0. It shall indicate that this - * is not a "real" GObject property. */ - func (setting, keys[i], &value, 0, user_data); - g_value_unset (&value); - } - } - return; - } - - for (i = 0; i < sett_info->property_infos_len; i++) { - NM_SETTING_GET_CLASS (setting)->enumerate_values (_nm_sett_info_property_info_get_sorted (sett_info, i), - setting, - func, - user_data); - } +nm_setting_enumerate_values(NMSetting *setting, NMSettingValueIterFn func, gpointer user_data) +{ + const NMSettInfoSetting *sett_info; + guint i; + + g_return_if_fail(NM_IS_SETTING(setting)); + g_return_if_fail(func != NULL); + + sett_info = _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(setting)); + + if (sett_info->detail.gendata_info) { + const char *const *names; + guint n_properties; + + /* the properties of this setting are not real GObject properties. + * Hence, this API makes little sense (or does it?). Still, call + * @func with each value. */ + n_properties = _nm_setting_option_get_all(setting, &names, NULL); + if (n_properties > 0) { + gs_strfreev char **keys = g_strdupv((char **) names); + GHashTable * h = _gendata_hash(setting, FALSE)->hash; + + for (i = 0; i < n_properties; i++) { + GValue value = G_VALUE_INIT; + GVariant *val = g_hash_table_lookup(h, keys[i]); + + if (!val) { + /* was deleted in the meantime? Skip */ + continue; + } + + g_value_init(&value, G_TYPE_VARIANT); + g_value_set_variant(&value, val); + /* call it will GParamFlags 0. It shall indicate that this + * is not a "real" GObject property. */ + func(setting, keys[i], &value, 0, user_data); + g_value_unset(&value); + } + } + return; + } + + for (i = 0; i < sett_info->property_infos_len; i++) { + NM_SETTING_GET_CLASS(setting)->enumerate_values( + _nm_sett_info_property_info_get_sorted(sett_info, i), + setting, + func, + user_data); + } } static gboolean -aggregate (NMSetting *setting, - int type_i, - gpointer arg) -{ - NMConnectionAggregateType type = type_i; - const NMSettInfoSetting *sett_info; - guint i; - - nm_assert (NM_IN_SET (type, NM_CONNECTION_AGGREGATE_ANY_SECRETS, - NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS)); - - sett_info = _nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (setting)); - for (i = 0; i < sett_info->property_infos_len; i++) { - const NMSettInfoProperty *property_info = &sett_info->property_infos[i]; - GParamSpec *prop_spec = property_info->param_spec; - nm_auto_unset_gvalue GValue value = G_VALUE_INIT; - NMSettingSecretFlags secret_flags; - - if ( !prop_spec - || !NM_FLAGS_HAS (prop_spec->flags, NM_SETTING_PARAM_SECRET)) { - nm_assert (!nm_setting_get_secret_flags (setting, property_info->name, NULL, NULL)); - continue; - } - - /* for the moment, all aggregate types only care about secrets. */ - nm_assert (nm_setting_get_secret_flags (setting, property_info->name, NULL, NULL)); - - switch (type) { - - case NM_CONNECTION_AGGREGATE_ANY_SECRETS: - g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (prop_spec)); - g_object_get_property (G_OBJECT (setting), prop_spec->name, &value); - if (!g_param_value_defaults (prop_spec, &value)) { - *((gboolean *) arg) = TRUE; - return TRUE; - } - break; - - case NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS: - if (!nm_setting_get_secret_flags (setting, prop_spec->name, &secret_flags, NULL)) - nm_assert_not_reached (); - if (secret_flags == NM_SETTING_SECRET_FLAG_NONE) { - *((gboolean *) arg) = TRUE; - return TRUE; - } - break; - - } - } - - return FALSE; +aggregate(NMSetting *setting, int type_i, gpointer arg) +{ + NMConnectionAggregateType type = type_i; + const NMSettInfoSetting * sett_info; + guint i; + + nm_assert(NM_IN_SET(type, + NM_CONNECTION_AGGREGATE_ANY_SECRETS, + NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS)); + + sett_info = _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(setting)); + for (i = 0; i < sett_info->property_infos_len; i++) { + const NMSettInfoProperty * property_info = &sett_info->property_infos[i]; + GParamSpec * prop_spec = property_info->param_spec; + nm_auto_unset_gvalue GValue value = G_VALUE_INIT; + NMSettingSecretFlags secret_flags; + + if (!prop_spec || !NM_FLAGS_HAS(prop_spec->flags, NM_SETTING_PARAM_SECRET)) { + nm_assert(!nm_setting_get_secret_flags(setting, property_info->name, NULL, NULL)); + continue; + } + + /* for the moment, all aggregate types only care about secrets. */ + nm_assert(nm_setting_get_secret_flags(setting, property_info->name, NULL, NULL)); + + switch (type) { + case NM_CONNECTION_AGGREGATE_ANY_SECRETS: + g_value_init(&value, G_PARAM_SPEC_VALUE_TYPE(prop_spec)); + g_object_get_property(G_OBJECT(setting), prop_spec->name, &value); + if (!g_param_value_defaults(prop_spec, &value)) { + *((gboolean *) arg) = TRUE; + return TRUE; + } + break; + + case NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS: + if (!nm_setting_get_secret_flags(setting, prop_spec->name, &secret_flags, NULL)) + nm_assert_not_reached(); + if (secret_flags == NM_SETTING_SECRET_FLAG_NONE) { + *((gboolean *) arg) = TRUE; + return TRUE; + } + break; + } + } + + return FALSE; } /** @@ -1895,56 +1911,55 @@ aggregate (NMSetting *setting, * argument of _nm_connection_aggregate(), which serves a different purpose. */ gboolean -_nm_setting_aggregate (NMSetting *setting, - NMConnectionAggregateType type, - gpointer arg) +_nm_setting_aggregate(NMSetting *setting, NMConnectionAggregateType type, gpointer arg) { - g_return_val_if_fail (NM_IS_SETTING (setting), FALSE); - g_return_val_if_fail (arg, FALSE); - g_return_val_if_fail (NM_IN_SET (type, NM_CONNECTION_AGGREGATE_ANY_SECRETS, - NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS), - FALSE); + g_return_val_if_fail(NM_IS_SETTING(setting), FALSE); + g_return_val_if_fail(arg, FALSE); + g_return_val_if_fail(NM_IN_SET(type, + NM_CONNECTION_AGGREGATE_ANY_SECRETS, + NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS), + FALSE); - return NM_SETTING_GET_CLASS (setting)->aggregate (setting, type, arg); + return NM_SETTING_GET_CLASS(setting)->aggregate(setting, type, arg); } static gboolean -clear_secrets (const NMSettInfoSetting *sett_info, - guint property_idx, - NMSetting *setting, - NMSettingClearSecretsWithFlagsFn func, - gpointer user_data) +clear_secrets(const NMSettInfoSetting * sett_info, + guint property_idx, + NMSetting * setting, + NMSettingClearSecretsWithFlagsFn func, + gpointer user_data) { - NMSettingSecretFlags flags = NM_SETTING_SECRET_FLAG_NONE; - GParamSpec *param_spec = sett_info->property_infos[property_idx].param_spec; + NMSettingSecretFlags flags = NM_SETTING_SECRET_FLAG_NONE; + GParamSpec * param_spec = sett_info->property_infos[property_idx].param_spec; - if (!param_spec) - return FALSE; + if (!param_spec) + return FALSE; - if (!NM_FLAGS_HAS (param_spec->flags, NM_SETTING_PARAM_SECRET)) - return FALSE; + if (!NM_FLAGS_HAS(param_spec->flags, NM_SETTING_PARAM_SECRET)) + return FALSE; - if (func) { - if (!nm_setting_get_secret_flags (setting, param_spec->name, &flags, NULL)) - nm_assert_not_reached (); - if (!func (setting, param_spec->name, flags, user_data)) - return FALSE; - } else - nm_assert (nm_setting_get_secret_flags (setting, param_spec->name, NULL, NULL)); + if (func) { + if (!nm_setting_get_secret_flags(setting, param_spec->name, &flags, NULL)) + nm_assert_not_reached(); + if (!func(setting, param_spec->name, flags, user_data)) + return FALSE; + } else + nm_assert(nm_setting_get_secret_flags(setting, param_spec->name, NULL, NULL)); - { - nm_auto_unset_gvalue GValue value = G_VALUE_INIT; + { + nm_auto_unset_gvalue GValue value = G_VALUE_INIT; - g_value_init (&value, param_spec->value_type); - g_object_get_property (G_OBJECT (setting), param_spec->name, &value); - if (g_param_value_defaults (param_spec, &value)) - return FALSE; + g_value_init(&value, param_spec->value_type); + g_object_get_property(G_OBJECT(setting), param_spec->name, &value); + if (g_param_value_defaults(param_spec, &value)) + return FALSE; - g_param_value_set_default (param_spec, &value); - g_object_set_property (G_OBJECT (setting), param_spec->name, &value); - } + g_param_value_set_default(param_spec, &value); + g_object_set_property(G_OBJECT(setting), param_spec->name, &value); + } - return TRUE; + return TRUE; } /** @@ -1959,32 +1974,28 @@ clear_secrets (const NMSettInfoSetting *sett_info, * Returns: %TRUE if the setting changed at all **/ gboolean -_nm_setting_clear_secrets (NMSetting *setting, - NMSettingClearSecretsWithFlagsFn func, - gpointer user_data) -{ - const NMSettInfoSetting *sett_info; - gboolean changed = FALSE; - guint i; - gboolean (*my_clear_secrets) (const struct _NMSettInfoSetting *sett_info, - guint property_idx, - NMSetting *setting, - NMSettingClearSecretsWithFlagsFn func, - gpointer user_data); - - g_return_val_if_fail (NM_IS_SETTING (setting), FALSE); - - my_clear_secrets = NM_SETTING_GET_CLASS (setting)->clear_secrets; - - sett_info = _nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (setting)); - for (i = 0; i < sett_info->property_infos_len; i++) { - changed |= my_clear_secrets (sett_info, - i, - setting, - func, - user_data); - } - return changed; +_nm_setting_clear_secrets(NMSetting * setting, + NMSettingClearSecretsWithFlagsFn func, + gpointer user_data) +{ + const NMSettInfoSetting *sett_info; + gboolean changed = FALSE; + guint i; + gboolean (*my_clear_secrets)(const struct _NMSettInfoSetting *sett_info, + guint property_idx, + NMSetting * setting, + NMSettingClearSecretsWithFlagsFn func, + gpointer user_data); + + g_return_val_if_fail(NM_IS_SETTING(setting), FALSE); + + my_clear_secrets = NM_SETTING_GET_CLASS(setting)->clear_secrets; + + sett_info = _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(setting)); + for (i = 0; i < sett_info->property_infos_len; i++) { + changed |= my_clear_secrets(sett_info, i, setting, func, user_data); + } + return changed; } /** @@ -2002,62 +2013,63 @@ _nm_setting_clear_secrets (NMSetting *setting, * free the elements. **/ GPtrArray * -_nm_setting_need_secrets (NMSetting *setting) +_nm_setting_need_secrets(NMSetting *setting) { - GPtrArray *secrets = NULL; + GPtrArray *secrets = NULL; - g_return_val_if_fail (NM_IS_SETTING (setting), NULL); + g_return_val_if_fail(NM_IS_SETTING(setting), NULL); - if (NM_SETTING_GET_CLASS (setting)->need_secrets) - secrets = NM_SETTING_GET_CLASS (setting)->need_secrets (setting); + if (NM_SETTING_GET_CLASS(setting)->need_secrets) + secrets = NM_SETTING_GET_CLASS(setting)->need_secrets(setting); - return secrets; + return secrets; } static int -update_one_secret (NMSetting *setting, const char *key, GVariant *value, GError **error) -{ - const NMSettInfoProperty *property; - GParamSpec *prop_spec; - GValue prop_value = { 0, }; - - property = _nm_setting_class_get_property_info (NM_SETTING_GET_CLASS (setting), key); - if (!property) { - g_set_error_literal (error, - NM_CONNECTION_ERROR, - NM_CONNECTION_ERROR_PROPERTY_NOT_FOUND, - _("secret not found")); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), key); - return NM_SETTING_UPDATE_SECRET_ERROR; - } - - /* Silently ignore non-secrets */ - prop_spec = property->param_spec; - if (!prop_spec || !(prop_spec->flags & NM_SETTING_PARAM_SECRET)) - return NM_SETTING_UPDATE_SECRET_SUCCESS_UNCHANGED; - - if ( g_variant_is_of_type (value, G_VARIANT_TYPE_STRING) - && G_IS_PARAM_SPEC_STRING (prop_spec)) { - /* String is expected to be a common case. Handle it specially and check - * whether the value is already set. Otherwise, we just reset the - * property and assume the value got modified. - */ - char *v; - - g_object_get (G_OBJECT (setting), prop_spec->name, &v, NULL); - if (g_strcmp0 (v, g_variant_get_string (value, NULL)) == 0) { - g_free (v); - return NM_SETTING_UPDATE_SECRET_SUCCESS_UNCHANGED; - } - g_free (v); - } - - g_value_init (&prop_value, prop_spec->value_type); - set_property_from_dbus (property, value, &prop_value); - g_object_set_property (G_OBJECT (setting), prop_spec->name, &prop_value); - g_value_unset (&prop_value); - - return NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED; +update_one_secret(NMSetting *setting, const char *key, GVariant *value, GError **error) +{ + const NMSettInfoProperty *property; + GParamSpec * prop_spec; + GValue prop_value = { + 0, + }; + + property = _nm_setting_class_get_property_info(NM_SETTING_GET_CLASS(setting), key); + if (!property) { + g_set_error_literal(error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_PROPERTY_NOT_FOUND, + _("secret not found")); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), key); + return NM_SETTING_UPDATE_SECRET_ERROR; + } + + /* Silently ignore non-secrets */ + prop_spec = property->param_spec; + if (!prop_spec || !(prop_spec->flags & NM_SETTING_PARAM_SECRET)) + return NM_SETTING_UPDATE_SECRET_SUCCESS_UNCHANGED; + + if (g_variant_is_of_type(value, G_VARIANT_TYPE_STRING) && G_IS_PARAM_SPEC_STRING(prop_spec)) { + /* String is expected to be a common case. Handle it specially and check + * whether the value is already set. Otherwise, we just reset the + * property and assume the value got modified. + */ + char *v; + + g_object_get(G_OBJECT(setting), prop_spec->name, &v, NULL); + if (g_strcmp0(v, g_variant_get_string(value, NULL)) == 0) { + g_free(v); + return NM_SETTING_UPDATE_SECRET_SUCCESS_UNCHANGED; + } + g_free(v); + } + + g_value_init(&prop_value, prop_spec->value_type); + set_property_from_dbus(property, value, &prop_value); + g_object_set_property(G_OBJECT(setting), prop_spec->name, &prop_value); + g_value_unset(&prop_value); + + return NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED; } /** @@ -2073,130 +2085,125 @@ update_one_secret (NMSetting *setting, const char *key, GVariant *value, GError * Returns: an #NMSettingUpdateSecretResult **/ NMSettingUpdateSecretResult -_nm_setting_update_secrets (NMSetting *setting, GVariant *secrets, GError **error) +_nm_setting_update_secrets(NMSetting *setting, GVariant *secrets, GError **error) { - GVariantIter iter; - const char *secret_key; - GVariant *secret_value; - GError *tmp_error = NULL; - NMSettingUpdateSecretResult result = NM_SETTING_UPDATE_SECRET_SUCCESS_UNCHANGED; + GVariantIter iter; + const char * secret_key; + GVariant * secret_value; + GError * tmp_error = NULL; + NMSettingUpdateSecretResult result = NM_SETTING_UPDATE_SECRET_SUCCESS_UNCHANGED; - g_return_val_if_fail (NM_IS_SETTING (setting), NM_SETTING_UPDATE_SECRET_ERROR); - g_return_val_if_fail (g_variant_is_of_type (secrets, NM_VARIANT_TYPE_SETTING), NM_SETTING_UPDATE_SECRET_ERROR); - if (error) - g_return_val_if_fail (*error == NULL, NM_SETTING_UPDATE_SECRET_ERROR); + g_return_val_if_fail(NM_IS_SETTING(setting), NM_SETTING_UPDATE_SECRET_ERROR); + g_return_val_if_fail(g_variant_is_of_type(secrets, NM_VARIANT_TYPE_SETTING), + NM_SETTING_UPDATE_SECRET_ERROR); + if (error) + g_return_val_if_fail(*error == NULL, NM_SETTING_UPDATE_SECRET_ERROR); - g_variant_iter_init (&iter, secrets); - while (g_variant_iter_next (&iter, "{&sv}", &secret_key, &secret_value)) { - int success; + g_variant_iter_init(&iter, secrets); + while (g_variant_iter_next(&iter, "{&sv}", &secret_key, &secret_value)) { + int success; - success = NM_SETTING_GET_CLASS (setting)->update_one_secret (setting, secret_key, secret_value, &tmp_error); - nm_assert (!((success == NM_SETTING_UPDATE_SECRET_ERROR) ^ (!!tmp_error))); + success = NM_SETTING_GET_CLASS(setting)->update_one_secret(setting, + secret_key, + secret_value, + &tmp_error); + nm_assert(!((success == NM_SETTING_UPDATE_SECRET_ERROR) ^ (!!tmp_error))); - g_variant_unref (secret_value); + g_variant_unref(secret_value); - if (success == NM_SETTING_UPDATE_SECRET_ERROR) { - g_propagate_error (error, tmp_error); - return NM_SETTING_UPDATE_SECRET_ERROR; - } + if (success == NM_SETTING_UPDATE_SECRET_ERROR) { + g_propagate_error(error, tmp_error); + return NM_SETTING_UPDATE_SECRET_ERROR; + } - if (success == NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED) - result = NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED; - } + if (success == NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED) + result = NM_SETTING_UPDATE_SECRET_SUCCESS_MODIFIED; + } - return result; + return result; } static void -for_each_secret (NMSetting *setting, - const char *secret_name, - GVariant *val, - gboolean remove_non_secrets, - _NMConnectionForEachSecretFunc callback, - gpointer callback_data, - GVariantBuilder *setting_builder) +for_each_secret(NMSetting * setting, + const char * secret_name, + GVariant * val, + gboolean remove_non_secrets, + _NMConnectionForEachSecretFunc callback, + gpointer callback_data, + GVariantBuilder * setting_builder) { - NMSettingSecretFlags secret_flags = NM_SETTING_SECRET_FLAG_NONE; + NMSettingSecretFlags secret_flags = NM_SETTING_SECRET_FLAG_NONE; - if (!nm_setting_get_secret_flags (setting, secret_name, &secret_flags, NULL)) { - if (!remove_non_secrets) - g_variant_builder_add (setting_builder, "{sv}", secret_name, val); - return; - } - if (callback (secret_flags, callback_data)) - g_variant_builder_add (setting_builder, "{sv}", secret_name, val); + if (!nm_setting_get_secret_flags(setting, secret_name, &secret_flags, NULL)) { + if (!remove_non_secrets) + g_variant_builder_add(setting_builder, "{sv}", secret_name, val); + return; + } + if (callback(secret_flags, callback_data)) + g_variant_builder_add(setting_builder, "{sv}", secret_name, val); } static void -_set_error_secret_property_not_found (GError **error, - NMSetting *setting, - const char *secret_name) +_set_error_secret_property_not_found(GError **error, NMSetting *setting, const char *secret_name) { - g_set_error_literal (error, - NM_CONNECTION_ERROR, - NM_CONNECTION_ERROR_PROPERTY_NOT_FOUND, - _("not a secret property")); - g_prefix_error (error, "%s.%s: ", nm_setting_get_name (setting), secret_name); + g_set_error_literal(error, + NM_CONNECTION_ERROR, + NM_CONNECTION_ERROR_PROPERTY_NOT_FOUND, + _("not a secret property")); + g_prefix_error(error, "%s.%s: ", nm_setting_get_name(setting), secret_name); } gboolean -_nm_setting_property_is_regular_secret (NMSetting *setting, - const char *secret_name) +_nm_setting_property_is_regular_secret(NMSetting *setting, const char *secret_name) { - const NMSettInfoProperty *property; + const NMSettInfoProperty *property; - nm_assert (NM_IS_SETTING (setting)); - nm_assert (secret_name); + nm_assert(NM_IS_SETTING(setting)); + nm_assert(secret_name); - property = _nm_setting_class_get_property_info (NM_SETTING_GET_CLASS (setting), secret_name); - return property - && property->param_spec - && NM_FLAGS_HAS (property->param_spec->flags, NM_SETTING_PARAM_SECRET); + property = _nm_setting_class_get_property_info(NM_SETTING_GET_CLASS(setting), secret_name); + return property && property->param_spec + && NM_FLAGS_HAS(property->param_spec->flags, NM_SETTING_PARAM_SECRET); } gboolean -_nm_setting_property_is_regular_secret_flags (NMSetting *setting, - const char *secret_flags_name) +_nm_setting_property_is_regular_secret_flags(NMSetting *setting, const char *secret_flags_name) { - const NMSettInfoProperty *property; + const NMSettInfoProperty *property; - nm_assert (NM_IS_SETTING (setting)); - nm_assert (secret_flags_name); + nm_assert(NM_IS_SETTING(setting)); + nm_assert(secret_flags_name); - property = _nm_setting_class_get_property_info (NM_SETTING_GET_CLASS (setting), secret_flags_name); - return property - && property->param_spec - && !NM_FLAGS_HAS (property->param_spec->flags, NM_SETTING_PARAM_SECRET) - && G_PARAM_SPEC_VALUE_TYPE (property->param_spec) == NM_TYPE_SETTING_SECRET_FLAGS; + property = + _nm_setting_class_get_property_info(NM_SETTING_GET_CLASS(setting), secret_flags_name); + return property && property->param_spec + && !NM_FLAGS_HAS(property->param_spec->flags, NM_SETTING_PARAM_SECRET) + && G_PARAM_SPEC_VALUE_TYPE(property->param_spec) == NM_TYPE_SETTING_SECRET_FLAGS; } static gboolean -get_secret_flags (NMSetting *setting, - const char *secret_name, - NMSettingSecretFlags *out_flags, - GError **error) +get_secret_flags(NMSetting * setting, + const char * secret_name, + NMSettingSecretFlags *out_flags, + GError ** error) { - gs_free char *secret_flags_name_free = NULL; - const char *secret_flags_name; - NMSettingSecretFlags flags; + gs_free char * secret_flags_name_free = NULL; + const char * secret_flags_name; + NMSettingSecretFlags flags; - if (!_nm_setting_property_is_regular_secret (setting, - secret_name)) { - _set_error_secret_property_not_found (error, setting, secret_name); - NM_SET_OUT (out_flags, NM_SETTING_SECRET_FLAG_NONE); - return FALSE; - } + if (!_nm_setting_property_is_regular_secret(setting, secret_name)) { + _set_error_secret_property_not_found(error, setting, secret_name); + NM_SET_OUT(out_flags, NM_SETTING_SECRET_FLAG_NONE); + return FALSE; + } - secret_flags_name = nm_construct_name_a ("%s-flags", secret_name, &secret_flags_name_free); + secret_flags_name = nm_construct_name_a("%s-flags", secret_name, &secret_flags_name_free); - nm_assert (_nm_setting_property_is_regular_secret_flags (setting, secret_flags_name)); + nm_assert(_nm_setting_property_is_regular_secret_flags(setting, secret_flags_name)); - g_object_get (G_OBJECT (setting), - secret_flags_name, - &flags, - NULL); - NM_SET_OUT (out_flags, flags); - return TRUE; + g_object_get(G_OBJECT(setting), secret_flags_name, &flags, NULL); + NM_SET_OUT(out_flags, flags); + return TRUE; } /** @@ -2213,43 +2220,42 @@ get_secret_flags (NMSetting *setting, * this setting, and if that property is secret), %FALSE if not **/ gboolean -nm_setting_get_secret_flags (NMSetting *setting, - const char *secret_name, - NMSettingSecretFlags *out_flags, - GError **error) +nm_setting_get_secret_flags(NMSetting * setting, + const char * secret_name, + NMSettingSecretFlags *out_flags, + GError ** error) { - g_return_val_if_fail (NM_IS_SETTING (setting), FALSE); - g_return_val_if_fail (secret_name != NULL, FALSE); + g_return_val_if_fail(NM_IS_SETTING(setting), FALSE); + g_return_val_if_fail(secret_name != NULL, FALSE); - return NM_SETTING_GET_CLASS (setting)->get_secret_flags (setting, secret_name, out_flags, error); + return NM_SETTING_GET_CLASS(setting)->get_secret_flags(setting, secret_name, out_flags, error); } static gboolean -set_secret_flags (NMSetting *setting, - const char *secret_name, - NMSettingSecretFlags flags, - GError **error) +set_secret_flags(NMSetting * setting, + const char * secret_name, + NMSettingSecretFlags flags, + GError ** error) { - gs_free char *secret_flags_name_free = NULL; - const char *secret_flags_name; + gs_free char *secret_flags_name_free = NULL; + const char * secret_flags_name; - if (!_nm_setting_property_is_regular_secret (setting, - secret_name)) { - _set_error_secret_property_not_found (error, setting, secret_name); - return FALSE; - } + if (!_nm_setting_property_is_regular_secret(setting, secret_name)) { + _set_error_secret_property_not_found(error, setting, secret_name); + return FALSE; + } - secret_flags_name = nm_construct_name_a ("%s-flags", secret_name, &secret_flags_name_free); + secret_flags_name = nm_construct_name_a("%s-flags", secret_name, &secret_flags_name_free); - nm_assert (_nm_setting_property_is_regular_secret_flags (setting, secret_flags_name)); + nm_assert(_nm_setting_property_is_regular_secret_flags(setting, secret_flags_name)); - if (!nm_g_object_set_property_flags (G_OBJECT (setting), - secret_flags_name, - NM_TYPE_SETTING_SECRET_FLAGS, - flags, - error)) - g_return_val_if_reached (FALSE); - return TRUE; + if (!nm_g_object_set_property_flags(G_OBJECT(setting), + secret_flags_name, + NM_TYPE_SETTING_SECRET_FLAGS, + flags, + error)) + g_return_val_if_reached(FALSE); + return TRUE; } /** @@ -2266,16 +2272,16 @@ set_secret_flags (NMSetting *setting, * this setting, and if that property is secret), %FALSE if not **/ gboolean -nm_setting_set_secret_flags (NMSetting *setting, - const char *secret_name, - NMSettingSecretFlags flags, - GError **error) +nm_setting_set_secret_flags(NMSetting * setting, + const char * secret_name, + NMSettingSecretFlags flags, + GError ** error) { - g_return_val_if_fail (NM_IS_SETTING (setting), FALSE); - g_return_val_if_fail (secret_name != NULL, FALSE); - g_return_val_if_fail (_nm_setting_secret_flags_valid (flags), FALSE); + g_return_val_if_fail(NM_IS_SETTING(setting), FALSE); + g_return_val_if_fail(secret_name != NULL, FALSE); + g_return_val_if_fail(_nm_setting_secret_flags_valid(flags), FALSE); - return NM_SETTING_GET_CLASS (setting)->set_secret_flags (setting, secret_name, flags, error); + return NM_SETTING_GET_CLASS(setting)->set_secret_flags(setting, secret_name, flags, error); } /** @@ -2292,193 +2298,193 @@ nm_setting_set_secret_flags (NMSetting *setting, * free with g_free() **/ char * -nm_setting_to_string (NMSetting *setting) +nm_setting_to_string(NMSetting *setting) { - GString *string; - gs_unref_variant GVariant *variant = NULL; - GVariant *child; - GVariantIter iter; + GString * string; + gs_unref_variant GVariant *variant = NULL; + GVariant * child; + GVariantIter iter; - string = g_string_new (nm_setting_get_name (setting)); - g_string_append_c (string, '\n'); + string = g_string_new(nm_setting_get_name(setting)); + g_string_append_c(string, '\n'); - variant = _nm_setting_to_dbus (setting, NULL, NM_CONNECTION_SERIALIZE_ALL, NULL); + variant = _nm_setting_to_dbus(setting, NULL, NM_CONNECTION_SERIALIZE_ALL, NULL); - g_variant_iter_init (&iter, variant); - while ((child = g_variant_iter_next_value (&iter))) { - gs_free char *name = NULL; - gs_free char *value_str = NULL; - gs_unref_variant GVariant *value = NULL; + g_variant_iter_init(&iter, variant); + while ((child = g_variant_iter_next_value(&iter))) { + gs_free char * name = NULL; + gs_free char * value_str = NULL; + gs_unref_variant GVariant *value = NULL; - g_variant_get (child, "{sv}", &name, &value); - value_str = g_variant_print (value, FALSE); + g_variant_get(child, "{sv}", &name, &value); + value_str = g_variant_print(value, FALSE); - g_string_append_printf (string, "\t%s : %s\n", name, value_str); - } + g_string_append_printf(string, "\t%s : %s\n", name, value_str); + } - return g_string_free (string, FALSE); + return g_string_free(string, FALSE); } static GVariant * -_nm_setting_get_deprecated_virtual_interface_name (const NMSettInfoSetting *sett_info, - guint property_idx, - NMConnection *connection, - NMSetting *setting, - NMConnectionSerializationFlags flags, - const NMConnectionSerializationOptions *options) +_nm_setting_get_deprecated_virtual_interface_name(const NMSettInfoSetting * sett_info, + guint property_idx, + NMConnection * connection, + NMSetting * setting, + NMConnectionSerializationFlags flags, + const NMConnectionSerializationOptions *options) { - NMSettingConnection *s_con; + NMSettingConnection *s_con; - if (!connection) - return NULL; + if (!connection) + return NULL; - s_con = nm_connection_get_setting_connection (connection); - if (!s_con) - return NULL; + s_con = nm_connection_get_setting_connection(connection); + if (!s_con) + return NULL; - if (nm_setting_connection_get_interface_name (s_con)) - return g_variant_new_string (nm_setting_connection_get_interface_name (s_con)); - else - return NULL; + if (nm_setting_connection_get_interface_name(s_con)) + return g_variant_new_string(nm_setting_connection_get_interface_name(s_con)); + else + return NULL; } const NMSettInfoPropertType nm_sett_info_propert_type_deprecated_interface_name = { - .dbus_type = G_VARIANT_TYPE_STRING, - .to_dbus_fcn = _nm_setting_get_deprecated_virtual_interface_name, + .dbus_type = G_VARIANT_TYPE_STRING, + .to_dbus_fcn = _nm_setting_get_deprecated_virtual_interface_name, }; const NMSettInfoPropertType nm_sett_info_propert_type_deprecated_ignore_i = { - .dbus_type = G_VARIANT_TYPE_INT32, - /* No functions set. This property type is to silently ignore the value on D-Bus. */ + .dbus_type = G_VARIANT_TYPE_INT32, + /* No functions set. This property type is to silently ignore the value on D-Bus. */ }; const NMSettInfoPropertType nm_sett_info_propert_type_deprecated_ignore_u = { - .dbus_type = G_VARIANT_TYPE_UINT32, - /* No functions set. This property type is to silently ignore the value on D-Bus. */ + .dbus_type = G_VARIANT_TYPE_UINT32, + /* No functions set. This property type is to silently ignore the value on D-Bus. */ }; const NMSettInfoPropertType nm_sett_info_propert_type_plain_i = { - .dbus_type = G_VARIANT_TYPE_INT32, + .dbus_type = G_VARIANT_TYPE_INT32, }; const NMSettInfoPropertType nm_sett_info_propert_type_plain_u = { - .dbus_type = G_VARIANT_TYPE_UINT32, + .dbus_type = G_VARIANT_TYPE_UINT32, }; /*****************************************************************************/ static GenData * -_gendata_hash (NMSetting *setting, gboolean create_if_necessary) +_gendata_hash(NMSetting *setting, gboolean create_if_necessary) { - NMSettingPrivate *priv; + NMSettingPrivate *priv; - nm_assert (NM_IS_SETTING (setting)); + nm_assert(NM_IS_SETTING(setting)); - priv = NM_SETTING_GET_PRIVATE (setting); + priv = NM_SETTING_GET_PRIVATE(setting); - if (G_UNLIKELY (!priv->gendata)) { - if (!create_if_necessary) - return NULL; - priv->gendata = g_slice_new (GenData); - priv->gendata->hash = g_hash_table_new_full (nm_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref); - priv->gendata->names = NULL; - priv->gendata->values = NULL; - } + if (G_UNLIKELY(!priv->gendata)) { + if (!create_if_necessary) + return NULL; + priv->gendata = g_slice_new(GenData); + priv->gendata->hash = g_hash_table_new_full(nm_str_hash, + g_str_equal, + g_free, + (GDestroyNotify) g_variant_unref); + priv->gendata->names = NULL; + priv->gendata->values = NULL; + } - return priv->gendata; + return priv->gendata; } GHashTable * -_nm_setting_option_hash (NMSetting *setting, gboolean create_if_necessary) +_nm_setting_option_hash(NMSetting *setting, gboolean create_if_necessary) { - GenData *gendata; + GenData *gendata; - gendata = _gendata_hash (setting, create_if_necessary); - return gendata ? gendata->hash : NULL; + gendata = _gendata_hash(setting, create_if_necessary); + return gendata ? gendata->hash : NULL; } void -_nm_setting_option_notify (NMSetting *setting, - gboolean names_changed) -{ - GenData *gendata; - - gendata = _gendata_hash (setting, FALSE); - if (!gendata) - goto out; - - nm_clear_g_free (&gendata->values); - - if (names_changed) { - /* if only the values changed, it's sufficient to invalidate the - * values cache. Otherwise, the names cache must be invalidated too. */ - nm_clear_g_free (&gendata->names); - } - - /* Note, currently there is no way to notify the subclass when gendata changed. - * gendata is only changed in two situations: - * 1) from within NMSetting itself, for example when creating a NMSetting instance - * from keyfile or a D-Bus GVariant. - * 2) actively from the subclass itself - * For 2), we don't need the notification, because the subclass knows that something - * changed. - * For 1), we currently don't need the notification either, because all that the subclass - * currently would do, is emit a g_object_notify() signal. However, 1) only happens when - * the setting instance is newly created, at that point, nobody listens to the signal. - * - * If we ever need it, then we would need to call a virtual function to notify the subclass - * that gendata changed. */ +_nm_setting_option_notify(NMSetting *setting, gboolean names_changed) +{ + GenData *gendata; + + gendata = _gendata_hash(setting, FALSE); + if (!gendata) + goto out; + + nm_clear_g_free(&gendata->values); + + if (names_changed) { + /* if only the values changed, it's sufficient to invalidate the + * values cache. Otherwise, the names cache must be invalidated too. */ + nm_clear_g_free(&gendata->names); + } + + /* Note, currently there is no way to notify the subclass when gendata changed. + * gendata is only changed in two situations: + * 1) from within NMSetting itself, for example when creating a NMSetting instance + * from keyfile or a D-Bus GVariant. + * 2) actively from the subclass itself + * For 2), we don't need the notification, because the subclass knows that something + * changed. + * For 1), we currently don't need the notification either, because all that the subclass + * currently would do, is emit a g_object_notify() signal. However, 1) only happens when + * the setting instance is newly created, at that point, nobody listens to the signal. + * + * If we ever need it, then we would need to call a virtual function to notify the subclass + * that gendata changed. */ out: - _nm_setting_emit_property_changed (setting); + _nm_setting_emit_property_changed(setting); } guint -_nm_setting_option_get_all (NMSetting *setting, - const char *const**out_names, - GVariant *const**out_values) -{ - GenData *gendata; - GHashTable *hash; - guint i, len; - - nm_assert (NM_IS_SETTING (setting)); - - gendata = _gendata_hash (setting, FALSE); - if (!gendata) - goto out_zero; - - hash = gendata->hash; - len = g_hash_table_size (hash); - if (len == 0) - goto out_zero; - - if (!out_names && !out_values) - return len; - - if (G_UNLIKELY (!gendata->names)) { - gendata->names = nm_utils_strdict_get_keys (hash, - TRUE, - NULL); - } - - if (out_values) { - if (G_UNLIKELY (!gendata->values)) { - gendata->values = g_new (GVariant *, len + 1); - for (i = 0; i < len; i++) - gendata->values[i] = g_hash_table_lookup (hash, gendata->names[i]); - gendata->values[i] = NULL; - } - *out_values = gendata->values; - } - - NM_SET_OUT (out_names, (const char *const*) gendata->names); - return len; +_nm_setting_option_get_all(NMSetting * setting, + const char *const **out_names, + GVariant *const ** out_values) +{ + GenData * gendata; + GHashTable *hash; + guint i, len; + + nm_assert(NM_IS_SETTING(setting)); + + gendata = _gendata_hash(setting, FALSE); + if (!gendata) + goto out_zero; + + hash = gendata->hash; + len = g_hash_table_size(hash); + if (len == 0) + goto out_zero; + + if (!out_names && !out_values) + return len; + + if (G_UNLIKELY(!gendata->names)) { + gendata->names = nm_utils_strdict_get_keys(hash, TRUE, NULL); + } + + if (out_values) { + if (G_UNLIKELY(!gendata->values)) { + gendata->values = g_new(GVariant *, len + 1); + for (i = 0; i < len; i++) + gendata->values[i] = g_hash_table_lookup(hash, gendata->names[i]); + gendata->values[i] = NULL; + } + *out_values = gendata->values; + } + + NM_SET_OUT(out_names, (const char *const *) gendata->names); + return len; out_zero: - NM_SET_OUT (out_names, NULL); - NM_SET_OUT (out_values, NULL); - return 0; + NM_SET_OUT(out_names, NULL); + NM_SET_OUT(out_values, NULL); + return 0; } /** @@ -2495,34 +2501,32 @@ out_zero: * * Since: 1.26 **/ -const char *const* -nm_setting_option_get_all_names (NMSetting *setting, - guint *out_len) +const char *const * +nm_setting_option_get_all_names(NMSetting *setting, guint *out_len) { - const char *const*names; - guint len; + const char *const *names; + guint len; - g_return_val_if_fail (NM_IS_SETTING (setting), NULL); + g_return_val_if_fail(NM_IS_SETTING(setting), NULL); - len = _nm_setting_option_get_all (setting, &names, NULL); - NM_SET_OUT (out_len, len); - return names; + len = _nm_setting_option_get_all(setting, &names, NULL); + NM_SET_OUT(out_len, len); + return names; } gboolean -_nm_setting_option_clear (NMSetting *setting, - const char *optname) +_nm_setting_option_clear(NMSetting *setting, const char *optname) { - GHashTable *ht; + GHashTable *ht; - nm_assert (NM_IS_SETTING (setting)); - nm_assert (nm_str_not_empty (optname)); + nm_assert(NM_IS_SETTING(setting)); + nm_assert(nm_str_not_empty(optname)); - ht = _nm_setting_option_hash (setting, FALSE); - if (!ht) - return FALSE; + ht = _nm_setting_option_hash(setting, FALSE); + if (!ht) + return FALSE; - return g_hash_table_remove (ht, optname); + return g_hash_table_remove(ht, optname); } /** @@ -2536,36 +2540,35 @@ _nm_setting_option_clear (NMSetting *setting, * Since: 1.26 */ void -nm_setting_option_clear_by_name (NMSetting *setting, - NMUtilsPredicateStr predicate) -{ - GHashTable *hash; - GHashTableIter iter; - const char *name; - gboolean changed = FALSE; - - g_return_if_fail (NM_IS_SETTING (setting)); - - hash = _nm_setting_option_hash (NM_SETTING (setting), FALSE); - if (!hash) - return; - - if (!predicate) { - changed = (g_hash_table_size (hash) > 0); - if (changed) - g_hash_table_remove_all (hash); - } else { - g_hash_table_iter_init (&iter, hash); - while (g_hash_table_iter_next (&iter, (gpointer *) &name, NULL)) { - if (predicate (name)) { - g_hash_table_iter_remove (&iter); - changed = TRUE; - } - } - } - - if (changed) - _nm_setting_option_notify (setting, TRUE); +nm_setting_option_clear_by_name(NMSetting *setting, NMUtilsPredicateStr predicate) +{ + GHashTable * hash; + GHashTableIter iter; + const char * name; + gboolean changed = FALSE; + + g_return_if_fail(NM_IS_SETTING(setting)); + + hash = _nm_setting_option_hash(NM_SETTING(setting), FALSE); + if (!hash) + return; + + if (!predicate) { + changed = (g_hash_table_size(hash) > 0); + if (changed) + g_hash_table_remove_all(hash); + } else { + g_hash_table_iter_init(&iter, hash); + while (g_hash_table_iter_next(&iter, (gpointer *) &name, NULL)) { + if (predicate(name)) { + g_hash_table_iter_remove(&iter); + changed = TRUE; + } + } + } + + if (changed) + _nm_setting_option_notify(setting, TRUE); } /*****************************************************************************/ @@ -2581,16 +2584,15 @@ nm_setting_option_clear_by_name (NMSetting *setting, * Since: 1.26. */ GVariant * -nm_setting_option_get (NMSetting *setting, - const char *opt_name) +nm_setting_option_get(NMSetting *setting, const char *opt_name) { - GenData *gendata; + GenData *gendata; - g_return_val_if_fail (NM_IS_SETTING (setting), FALSE); - g_return_val_if_fail (opt_name, FALSE); + g_return_val_if_fail(NM_IS_SETTING(setting), FALSE); + g_return_val_if_fail(opt_name, FALSE); - gendata = _gendata_hash (setting, FALSE); - return gendata ? g_hash_table_lookup (gendata->hash, opt_name) : NULL; + gendata = _gendata_hash(setting, FALSE); + return gendata ? g_hash_table_lookup(gendata->hash, opt_name) : NULL; } /** @@ -2605,20 +2607,17 @@ nm_setting_option_get (NMSetting *setting, * Since: 1.26 */ gboolean -nm_setting_option_get_boolean (NMSetting *setting, - const char *opt_name, - gboolean *out_value) +nm_setting_option_get_boolean(NMSetting *setting, const char *opt_name, gboolean *out_value) { - GVariant *v; + GVariant *v; - v = nm_setting_option_get (NM_SETTING (setting), opt_name); - if ( v - && g_variant_is_of_type (v, G_VARIANT_TYPE_BOOLEAN)) { - NM_SET_OUT (out_value, g_variant_get_boolean (v)); - return TRUE; - } - NM_SET_OUT (out_value, FALSE); - return FALSE; + v = nm_setting_option_get(NM_SETTING(setting), opt_name); + if (v && g_variant_is_of_type(v, G_VARIANT_TYPE_BOOLEAN)) { + NM_SET_OUT(out_value, g_variant_get_boolean(v)); + return TRUE; + } + NM_SET_OUT(out_value, FALSE); + return FALSE; } /** @@ -2633,20 +2632,17 @@ nm_setting_option_get_boolean (NMSetting *setting, * Since: 1.26 */ gboolean -nm_setting_option_get_uint32 (NMSetting *setting, - const char *opt_name, - guint32 *out_value) +nm_setting_option_get_uint32(NMSetting *setting, const char *opt_name, guint32 *out_value) { - GVariant *v; + GVariant *v; - v = nm_setting_option_get (NM_SETTING (setting), opt_name); - if ( v - && g_variant_is_of_type (v, G_VARIANT_TYPE_UINT32)) { - NM_SET_OUT (out_value, g_variant_get_uint32 (v)); - return TRUE; - } - NM_SET_OUT (out_value, 0); - return FALSE; + v = nm_setting_option_get(NM_SETTING(setting), opt_name); + if (v && g_variant_is_of_type(v, G_VARIANT_TYPE_UINT32)) { + NM_SET_OUT(out_value, g_variant_get_uint32(v)); + return TRUE; + } + NM_SET_OUT(out_value, 0); + return FALSE; } /** @@ -2661,63 +2657,59 @@ nm_setting_option_get_uint32 (NMSetting *setting, * * Note that not all setting types support options. It is a bug * setting a variant to a setting that doesn't support it. - * Currently only #NMSettingEthtool supports it. + * Currently, only #NMSettingEthtool supports it. * * Since: 1.26 */ void -nm_setting_option_set (NMSetting *setting, - const char *opt_name, - GVariant *variant) -{ - GVariant *old_variant; - gboolean changed_name; - gboolean changed_value; - GHashTable *hash; - - g_return_if_fail (NM_IS_SETTING (setting)); - g_return_if_fail (opt_name); - - hash = _nm_setting_option_hash (setting, variant != NULL); - - if (!variant) { - if (hash) { - if (g_hash_table_remove (hash, opt_name)) - _nm_setting_option_notify (setting, TRUE); - } - return; - } - - /* Currently, it is a bug setting any option, unless the setting type supports it. - * And currently, only NMSettingEthtool supports it. - * - * In the future, more setting types may support it. Or we may relax this so - * that options can be attached to all setting types (to indicate "unsupported" - * settings for forward compatibility). - * - * As it is today, internal code will only add gendata options to NMSettingEthtool, - * and there exists not public API to add such options. Still, it is permissible - * to call get(), clear() and set(variant=NULL) also on settings that don't support - * it, as these operations don't add options. - */ - g_return_if_fail (_nm_setting_class_get_sett_info (NM_SETTING_GET_CLASS (setting))->detail.gendata_info); - - old_variant = g_hash_table_lookup (hash, opt_name); - - changed_name = (old_variant == NULL); - changed_value = changed_name - || !g_variant_equal (old_variant, variant); - - /* We always want to replace the variant, even if it has - * the same value according to g_variant_equal(). The reason - * is that we want to take a reference on @variant, because - * that is what the user might expect. */ - g_hash_table_insert (hash, - g_strdup (opt_name), - g_variant_ref_sink (variant)); - - if (changed_value) - _nm_setting_option_notify (setting, !changed_name); +nm_setting_option_set(NMSetting *setting, const char *opt_name, GVariant *variant) +{ + GVariant * old_variant; + gboolean changed_name; + gboolean changed_value; + GHashTable *hash; + + g_return_if_fail(NM_IS_SETTING(setting)); + g_return_if_fail(opt_name); + + hash = _nm_setting_option_hash(setting, variant != NULL); + + if (!variant) { + if (hash) { + if (g_hash_table_remove(hash, opt_name)) + _nm_setting_option_notify(setting, TRUE); + } + return; + } + + /* Currently, it is a bug setting any option, unless the setting type supports it. + * And currently, only NMSettingEthtool supports it. + * + * In the future, more setting types may support it. Or we may relax this so + * that options can be attached to all setting types (to indicate "unsupported" + * settings for forward compatibility). + * + * As it is today, internal code will only add gendata options to NMSettingEthtool, + * and there exists not public API to add such options. Still, it is permissible + * to call get(), clear() and set(variant=NULL) also on settings that don't support + * it, as these operations don't add options. + */ + g_return_if_fail( + _nm_setting_class_get_sett_info(NM_SETTING_GET_CLASS(setting))->detail.gendata_info); + + old_variant = g_hash_table_lookup(hash, opt_name); + + changed_name = (old_variant == NULL); + changed_value = changed_name || !g_variant_equal(old_variant, variant); + + /* We always want to replace the variant, even if it has + * the same value according to g_variant_equal(). The reason + * is that we want to take a reference on @variant, because + * that is what the user might expect. */ + g_hash_table_insert(hash, g_strdup(opt_name), g_variant_ref_sink(variant)); + + if (changed_value) + _nm_setting_option_notify(setting, !changed_name); } /** @@ -2730,35 +2722,31 @@ nm_setting_option_set (NMSetting *setting, * Since: 1.26 */ void -nm_setting_option_set_boolean (NMSetting *setting, - const char *opt_name, - gboolean value) +nm_setting_option_set_boolean(NMSetting *setting, const char *opt_name, gboolean value) { - GVariant *old_variant; - gboolean changed_name; - gboolean changed_value; - GHashTable *hash; + GVariant * old_variant; + gboolean changed_name; + gboolean changed_value; + GHashTable *hash; - g_return_if_fail (NM_IS_SETTING (setting)); - g_return_if_fail (opt_name); + g_return_if_fail(NM_IS_SETTING(setting)); + g_return_if_fail(opt_name); - value = (!!value); + value = (!!value); - hash = _nm_setting_option_hash (setting, TRUE); + hash = _nm_setting_option_hash(setting, TRUE); - old_variant = g_hash_table_lookup (hash, opt_name); + old_variant = g_hash_table_lookup(hash, opt_name); - changed_name = (old_variant == NULL); - changed_value = changed_name - || ( !g_variant_is_of_type (old_variant, G_VARIANT_TYPE_BOOLEAN) - || g_variant_get_boolean (old_variant) != value); + changed_name = (old_variant == NULL); + changed_value = changed_name + || (!g_variant_is_of_type(old_variant, G_VARIANT_TYPE_BOOLEAN) + || g_variant_get_boolean(old_variant) != value); - g_hash_table_insert (hash, - g_strdup (opt_name), - g_variant_ref_sink (g_variant_new_boolean (value))); + g_hash_table_insert(hash, g_strdup(opt_name), g_variant_ref_sink(g_variant_new_boolean(value))); - if (changed_value) - _nm_setting_option_notify (setting, !changed_name); + if (changed_value) + _nm_setting_option_notify(setting, !changed_name); } /** @@ -2771,108 +2759,102 @@ nm_setting_option_set_boolean (NMSetting *setting, * Since: 1.26 */ void -nm_setting_option_set_uint32 (NMSetting *setting, - const char *opt_name, - guint32 value) +nm_setting_option_set_uint32(NMSetting *setting, const char *opt_name, guint32 value) { - GVariant *old_variant; - gboolean changed_name; - gboolean changed_value; - GHashTable *hash; + GVariant * old_variant; + gboolean changed_name; + gboolean changed_value; + GHashTable *hash; - g_return_if_fail (NM_IS_SETTING (setting)); - g_return_if_fail (opt_name); + g_return_if_fail(NM_IS_SETTING(setting)); + g_return_if_fail(opt_name); - hash = _nm_setting_option_hash (setting, TRUE); + hash = _nm_setting_option_hash(setting, TRUE); - old_variant = g_hash_table_lookup (hash, opt_name); + old_variant = g_hash_table_lookup(hash, opt_name); - changed_name = (old_variant == NULL); - changed_value = changed_name - || ( !g_variant_is_of_type (old_variant, G_VARIANT_TYPE_UINT32) - || g_variant_get_uint32 (old_variant) != value); + changed_name = (old_variant == NULL); + changed_value = changed_name + || (!g_variant_is_of_type(old_variant, G_VARIANT_TYPE_UINT32) + || g_variant_get_uint32(old_variant) != value); - g_hash_table_insert (hash, - g_strdup (opt_name), - g_variant_ref_sink (g_variant_new_uint32 (value))); + g_hash_table_insert(hash, g_strdup(opt_name), g_variant_ref_sink(g_variant_new_uint32(value))); - if (changed_value) - _nm_setting_option_notify (setting, !changed_name); + if (changed_value) + _nm_setting_option_notify(setting, !changed_name); } /*****************************************************************************/ static void -get_property (GObject *object, guint prop_id, - GValue *value, GParamSpec *pspec) +get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { - NMSetting *setting = NM_SETTING (object); + NMSetting *setting = NM_SETTING(object); - switch (prop_id) { - case PROP_NAME: - g_value_set_string (value, nm_setting_get_name (setting)); - break; - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); - break; - } + switch (prop_id) { + case PROP_NAME: + g_value_set_string(value, nm_setting_get_name(setting)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + break; + } } /*****************************************************************************/ static void -nm_setting_init (NMSetting *setting) -{ -} +nm_setting_init(NMSetting *setting) +{} static void -finalize (GObject *object) +finalize(GObject *object) { - NMSettingPrivate *priv = NM_SETTING_GET_PRIVATE (object); + NMSettingPrivate *priv = NM_SETTING_GET_PRIVATE(object); - if (priv->gendata) { - g_free (priv->gendata->names); - g_free (priv->gendata->values); - g_hash_table_unref (priv->gendata->hash); - g_slice_free (GenData, priv->gendata); - } + if (priv->gendata) { + g_free(priv->gendata->names); + g_free(priv->gendata->values); + g_hash_table_unref(priv->gendata->hash); + g_slice_free(GenData, priv->gendata); + } - G_OBJECT_CLASS (nm_setting_parent_class)->finalize (object); + G_OBJECT_CLASS(nm_setting_parent_class)->finalize(object); } static void -nm_setting_class_init (NMSettingClass *setting_class) -{ - GObjectClass *object_class = G_OBJECT_CLASS (setting_class); - - g_type_class_add_private (setting_class, sizeof (NMSettingPrivate)); - - object_class->get_property = get_property; - object_class->finalize = finalize; - - setting_class->update_one_secret = update_one_secret; - setting_class->get_secret_flags = get_secret_flags; - setting_class->set_secret_flags = set_secret_flags; - setting_class->compare_property = compare_property; - setting_class->clear_secrets = clear_secrets; - setting_class->for_each_secret = for_each_secret; - setting_class->duplicate_copy_properties = duplicate_copy_properties; - setting_class->enumerate_values = enumerate_values; - setting_class->aggregate = aggregate; - setting_class->init_from_dbus = init_from_dbus; - - /** - * NMSetting:name: - * - * The setting's name, which uniquely identifies the setting within the - * connection. Each setting type has a name unique to that type, for - * example "ppp" or "802-11-wireless" or "802-3-ethernet". - **/ - obj_properties[PROP_NAME] = - g_param_spec_string (NM_SETTING_NAME, "", "", - NULL, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS); - - g_object_class_install_properties (object_class, _PROPERTY_ENUMS_LAST, obj_properties); +nm_setting_class_init(NMSettingClass *setting_class) +{ + GObjectClass *object_class = G_OBJECT_CLASS(setting_class); + + g_type_class_add_private(setting_class, sizeof(NMSettingPrivate)); + + object_class->get_property = get_property; + object_class->finalize = finalize; + + setting_class->update_one_secret = update_one_secret; + setting_class->get_secret_flags = get_secret_flags; + setting_class->set_secret_flags = set_secret_flags; + setting_class->compare_property = compare_property; + setting_class->clear_secrets = clear_secrets; + setting_class->for_each_secret = for_each_secret; + setting_class->duplicate_copy_properties = duplicate_copy_properties; + setting_class->enumerate_values = enumerate_values; + setting_class->aggregate = aggregate; + setting_class->init_from_dbus = init_from_dbus; + + /** + * NMSetting:name: + * + * The setting's name, which uniquely identifies the setting within the + * connection. Each setting type has a name unique to that type, for + * example "ppp" or "802-11-wireless" or "802-3-ethernet". + **/ + obj_properties[PROP_NAME] = g_param_spec_string(NM_SETTING_NAME, + "", + "", + NULL, + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties); } |