mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager
synced 2024-10-06 16:21:50 +00:00
1cab6367b2
G_PARAM_CONSTRUCT cause to explicitly initialize the property during object construction. This is an unnecessary overhead that we can easily avoid. The overhead is because G_PARAM_CONSTRUCT parameters are always set with g_object_set() before calling constructed(). Even if they are not specified during g_object_new(), in which case it calls set with the property's default value. This also requires g_object_new() to iterate all properties to find and sort the construct properties. NMSetting are supposed to be simple classes. They don't need to have their properties initialized before object construction completes. Especially if the default values are NULL or zero, in which case there is nothing to do. If the default value is not NULL or zero, we need to initialize the field instead in the nm_setting*_init() function.
984 lines
29 KiB
C
984 lines
29 KiB
C
// SPDX-License-Identifier: LGPL-2.1+
|
|
/*
|
|
* Copyright (C) 2011 - 2014 Red Hat, Inc.
|
|
*/
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include "nm-setting-vlan.h"
|
|
|
|
#include <stdlib.h>
|
|
|
|
#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_is_valid_iface_name (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 (NMSetting *) 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);
|
|
}
|