/* SPDX-License-Identifier: LGPL-2.1-or-later */ /* * Copyright (C) 2011 - 2014 Red Hat, Inc. */ #include "libnm-core/nm-default-libnm-core.h" #include "nm-setting-vlan.h" #include #include "nm-libnm-core-intern/nm-libnm-core-utils.h" #include "nm-utils.h" #include "nm-core-types-internal.h" #include "nm-setting-connection.h" #include "nm-setting-private.h" #include "nm-setting-wired.h" #include "nm-connection-private.h" /** * SECTION:nm-setting-vlan * @short_description: Describes connection properties for VLAN interfaces * * The #NMSettingVlan object is a #NMSetting subclass that describes properties * necessary for connection to VLAN interfaces. **/ /*****************************************************************************/ NM_GOBJECT_PROPERTIES_DEFINE(NMSettingVlan, PROP_PARENT, PROP_ID, PROP_FLAGS, PROP_INGRESS_PRIORITY_MAP, PROP_EGRESS_PRIORITY_MAP, ); typedef struct { GSList *ingress_priority_map; GSList *egress_priority_map; char * parent; guint32 id; guint32 flags; } NMSettingVlanPrivate; G_DEFINE_TYPE(NMSettingVlan, nm_setting_vlan, NM_TYPE_SETTING) #define NM_SETTING_VLAN_GET_PRIVATE(o) \ (G_TYPE_INSTANCE_GET_PRIVATE((o), NM_TYPE_SETTING_VLAN, NMSettingVlanPrivate)) /*****************************************************************************/ #define MAX_SKB_PRIO G_MAXUINT32 #define MAX_8021P_PRIO 7 /* Max 802.1p priority */ /** * nm_setting_vlan_get_parent: * @setting: the #NMSettingVlan * * Returns: the #NMSettingVlan:parent property of the setting **/ const char * nm_setting_vlan_get_parent(NMSettingVlan *setting) { g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), NULL); return NM_SETTING_VLAN_GET_PRIVATE(setting)->parent; } /** * nm_setting_vlan_get_id: * @setting: the #NMSettingVlan * * Returns: the #NMSettingVlan:id property of the setting **/ guint32 nm_setting_vlan_get_id(NMSettingVlan *setting) { g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), 0); return NM_SETTING_VLAN_GET_PRIVATE(setting)->id; } /** * nm_setting_vlan_get_flags: * @setting: the #NMSettingVlan * * Returns: the #NMSettingVlan:flags property of the setting **/ guint32 nm_setting_vlan_get_flags(NMSettingVlan *setting) { g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), 0); return NM_SETTING_VLAN_GET_PRIVATE(setting)->flags; } static NMVlanQosMapping * priority_map_new(guint32 from, guint32 to) { NMVlanQosMapping *mapping; mapping = g_new(NMVlanQosMapping, 1); *mapping = (NMVlanQosMapping){ .from = from, .to = to, }; return mapping; } static NMVlanQosMapping * priority_map_new_from_str(NMVlanPriorityMap map, const char *str) { guint32 from, to; if (!nm_utils_vlan_priority_map_parse_str(map, str, FALSE, &from, &to, NULL)) return NULL; return priority_map_new(from, to); } static void priority_map_free(NMVlanQosMapping *map) { nm_assert(map); g_free(map); } static GSList * get_map(NMSettingVlan *self, NMVlanPriorityMap map) { if (map == NM_VLAN_INGRESS_MAP) return NM_SETTING_VLAN_GET_PRIVATE(self)->ingress_priority_map; else if (map == NM_VLAN_EGRESS_MAP) return NM_SETTING_VLAN_GET_PRIVATE(self)->egress_priority_map; nm_assert_not_reached(); return NULL; } static int prio_map_compare(gconstpointer p_a, gconstpointer p_b) { const NMVlanQosMapping *a = p_a; const NMVlanQosMapping *b = p_b; return a->from < b->from ? -1 : (a->from > b->from ? 1 : (a->to < b->to ? -1 : (a->to > b->to ? 1 : 0))); } static void set_map(NMSettingVlan *self, NMVlanPriorityMap map, GSList *list) { /* Assert that the list is sorted */ #if NM_MORE_ASSERTS >= 2 { GSList *iter, *last; last = list; iter = list ? list->next : NULL; while (iter) { const NMVlanQosMapping *l = last->data; const NMVlanQosMapping *m = iter->data; nm_assert(prio_map_compare(last->data, iter->data) < 0); /* Also reject duplicates (based on "from") */ nm_assert(l->from < m->from); last = iter; iter = iter->next; } } #endif if (map == NM_VLAN_INGRESS_MAP) { NM_SETTING_VLAN_GET_PRIVATE(self)->ingress_priority_map = list; _notify(self, PROP_INGRESS_PRIORITY_MAP); } else if (map == NM_VLAN_EGRESS_MAP) { NM_SETTING_VLAN_GET_PRIVATE(self)->egress_priority_map = list; _notify(self, PROP_EGRESS_PRIORITY_MAP); } else nm_assert_not_reached(); } static gboolean check_replace_duplicate_priority(GSList *list, guint32 from, guint32 to) { GSList * iter; NMVlanQosMapping *p; for (iter = list; iter; iter = g_slist_next(iter)) { p = iter->data; if (p->from == from) { p->to = to; return TRUE; } } return FALSE; } /** * nm_setting_vlan_add_priority_str: * @setting: the #NMSettingVlan * @map: the type of priority map * @str: the string which contains a priority map, like "3:7" * * Adds a priority map entry into either the #NMSettingVlan:ingress_priority_map * or the #NMSettingVlan:egress_priority_map properties. The priority map maps * the Linux SKB priorities to 802.1p priorities. * * Returns: %TRUE if the entry was successfully added to the list, or it * overwrote the old value, %FALSE if @str is not a valid mapping. */ gboolean nm_setting_vlan_add_priority_str(NMSettingVlan *setting, NMVlanPriorityMap map, const char *str) { GSList * list = NULL; NMVlanQosMapping *item = NULL; g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), FALSE); g_return_val_if_fail(map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP, FALSE); g_return_val_if_fail(str && str[0], FALSE); item = priority_map_new_from_str(map, str); if (!item) return FALSE; list = get_map(setting, map); /* Duplicates get replaced */ if (check_replace_duplicate_priority(list, item->from, item->to)) { g_free(item); if (map == NM_VLAN_INGRESS_MAP) _notify(setting, PROP_INGRESS_PRIORITY_MAP); else _notify(setting, PROP_EGRESS_PRIORITY_MAP); return TRUE; } set_map(setting, map, g_slist_insert_sorted(list, item, prio_map_compare)); return TRUE; } /** * nm_setting_vlan_get_num_priorities: * @setting: the #NMSettingVlan * @map: the type of priority map * * Returns the number of entries in the * #NMSettingVlan:ingress_priority_map or #NMSettingVlan:egress_priority_map * properties of this setting. * * Returns: return the number of ingress/egress priority entries. **/ gint32 nm_setting_vlan_get_num_priorities(NMSettingVlan *setting, NMVlanPriorityMap map) { g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), -1); g_return_val_if_fail(map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP, -1); return g_slist_length(get_map(setting, map)); } /** * nm_setting_vlan_get_priority: * @setting: the #NMSettingVlan * @map: the type of priority map * @idx: the zero-based index of the ingress/egress priority map entry * @out_from: (out) (allow-none): on return the value of the priority map's 'from' item * @out_to: (out) (allow-none): on return the value of priority map's 'to' item * * Retrieve one of the entries of the #NMSettingVlan:ingress_priority_map * or #NMSettingVlan:egress_priority_map properties of this setting. * * Returns: returns %TRUE if @idx is in range. Otherwise, %FALSE. **/ gboolean nm_setting_vlan_get_priority(NMSettingVlan * setting, NMVlanPriorityMap map, guint32 idx, guint32 * out_from, guint32 * out_to) { NMVlanQosMapping *item; GSList * list; g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), FALSE); g_return_val_if_fail(NM_IN_SET(map, NM_VLAN_INGRESS_MAP, NM_VLAN_EGRESS_MAP), FALSE); list = get_map(setting, map); item = g_slist_nth_data(list, idx); if (!item) { NM_SET_OUT(out_from, 0); NM_SET_OUT(out_to, 0); return FALSE; } NM_SET_OUT(out_from, item->from); NM_SET_OUT(out_to, item->to); return TRUE; } /** * nm_setting_vlan_add_priority: * @setting: the #NMSettingVlan * @map: the type of priority map * @from: the priority to map to @to * @to: the priority to map @from to * * Adds a priority mapping to the #NMSettingVlan:ingress_priority_map or * #NMSettingVlan:egress_priority_map properties of the setting. If @from is * already in the given priority map, this function will overwrite the * existing entry with the new @to. * * If @map is #NM_VLAN_INGRESS_MAP then @from is the incoming 802.1q VLAN * Priority Code Point (PCP) value, and @to is the Linux SKB priority value. * * If @map is #NM_VLAN_EGRESS_MAP then @from is the Linux SKB priority value and * @to is the outgoing 802.1q VLAN Priority Code Point (PCP) value. * * Returns: %TRUE. */ gboolean nm_setting_vlan_add_priority(NMSettingVlan * setting, NMVlanPriorityMap map, guint32 from, guint32 to) { GSList * list = NULL; NMVlanQosMapping *item; g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), FALSE); g_return_val_if_fail(map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP, FALSE); list = get_map(setting, map); if (check_replace_duplicate_priority(list, from, to)) { if (map == NM_VLAN_INGRESS_MAP) _notify(setting, PROP_INGRESS_PRIORITY_MAP); else _notify(setting, PROP_EGRESS_PRIORITY_MAP); return TRUE; } item = g_malloc0(sizeof(NMVlanQosMapping)); item->from = from; item->to = to; set_map(setting, map, g_slist_insert_sorted(list, item, prio_map_compare)); return TRUE; } gboolean _nm_setting_vlan_set_priorities(NMSettingVlan * setting, NMVlanPriorityMap map, const NMVlanQosMapping *qos_map, guint n_qos_map) { gboolean has_changes = FALSE; GSList * map_prev, *map_new; guint i; gint64 from_last; map_prev = get_map(setting, map); if (n_qos_map != g_slist_length(map_prev)) has_changes = TRUE; else { const GSList *iter; iter = map_prev; for (i = 0; i < n_qos_map; i++, iter = iter->next) { const NMVlanQosMapping *m = iter->data; if (m->from != qos_map[i].from || m->to != qos_map[i].to) { has_changes = TRUE; break; } } } if (!has_changes) return FALSE; map_new = NULL; from_last = G_MAXINT64; for (i = n_qos_map; i > 0;) { const NMVlanQosMapping *m = &qos_map[--i]; NMVlanQosMapping * item; /* We require the array to be presorted. */ if (m->from >= from_last) g_return_val_if_reached(FALSE); from_last = m->from; item = g_malloc0(sizeof(NMVlanQosMapping)); item->from = m->from; item->to = m->to; map_new = g_slist_prepend(map_new, item); } g_slist_free_full(map_prev, g_free); set_map(setting, map, map_new); return TRUE; } void _nm_setting_vlan_get_priorities(NMSettingVlan * setting, NMVlanPriorityMap map, NMVlanQosMapping **out_qos_map, guint * out_n_qos_map) { GSList * list; NMVlanQosMapping *qos_map = NULL; guint n_qos_map, i; list = get_map(setting, map); n_qos_map = g_slist_length(list); if (n_qos_map > 0) { qos_map = g_new(NMVlanQosMapping, n_qos_map); for (i = 0; list; i++, list = list->next) { nm_assert(i < n_qos_map); qos_map[i] = *((const NMVlanQosMapping *) list->data); } } *out_qos_map = qos_map; *out_n_qos_map = n_qos_map; } /** * nm_setting_vlan_remove_priority: * @setting: the #NMSettingVlan * @map: the type of priority map * @idx: the zero-based index of the priority map to remove * * Removes the priority map at index @idx from the * #NMSettingVlan:ingress_priority_map or #NMSettingVlan:egress_priority_map * properties. */ void nm_setting_vlan_remove_priority(NMSettingVlan *setting, NMVlanPriorityMap map, guint32 idx) { GSList *list = NULL, *item = NULL; g_return_if_fail(NM_IS_SETTING_VLAN(setting)); g_return_if_fail(map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP); list = get_map(setting, map); g_return_if_fail(idx < g_slist_length(list)); item = g_slist_nth(list, idx); priority_map_free((NMVlanQosMapping *) (item->data)); set_map(setting, map, g_slist_delete_link(list, item)); } static gboolean priority_map_remove_by_value(NMSettingVlan * setting, NMVlanPriorityMap map, guint32 from, guint32 to, gboolean wildcard_to) { GSList * list = NULL, *iter = NULL; NMVlanQosMapping *item; nm_assert(NM_IS_SETTING_VLAN(setting)); nm_assert(NM_IN_SET(map, NM_VLAN_INGRESS_MAP, NM_VLAN_EGRESS_MAP)); list = get_map(setting, map); for (iter = list; iter; iter = g_slist_next(iter)) { item = iter->data; if (item->from != from) continue; if (!wildcard_to && item->to != to) continue; priority_map_free((NMVlanQosMapping *) (iter->data)); set_map(setting, map, g_slist_delete_link(list, iter)); return TRUE; } return FALSE; } /** * nm_setting_vlan_remove_priority_by_value: * @setting: the #NMSettingVlan * @map: the type of priority map * @from: the priority to map to @to * @to: the priority to map @from to * * Removes the priority map @form:@to from the #NMSettingVlan:ingress_priority_map * or #NMSettingVlan:egress_priority_map (according to @map argument) * properties. * * Returns: %TRUE if the priority mapping was found and removed; %FALSE if it was not. */ gboolean nm_setting_vlan_remove_priority_by_value(NMSettingVlan * setting, NMVlanPriorityMap map, guint32 from, guint32 to) { g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), FALSE); g_return_val_if_fail(map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP, FALSE); return priority_map_remove_by_value(setting, map, from, to, FALSE); } /** * nm_setting_vlan_remove_priority_str_by_value: * @setting: the #NMSettingVlan * @map: the type of priority map * @str: the string which contains a priority map, like "3:7" * * Removes the priority map @str from the #NMSettingVlan:ingress_priority_map * or #NMSettingVlan:egress_priority_map (according to @map argument) * properties. * * Returns: %TRUE if the priority mapping was found and removed; %FALSE if it was not. */ gboolean nm_setting_vlan_remove_priority_str_by_value(NMSettingVlan * setting, NMVlanPriorityMap map, const char * str) { gboolean is_wildcard_to; guint32 from, to; g_return_val_if_fail(NM_IS_SETTING_VLAN(setting), FALSE); g_return_val_if_fail(map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP, FALSE); if (!nm_utils_vlan_priority_map_parse_str(map, str, TRUE, &from, &to, &is_wildcard_to)) return FALSE; return priority_map_remove_by_value(setting, map, from, to, is_wildcard_to); } /** * nm_setting_vlan_clear_priorities: * @setting: the #NMSettingVlan * @map: the type of priority map * * Clear all the entries from #NMSettingVlan:ingress_priority_map or * #NMSettingVlan:egress_priority_map properties. */ void nm_setting_vlan_clear_priorities(NMSettingVlan *setting, NMVlanPriorityMap map) { GSList *list = NULL; g_return_if_fail(NM_IS_SETTING_VLAN(setting)); g_return_if_fail(map == NM_VLAN_INGRESS_MAP || map == NM_VLAN_EGRESS_MAP); list = get_map(setting, map); g_slist_free_full(list, g_free); set_map(setting, map, NULL); } /*****************************************************************************/ static int verify(NMSetting *setting, NMConnection *connection, GError **error) { NMSettingVlanPrivate *priv = NM_SETTING_VLAN_GET_PRIVATE(setting); NMSettingConnection * s_con; NMSettingWired * s_wired; if (connection) { s_con = nm_connection_get_setting_connection(connection); s_wired = nm_connection_get_setting_wired(connection); } else { s_con = NULL; s_wired = NULL; } if (priv->parent) { if (nm_utils_is_uuid(priv->parent)) { /* If we have an NMSettingConnection:master with slave-type="vlan", * then it must be the same UUID. */ if (s_con) { const char *master = NULL, *slave_type = NULL; slave_type = nm_setting_connection_get_slave_type(s_con); if (!g_strcmp0(slave_type, NM_SETTING_VLAN_SETTING_NAME)) master = nm_setting_connection_get_master(s_con); if (master && g_strcmp0(priv->parent, master) != 0) { g_set_error(error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, _("'%s' value doesn't match '%s=%s'"), priv->parent, NM_SETTING_CONNECTION_MASTER, master); g_prefix_error(error, "%s.%s: ", NM_SETTING_VLAN_SETTING_NAME, NM_SETTING_VLAN_PARENT); return FALSE; } } } else if (!nm_utils_ifname_valid_kernel(priv->parent, NULL)) { /* parent must be either a UUID or an interface name */ g_set_error(error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, _("'%s' is neither an UUID nor an interface name"), priv->parent); g_prefix_error(error, "%s.%s: ", NM_SETTING_VLAN_SETTING_NAME, NM_SETTING_VLAN_PARENT); return FALSE; } } else { /* If parent is NULL, the parent must be specified via * NMSettingWired:mac-address. */ if (connection && (!s_wired || !nm_setting_wired_get_mac_address(s_wired))) { g_set_error(error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_MISSING_PROPERTY, _("property is not specified and neither is '%s:%s'"), NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_MAC_ADDRESS); g_prefix_error(error, "%s.%s: ", NM_SETTING_VLAN_SETTING_NAME, NM_SETTING_VLAN_PARENT); return FALSE; } } if (priv->id >= 4095) { g_set_error(error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, _("the vlan id must be in range 0-4094 but is %u"), priv->id); g_prefix_error(error, "%s.%s: ", NM_SETTING_VLAN_SETTING_NAME, NM_SETTING_VLAN_ID); return FALSE; } if (priv->flags & ~NM_VLAN_FLAGS_ALL) { g_set_error_literal(error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_INVALID_PROPERTY, _("flags are invalid")); g_prefix_error(error, "%s.%s: ", NM_SETTING_VLAN_SETTING_NAME, NM_SETTING_VLAN_FLAGS); return FALSE; } if (connection && !s_wired) { /* technically, a VLAN setting does not require an ethernet setting. However, * the ifcfg-rh reader always adds a ethernet setting when reading a vlan setting. * Thus, in order to be consistent, always add one via normalization. */ g_set_error_literal(error, NM_CONNECTION_ERROR, NM_CONNECTION_ERROR_SETTING_NOT_FOUND, _("vlan setting should have a ethernet setting as well")); g_prefix_error(error, "%s.%s: ", NM_SETTING_VLAN_SETTING_NAME, NM_SETTING_VLAN_FLAGS); return NM_SETTING_VERIFY_NORMALIZABLE; } return TRUE; } static GVariant * _override_flags_get(const NMSettInfoSetting * sett_info, guint property_idx, NMConnection * connection, NMSetting * setting, NMConnectionSerializationFlags flags, const NMConnectionSerializationOptions *options) { return g_variant_new_uint32(nm_setting_vlan_get_flags((NMSettingVlan *) setting)); } static gboolean _override_flags_not_set(NMSetting * setting, GVariant * connection_dict, const char * property, NMSettingParseFlags parse_flags, GError ** error) { /* we changed the default value for FLAGS. When an older client * doesn't serialize the property, we assume it is the old default. */ g_object_set(G_OBJECT(setting), NM_SETTING_VLAN_FLAGS, (NMVlanFlags) 0, NULL); return TRUE; } static GSList * priority_strv_to_maplist(NMVlanPriorityMap map, char **strv) { GSList *list = NULL; gsize i; for (i = 0; strv && strv[i]; i++) { guint32 from, to; if (!nm_utils_vlan_priority_map_parse_str(map, strv[i], FALSE, &from, &to, NULL)) continue; if (check_replace_duplicate_priority(list, from, to)) continue; list = g_slist_prepend(list, priority_map_new(from, to)); } return g_slist_sort(list, prio_map_compare); } static char ** priority_maplist_to_strv(GSList *list) { GSList * iter; GPtrArray *strv; strv = g_ptr_array_new(); for (iter = list; iter; iter = g_slist_next(iter)) { NMVlanQosMapping *item = iter->data; g_ptr_array_add(strv, g_strdup_printf("%d:%d", item->from, item->to)); } g_ptr_array_add(strv, NULL); return (char **) g_ptr_array_free(strv, FALSE); } /*****************************************************************************/ static void get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { NMSettingVlan * setting = NM_SETTING_VLAN(object); NMSettingVlanPrivate *priv = NM_SETTING_VLAN_GET_PRIVATE(setting); switch (prop_id) { case PROP_PARENT: g_value_set_string(value, priv->parent); break; case PROP_ID: g_value_set_uint(value, priv->id); break; case PROP_FLAGS: g_value_set_flags(value, priv->flags); break; case PROP_INGRESS_PRIORITY_MAP: g_value_take_boxed(value, priority_maplist_to_strv(priv->ingress_priority_map)); break; case PROP_EGRESS_PRIORITY_MAP: g_value_take_boxed(value, priority_maplist_to_strv(priv->egress_priority_map)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } } static void set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { NMSettingVlan * setting = NM_SETTING_VLAN(object); NMSettingVlanPrivate *priv = NM_SETTING_VLAN_GET_PRIVATE(setting); switch (prop_id) { case PROP_PARENT: g_free(priv->parent); priv->parent = g_value_dup_string(value); break; case PROP_ID: priv->id = g_value_get_uint(value); break; case PROP_FLAGS: priv->flags = g_value_get_flags(value); break; case PROP_INGRESS_PRIORITY_MAP: g_slist_free_full(priv->ingress_priority_map, g_free); priv->ingress_priority_map = priority_strv_to_maplist(NM_VLAN_INGRESS_MAP, g_value_get_boxed(value)); break; case PROP_EGRESS_PRIORITY_MAP: g_slist_free_full(priv->egress_priority_map, g_free); priv->egress_priority_map = priority_strv_to_maplist(NM_VLAN_EGRESS_MAP, g_value_get_boxed(value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); break; } } /*****************************************************************************/ static void nm_setting_vlan_init(NMSettingVlan *self) { NMSettingVlanPrivate *priv = NM_SETTING_VLAN_GET_PRIVATE(self); priv->flags = NM_VLAN_FLAG_REORDER_HEADERS; } /** * nm_setting_vlan_new: * * Creates a new #NMSettingVlan object with default values. * * Returns: (transfer full): the new empty #NMSettingVlan object **/ NMSetting * nm_setting_vlan_new(void) { return g_object_new(NM_TYPE_SETTING_VLAN, NULL); } static void finalize(GObject *object) { NMSettingVlan * setting = NM_SETTING_VLAN(object); NMSettingVlanPrivate *priv = NM_SETTING_VLAN_GET_PRIVATE(setting); g_free(priv->parent); g_slist_free_full(priv->ingress_priority_map, g_free); g_slist_free_full(priv->egress_priority_map, g_free); G_OBJECT_CLASS(nm_setting_vlan_parent_class)->finalize(object); } static void nm_setting_vlan_class_init(NMSettingVlanClass *klass) { GObjectClass * object_class = G_OBJECT_CLASS(klass); NMSettingClass *setting_class = NM_SETTING_CLASS(klass); GArray * properties_override = _nm_sett_info_property_override_create_array(); g_type_class_add_private(klass, sizeof(NMSettingVlanPrivate)); object_class->get_property = get_property; object_class->set_property = set_property; object_class->finalize = finalize; setting_class->verify = verify; /** * NMSettingVlan:parent: * * If given, specifies the parent interface name or parent connection UUID * from which this VLAN interface should be created. If this property is * not specified, the connection must contain an #NMSettingWired setting * with a #NMSettingWired:mac-address property. **/ /* ---ifcfg-rh--- * property: parent * variable: DEVICE or PHYSDEV * description: Parent interface of the VLAN. * ---end--- */ obj_properties[PROP_PARENT] = g_param_spec_string( NM_SETTING_VLAN_PARENT, "", "", NULL, G_PARAM_READWRITE | NM_SETTING_PARAM_INFERRABLE | G_PARAM_STATIC_STRINGS); /** * NMSettingVlan:id: * * The VLAN identifier that the interface created by this connection should * be assigned. The valid range is from 0 to 4094, without the reserved id 4095. **/ /* ---ifcfg-rh--- * property: id * variable: VLAN_ID or DEVICE * description: VLAN identifier. * ---end--- */ obj_properties[PROP_ID] = g_param_spec_uint(NM_SETTING_VLAN_ID, "", "", 0, 4095, 0, G_PARAM_READWRITE | NM_SETTING_PARAM_INFERRABLE | G_PARAM_STATIC_STRINGS); /** * NMSettingVlan:flags: * * One or more flags which control the behavior and features of the VLAN * interface. Flags include %NM_VLAN_FLAG_REORDER_HEADERS (reordering of * output packet headers), %NM_VLAN_FLAG_GVRP (use of the GVRP protocol), * and %NM_VLAN_FLAG_LOOSE_BINDING (loose binding of the interface to its * master device's operating state). %NM_VLAN_FLAG_MVRP (use of the MVRP * protocol). * * The default value of this property is NM_VLAN_FLAG_REORDER_HEADERS, * but it used to be 0. To preserve backward compatibility, the default-value * in the D-Bus API continues to be 0 and a missing property on D-Bus * is still considered as 0. **/ /* ---ifcfg-rh--- * property: flags * variable: GVRP, MVRP, VLAN_FLAGS * values: "yes or "no" for GVRP and MVRP; "LOOSE_BINDING" and "NO_REORDER_HDR" for VLAN_FLAGS * description: VLAN flags. * ---end--- */ obj_properties[PROP_FLAGS] = g_param_spec_flags(NM_SETTING_VLAN_FLAGS, "", "", NM_TYPE_VLAN_FLAGS, NM_VLAN_FLAG_REORDER_HEADERS, G_PARAM_READWRITE | NM_SETTING_PARAM_INFERRABLE | G_PARAM_STATIC_STRINGS); _nm_properties_override_gobj( properties_override, obj_properties[PROP_FLAGS], NM_SETT_INFO_PROPERT_TYPE(.dbus_type = G_VARIANT_TYPE_UINT32, .to_dbus_fcn = _override_flags_get, .missing_from_dbus_fcn = _override_flags_not_set, )); /** * NMSettingVlan:ingress-priority-map: * * For incoming packets, a list of mappings from 802.1p priorities to Linux * SKB priorities. The mapping is given in the format "from:to" where both * "from" and "to" are unsigned integers, ie "7:3". **/ /* ---ifcfg-rh--- * property: ingress-priority-map * variable: VLAN_INGRESS_PRIORITY_MAP * description: Ingress priority mapping. * example: VLAN_INGRESS_PRIORITY_MAP=4:2,3:5 * ---end--- */ obj_properties[PROP_INGRESS_PRIORITY_MAP] = g_param_spec_boxed( NM_SETTING_VLAN_INGRESS_PRIORITY_MAP, "", "", G_TYPE_STRV, G_PARAM_READWRITE | NM_SETTING_PARAM_INFERRABLE | G_PARAM_STATIC_STRINGS); /** * NMSettingVlan:egress-priority-map: * * For outgoing packets, a list of mappings from Linux SKB priorities to * 802.1p priorities. The mapping is given in the format "from:to" where * both "from" and "to" are unsigned integers, ie "7:3". **/ /* ---ifcfg-rh--- * property: egress-priority-map * variable: VLAN_EGRESS_PRIORITY_MAP * description: Egress priority mapping. * example: VLAN_EGRESS_PRIORITY_MAP=5:4,4:1,3:7 * ---end--- */ obj_properties[PROP_EGRESS_PRIORITY_MAP] = g_param_spec_boxed( NM_SETTING_VLAN_EGRESS_PRIORITY_MAP, "", "", G_TYPE_STRV, G_PARAM_READWRITE | NM_SETTING_PARAM_INFERRABLE | G_PARAM_STATIC_STRINGS); /* ---ifcfg-rh--- * property: interface-name * variable: PHYSDEV and VLAN_ID, or DEVICE * description: VLAN interface name. * If all variables are set, parent device from PHYSDEV takes precedence over DEVICE, * but VLAN id from DEVICE takes precedence over VLAN_ID. * example: PHYSDEV=eth0, VLAN_ID=12; or DEVICE=eth0.12 * ---end--- * ---dbus--- * property: interface-name * format: string * description: Deprecated in favor of connection.interface-name, but can * be used for backward-compatibility with older daemons, to set the * vlan's interface name. * ---end--- */ _nm_properties_override_dbus(properties_override, "interface-name", &nm_sett_info_propert_type_deprecated_interface_name); g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties); _nm_setting_class_commit_full(setting_class, NM_META_SETTING_TYPE_VLAN, NULL, properties_override); }