mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager
synced 2024-10-02 22:38:01 +00:00
8bace23beb
- All internal source files (except "examples", which are not internal) should include "config.h" first. As also all internal source files should include "nm-default.h", let "config.h" be included by "nm-default.h" and include "nm-default.h" as first in every source file. We already wanted to include "nm-default.h" before other headers because it might contains some fixes (like "nm-glib.h" compatibility) that is required first. - After including "nm-default.h", we optinally allow for including the corresponding header file for the source file at hand. The idea is to ensure that each header file is self contained. - Don't include "config.h" or "nm-default.h" in any header file (except "nm-sd-adapt.h"). Public headers anyway must not include these headers, and internal headers are never included after "nm-default.h", as of the first previous point. - Include all internal headers with quotes instead of angle brackets. In practice it doesn't matter, because in our public headers we must include other headers with angle brackets. As we use our public headers also to compile our interal source files, effectively the result must be the same. Still do it for consistency. - Except for <config.h> itself. Include it with angle brackets as suggested by https://www.gnu.org/software/autoconf/manual/autoconf.html#Configuration-Headers
853 lines
26 KiB
C
853 lines
26 KiB
C
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
|
|
|
|
/*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301 USA.
|
|
*
|
|
* Copyright 2011 - 2014 Red Hat, Inc.
|
|
*/
|
|
|
|
#include "nm-default.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <dbus/dbus-glib.h>
|
|
|
|
#include "nm-setting-vlan.h"
|
|
#include "nm-param-spec-specialized.h"
|
|
#include "nm-utils.h"
|
|
#include "nm-dbus-glib-types.h"
|
|
#include "nm-setting-connection.h"
|
|
#include "nm-setting-private.h"
|
|
|
|
/**
|
|
* SECTION:nm-setting-vlan
|
|
* @short_description: Describes connection properties for VLAN interfaces
|
|
* @include: nm-setting-vlan.h
|
|
*
|
|
* The #NMSettingVlan object is a #NMSetting subclass that describes properties
|
|
* necessary for connection to VLAN interfaces.
|
|
**/
|
|
|
|
/**
|
|
* nm_setting_vlan_error_quark:
|
|
*
|
|
* Registers an error quark for #NMSettingVlan if necessary.
|
|
*
|
|
* Returns: the error quark used for #NMSettingVlan errors.
|
|
**/
|
|
GQuark
|
|
nm_setting_vlan_error_quark (void)
|
|
{
|
|
static GQuark quark;
|
|
|
|
if (G_UNLIKELY (!quark))
|
|
quark = g_quark_from_static_string ("nm-setting-vlan-error-quark");
|
|
return quark;
|
|
}
|
|
|
|
G_DEFINE_TYPE_WITH_CODE (NMSettingVlan, nm_setting_vlan, NM_TYPE_SETTING,
|
|
_nm_register_setting (NM_SETTING_VLAN_SETTING_NAME,
|
|
g_define_type_id,
|
|
1,
|
|
NM_SETTING_VLAN_ERROR))
|
|
NM_SETTING_REGISTER_TYPE (NM_TYPE_SETTING_VLAN)
|
|
|
|
#define NM_SETTING_VLAN_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING_VLAN, NMSettingVlanPrivate))
|
|
|
|
typedef struct {
|
|
char *interface_name;
|
|
char *parent;
|
|
guint32 id;
|
|
guint32 flags;
|
|
GSList *ingress_priority_map;
|
|
GSList *egress_priority_map;
|
|
} NMSettingVlanPrivate;
|
|
|
|
enum {
|
|
PROP_0,
|
|
PROP_INTERFACE_NAME,
|
|
PROP_PARENT,
|
|
PROP_ID,
|
|
PROP_FLAGS,
|
|
PROP_INGRESS_PRIORITY_MAP,
|
|
PROP_EGRESS_PRIORITY_MAP,
|
|
LAST_PROP
|
|
};
|
|
|
|
#define MAX_SKB_PRIO G_MAXUINT32
|
|
#define MAX_8021P_PRIO 7 /* Max 802.1p priority */
|
|
|
|
typedef struct {
|
|
guint32 from;
|
|
guint32 to;
|
|
} PriorityMap;
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
/**
|
|
* nm_setting_vlan_get_interface_name:
|
|
* @setting: the #NMSettingVlan
|
|
*
|
|
* Returns: the #NMSettingVlan:interface_name property of the setting
|
|
**/
|
|
const char *
|
|
nm_setting_vlan_get_interface_name (NMSettingVlan *setting)
|
|
{
|
|
g_return_val_if_fail (NM_IS_SETTING_VLAN (setting), NULL);
|
|
return NM_SETTING_VLAN_GET_PRIVATE (setting)->interface_name;
|
|
}
|
|
|
|
/**
|
|
* 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 guint32
|
|
get_max_prio (NMVlanPriorityMap map, gboolean from)
|
|
{
|
|
if (map == NM_VLAN_INGRESS_MAP)
|
|
return from ? MAX_8021P_PRIO : MAX_SKB_PRIO;
|
|
else if (map == NM_VLAN_EGRESS_MAP)
|
|
return from ? MAX_SKB_PRIO : MAX_8021P_PRIO;
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
static PriorityMap *
|
|
priority_map_new_from_str (NMVlanPriorityMap map, const char *str)
|
|
{
|
|
PriorityMap *p = NULL;
|
|
gchar **t = NULL;
|
|
guint32 len;
|
|
guint64 from, to;
|
|
|
|
g_return_val_if_fail (str && str[0], NULL);
|
|
|
|
t = g_strsplit (str, ":", 0);
|
|
len = g_strv_length (t);
|
|
if (len == 2) {
|
|
from = g_ascii_strtoull (t[0], NULL, 10);
|
|
to = g_ascii_strtoull (t[1], NULL, 10);
|
|
|
|
if ((from <= get_max_prio (map, TRUE)) && (to <= get_max_prio (map, FALSE))) {
|
|
p = g_malloc0 (sizeof (PriorityMap));
|
|
p->from = from;
|
|
p->to = to;
|
|
}
|
|
} else {
|
|
/* Warn */
|
|
g_warn_if_fail (len == 2);
|
|
}
|
|
|
|
g_strfreev (t);
|
|
return p;
|
|
}
|
|
|
|
static void
|
|
priority_map_free (PriorityMap *map)
|
|
{
|
|
g_return_if_fail (map != NULL);
|
|
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;
|
|
g_assert_not_reached ();
|
|
return NULL;
|
|
}
|
|
|
|
static void
|
|
set_map (NMSettingVlan *self, NMVlanPriorityMap map, GSList *list)
|
|
{
|
|
if (map == NM_VLAN_INGRESS_MAP) {
|
|
NM_SETTING_VLAN_GET_PRIVATE (self)->ingress_priority_map = list;
|
|
g_object_notify (G_OBJECT (self), NM_SETTING_VLAN_INGRESS_PRIORITY_MAP);
|
|
} else if (map == NM_VLAN_EGRESS_MAP) {
|
|
NM_SETTING_VLAN_GET_PRIVATE (self)->egress_priority_map = list;
|
|
g_object_notify (G_OBJECT (self), NM_SETTING_VLAN_EGRESS_PRIORITY_MAP);
|
|
} else
|
|
g_assert_not_reached ();
|
|
}
|
|
|
|
/**
|
|
* 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 error
|
|
*/
|
|
gboolean
|
|
nm_setting_vlan_add_priority_str (NMSettingVlan *setting,
|
|
NMVlanPriorityMap map,
|
|
const char *str)
|
|
{
|
|
GSList *list = NULL, *iter = NULL;
|
|
PriorityMap *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);
|
|
|
|
list = get_map (setting, map);
|
|
|
|
item = priority_map_new_from_str (map, str);
|
|
if (!item)
|
|
g_return_val_if_reached (FALSE);
|
|
|
|
/* Duplicates get replaced */
|
|
for (iter = list; iter; iter = g_slist_next (iter)) {
|
|
PriorityMap *p = iter->data;
|
|
|
|
if (p->from == item->from) {
|
|
p->to = item->to;
|
|
g_free (item);
|
|
if (map == NM_VLAN_INGRESS_MAP)
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_VLAN_INGRESS_PRIORITY_MAP);
|
|
else
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_VLAN_EGRESS_PRIORITY_MAP);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
set_map (setting, map, g_slist_append (list, item));
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_vlan_get_num_priorities:
|
|
* @setting: the #NMSettingVlan
|
|
* @map: the type of priority map
|
|
*
|
|
* Returns the number of entires in the
|
|
* #NMSettingVlan:ingress_priority_map or #NMSettingVlan:egress_priority_map
|
|
* properties of this setting.
|
|
*
|
|
* Returns: return the number of ingress/egress priority entries, -1 if error
|
|
**/
|
|
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): on return the value of the priority map's 'from' item
|
|
* @out_to: (out): 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: %TRUE if a priority map was returned, %FALSE if error
|
|
**/
|
|
gboolean
|
|
nm_setting_vlan_get_priority (NMSettingVlan *setting,
|
|
NMVlanPriorityMap map,
|
|
guint32 idx,
|
|
guint32 *out_from,
|
|
guint32 *out_to)
|
|
{
|
|
GSList *list = NULL;
|
|
PriorityMap *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 (out_from != NULL, FALSE);
|
|
g_return_val_if_fail (out_to != NULL, FALSE);
|
|
|
|
list = get_map (setting, map);
|
|
g_return_val_if_fail (idx < g_slist_length (list), FALSE);
|
|
|
|
item = g_slist_nth_data (list, idx);
|
|
g_assert (item);
|
|
*out_from = item->from;
|
|
*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 if the new priority mapping was successfully added to the
|
|
* list, %FALSE if error
|
|
*/
|
|
gboolean
|
|
nm_setting_vlan_add_priority (NMSettingVlan *setting,
|
|
NMVlanPriorityMap map,
|
|
guint32 from,
|
|
guint32 to)
|
|
{
|
|
GSList *list = NULL, *iter = NULL;
|
|
PriorityMap *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);
|
|
for (iter = list; iter; iter = g_slist_next (iter)) {
|
|
item = iter->data;
|
|
if (item->from == from) {
|
|
item->to = to;
|
|
if (map == NM_VLAN_INGRESS_MAP)
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_VLAN_INGRESS_PRIORITY_MAP);
|
|
else
|
|
g_object_notify (G_OBJECT (setting), NM_SETTING_VLAN_EGRESS_PRIORITY_MAP);
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
item = g_malloc0 (sizeof (PriorityMap));
|
|
item->from = from;
|
|
item->to = to;
|
|
set_map (setting, map, g_slist_append (list, item));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* 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 ((PriorityMap *) (item->data));
|
|
set_map (setting, map, g_slist_delete_link (list, item));
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*
|
|
* Since: 0.9.10
|
|
*/
|
|
gboolean
|
|
nm_setting_vlan_remove_priority_by_value (NMSettingVlan *setting,
|
|
NMVlanPriorityMap map,
|
|
guint32 from,
|
|
guint32 to)
|
|
{
|
|
GSList *list = NULL, *iter = NULL;
|
|
PriorityMap *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);
|
|
for (iter = list; iter; iter = g_slist_next (iter)) {
|
|
item = iter->data;
|
|
if (item->from == from && item->to == to) {
|
|
priority_map_free ((PriorityMap *) (iter->data));
|
|
set_map (setting, map, g_slist_delete_link (list, iter));
|
|
return TRUE;
|
|
}
|
|
}
|
|
return 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.
|
|
*
|
|
* Since: 0.9.10
|
|
*/
|
|
gboolean
|
|
nm_setting_vlan_remove_priority_str_by_value (NMSettingVlan *setting,
|
|
NMVlanPriorityMap map,
|
|
const char *str)
|
|
{
|
|
PriorityMap *item;
|
|
gboolean found;
|
|
|
|
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);
|
|
|
|
item = priority_map_new_from_str (map, str);
|
|
if (!item)
|
|
return FALSE;
|
|
|
|
found = nm_setting_vlan_remove_priority_by_value (setting, map, item->from, item->to);
|
|
g_free (item);
|
|
return found;
|
|
}
|
|
|
|
/**
|
|
* nm_setting_vlan_clear_priorities:
|
|
* @setting: the #NMSettingVlan
|
|
* @map: the type of priority map
|
|
*
|
|
* Clear all the entires 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 void
|
|
nm_setting_vlan_init (NMSettingVlan *setting)
|
|
{
|
|
}
|
|
|
|
static gboolean
|
|
verify (NMSetting *setting, GSList *all_settings, GError **error)
|
|
{
|
|
NMSettingVlanPrivate *priv = NM_SETTING_VLAN_GET_PRIVATE (setting);
|
|
NMSettingConnection *s_con = NULL;
|
|
NMSettingWired *s_wired = NULL;
|
|
GSList *iter;
|
|
|
|
for (iter = all_settings; iter; iter = iter->next) {
|
|
if (NM_IS_SETTING_CONNECTION (iter->data))
|
|
s_con = iter->data;
|
|
else if (NM_IS_SETTING_WIRED (iter->data))
|
|
s_wired = iter->data;
|
|
}
|
|
|
|
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_SETTING_VLAN_ERROR,
|
|
NM_SETTING_VLAN_ERROR_INVALID_PARENT,
|
|
_("'%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_iface_valid_name (priv->parent)) {
|
|
/* parent must be either a UUID or an interface name */
|
|
g_set_error (error,
|
|
NM_SETTING_VLAN_ERROR,
|
|
NM_SETTING_VLAN_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 (!s_wired || !nm_setting_wired_get_mac_address (s_wired)) {
|
|
g_set_error (error,
|
|
NM_SETTING_VLAN_ERROR,
|
|
NM_SETTING_VLAN_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->flags & ~NM_VLAN_FLAGS_ALL) {
|
|
g_set_error_literal (error,
|
|
NM_SETTING_VLAN_ERROR,
|
|
NM_SETTING_VLAN_ERROR_INVALID_PROPERTY,
|
|
_("flags are invalid"));
|
|
g_prefix_error (error, "%s.%s: ", NM_SETTING_VLAN_SETTING_NAME, NM_SETTING_VLAN_FLAGS);
|
|
return FALSE;
|
|
}
|
|
|
|
if (priv->id >= 4095) {
|
|
g_set_error (error,
|
|
NM_SETTING_VLAN_ERROR,
|
|
NM_SETTING_VLAN_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 interface_name is specified, it must be a valid interface name. We
|
|
* don't check that it matches parent and/or id, because we allow
|
|
* renaming vlans to arbitrary names.
|
|
*/
|
|
return _nm_setting_verify_deprecated_virtual_iface_name (
|
|
priv->interface_name, TRUE,
|
|
NM_SETTING_VLAN_SETTING_NAME, NM_SETTING_VLAN_INTERFACE_NAME,
|
|
NM_SETTING_VLAN_ERROR,
|
|
NM_SETTING_VLAN_ERROR_INVALID_PROPERTY,
|
|
NM_SETTING_VLAN_ERROR_MISSING_PROPERTY,
|
|
all_settings, error);
|
|
}
|
|
|
|
static const char *
|
|
get_virtual_iface_name (NMSetting *setting)
|
|
{
|
|
return nm_setting_vlan_get_interface_name (NM_SETTING_VLAN (setting));
|
|
}
|
|
|
|
static GSList *
|
|
priority_stringlist_to_maplist (NMVlanPriorityMap map, GSList *strlist)
|
|
{
|
|
GSList *list = NULL, *iter;
|
|
|
|
for (iter = strlist; iter; iter = g_slist_next (iter)) {
|
|
PriorityMap *item;
|
|
|
|
item = priority_map_new_from_str (map, (const char *) iter->data);
|
|
if (item)
|
|
list = g_slist_prepend (list, item);
|
|
}
|
|
return g_slist_reverse (list);
|
|
}
|
|
|
|
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_INTERFACE_NAME:
|
|
g_free (priv->interface_name);
|
|
priv->interface_name = g_value_dup_string (value);
|
|
break;
|
|
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_uint (value);
|
|
break;
|
|
case PROP_INGRESS_PRIORITY_MAP:
|
|
g_slist_free_full (priv->ingress_priority_map, g_free);
|
|
priv->ingress_priority_map =
|
|
priority_stringlist_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_stringlist_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 GSList *
|
|
priority_maplist_to_stringlist (GSList *list)
|
|
{
|
|
GSList *strlist = NULL, *iter;
|
|
|
|
for (iter = list; iter; iter = g_slist_next (iter)) {
|
|
PriorityMap *item = iter->data;
|
|
|
|
strlist = g_slist_prepend (strlist, g_strdup_printf ("%d:%d", item->from, item->to));
|
|
}
|
|
return g_slist_reverse (strlist);
|
|
}
|
|
|
|
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_INTERFACE_NAME:
|
|
g_value_set_string (value, priv->interface_name);
|
|
break;
|
|
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_uint (value, priv->flags);
|
|
break;
|
|
case PROP_INGRESS_PRIORITY_MAP:
|
|
g_value_take_boxed (value, priority_maplist_to_stringlist (priv->ingress_priority_map));
|
|
break;
|
|
case PROP_EGRESS_PRIORITY_MAP:
|
|
g_value_take_boxed (value, priority_maplist_to_stringlist (priv->egress_priority_map));
|
|
break;
|
|
default:
|
|
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void
|
|
finalize (GObject *object)
|
|
{
|
|
NMSettingVlan *setting = NM_SETTING_VLAN (object);
|
|
NMSettingVlanPrivate *priv = NM_SETTING_VLAN_GET_PRIVATE (setting);
|
|
|
|
g_free (priv->interface_name);
|
|
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 *setting_class)
|
|
{
|
|
GObjectClass *object_class = G_OBJECT_CLASS (setting_class);
|
|
NMSettingClass *parent_class = NM_SETTING_CLASS (setting_class);
|
|
|
|
g_type_class_add_private (setting_class, sizeof (NMSettingVlanPrivate));
|
|
|
|
/* virtual methods */
|
|
object_class->set_property = set_property;
|
|
object_class->get_property = get_property;
|
|
object_class->finalize = finalize;
|
|
parent_class->verify = verify;
|
|
parent_class->get_virtual_iface_name = get_virtual_iface_name;
|
|
|
|
/* Properties */
|
|
|
|
/**
|
|
* NMSettingVlan:interface-name:
|
|
*
|
|
* If given, specifies the kernel name of the VLAN interface. If not given,
|
|
* a default name will be constructed from the interface described by the
|
|
* parent interface and the #NMSettingVlan:id property, eg "eth2.1". The
|
|
* parent interface may be given by the #NMSettingVlan:parent property or by
|
|
* the #NMSettingWired:mac-address property of an #NMSettingWired setting.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_INTERFACE_NAME,
|
|
g_param_spec_string (NM_SETTING_VLAN_INTERFACE_NAME, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
NM_SETTING_PARAM_INFERRABLE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* 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.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_PARENT,
|
|
g_param_spec_string (NM_SETTING_VLAN_PARENT, "", "",
|
|
NULL,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
NM_SETTING_PARAM_INFERRABLE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* NMSettingVlan:id:
|
|
*
|
|
* The VLAN identifier that the interface created by this connection should
|
|
* be assigned.
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_ID,
|
|
g_param_spec_uint (NM_SETTING_VLAN_ID, "", "",
|
|
0, 4095, 0,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
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).
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_FLAGS,
|
|
g_param_spec_uint (NM_SETTING_VLAN_FLAGS, "", "",
|
|
0, G_MAXUINT32, 0,
|
|
G_PARAM_READWRITE |
|
|
G_PARAM_CONSTRUCT |
|
|
NM_SETTING_PARAM_INFERRABLE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
|
|
/**
|
|
* 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".
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_INGRESS_PRIORITY_MAP,
|
|
_nm_param_spec_specialized (NM_SETTING_VLAN_INGRESS_PRIORITY_MAP, "", "",
|
|
DBUS_TYPE_G_LIST_OF_STRING,
|
|
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".
|
|
**/
|
|
g_object_class_install_property
|
|
(object_class, PROP_EGRESS_PRIORITY_MAP,
|
|
_nm_param_spec_specialized (NM_SETTING_VLAN_EGRESS_PRIORITY_MAP, "", "",
|
|
DBUS_TYPE_G_LIST_OF_STRING,
|
|
G_PARAM_READWRITE |
|
|
NM_SETTING_PARAM_INFERRABLE |
|
|
G_PARAM_STATIC_STRINGS));
|
|
}
|