fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-01-06 20:10:17 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/libnm/nm-device-ethernet.c
Fernando Fernandez Mancera cd0cf9229d
veth: add support to configure veth interfaces 
NetworkManager is now able to configure veth interfaces throught the
NMSettingVeth. Veth interfaces only have "peer" property.

In order to support Veth interfaces in NetworkManager the design need
to pass the following requirements:

 * Veth setting only has "peer" attribute.
 * Ethernet profiles must be applicable to Veth interfaces.
 * When creating a veth interface, the peer will be managed by
   NetworkManager but will not have a profile.
 * Veth connection can reapply only if the peer has not been modified.
 * In order to modify the veth peer, NetworkManager must deactivate the
   connection and create a new one with peer modified.

In general, it should support the basis of veth interfaces but without
breaking any existing feature or use case. The users that are using veth
interfaces as ethernet should not notice anything changed unless they
specified the veth peer setting.

Creating a Veth interface in NetworkManager is useful even without the
support for namespaces for some use cases, e.g "connecting one side of
the veth to an OVS bridge and the other side to a Linux bridge" this is
done when using OVN kubernetes [1][2]. In addition, it would provide
persistent configuration and rollback support for Veth interfaces.

[1] https://bugzilla.redhat.com/show_bug.cgi?id=1885605
[2] https://bugzilla.redhat.com/show_bug.cgi?id=1894139

Signed-off-by: Fernando Fernandez Mancera <ffmancera@riseup.net>
2020-11-27 10:12:36 +01:00

402 lines
14 KiB
C
Raw Blame History

/* SPDX-License-Identifier: LGPL-2.1+ */
/*
* Copyright (C) 2007 - 2008 Novell, Inc.
* Copyright (C) 2007 - 2012 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-device-ethernet.h"
#include "nm-libnm-utils.h"
#include "nm-setting-connection.h"
#include "nm-setting-wired.h"
#include "nm-setting-pppoe.h"
#include "nm-setting-veth.h"
#include "nm-utils.h"
#include "nm-object-private.h"
#include "nm-device-veth.h"
/*****************************************************************************/
NM_GOBJECT_PROPERTIES_DEFINE_BASE(PROP_PERM_HW_ADDRESS,
PROP_SPEED,
PROP_CARRIER,
PROP_S390_SUBCHANNELS, );
typedef struct _NMDeviceEthernetPrivate {
char ** s390_subchannels;
char * perm_hw_address;
guint32 speed;
bool carrier;
} NMDeviceEthernetPrivate;
G_DEFINE_TYPE(NMDeviceEthernet, nm_device_ethernet, NM_TYPE_DEVICE)
#define NM_DEVICE_ETHERNET_GET_PRIVATE(self) \
_NM_GET_PRIVATE_PTR(self, NMDeviceEthernet, NM_IS_DEVICE_ETHERNET, NMObject)
/*****************************************************************************/
/**
* nm_device_ethernet_get_hw_address: (skip)
* @device: a #NMDeviceEthernet
*
* Gets the active hardware (MAC) address of the #NMDeviceEthernet
*
* Returns: the active hardware address. This is the internal string used by the
* device, and must not be modified.
*
* Deprecated: 1.24: Use nm_device_get_hw_address() instead.
**/
const char *
nm_device_ethernet_get_hw_address(NMDeviceEthernet *device)
{
g_return_val_if_fail(NM_IS_DEVICE_ETHERNET(device), NULL);
return nm_device_get_hw_address(NM_DEVICE(device));
}
/**
* nm_device_ethernet_get_permanent_hw_address:
* @device: a #NMDeviceEthernet
*
* Gets the permanent hardware (MAC) address of the #NMDeviceEthernet
*
* Returns: the permanent hardware address. This is the internal string used by the
* device, and must not be modified.
**/
const char *
nm_device_ethernet_get_permanent_hw_address(NMDeviceEthernet *device)
{
g_return_val_if_fail(NM_IS_DEVICE_ETHERNET(device), NULL);
return _nml_coerce_property_str_not_empty(
NM_DEVICE_ETHERNET_GET_PRIVATE(device)->perm_hw_address);
}
/**
* nm_device_ethernet_get_speed:
* @device: a #NMDeviceEthernet
*
* Gets the speed of the #NMDeviceEthernet in Mbit/s.
*
* Returns: the speed of the device in Mbit/s
**/
guint32
nm_device_ethernet_get_speed(NMDeviceEthernet *device)
{
g_return_val_if_fail(NM_IS_DEVICE_ETHERNET(device), 0);
return NM_DEVICE_ETHERNET_GET_PRIVATE(device)->speed;
}
/**
* nm_device_ethernet_get_carrier:
* @device: a #NMDeviceEthernet
*
* Whether the device has carrier.
*
* Returns: %TRUE if the device has carrier
**/
gboolean
nm_device_ethernet_get_carrier(NMDeviceEthernet *device)
{
g_return_val_if_fail(NM_IS_DEVICE_ETHERNET(device), FALSE);
return NM_DEVICE_ETHERNET_GET_PRIVATE(device)->carrier;
}
/**
* nm_device_ethernet_get_s390_subchannels:
* @device: a #NMDeviceEthernet
*
* Return the list of s390 subchannels if the device supports them.
*
* Returns: (transfer none) (element-type utf8): array of strings, each specifying
* one subchannel the s390 device uses to communicate to the host.
*
* Since: 1.2
**/
const char *const *
nm_device_ethernet_get_s390_subchannels(NMDeviceEthernet *device)
{
g_return_val_if_fail(NM_IS_DEVICE_ETHERNET(device), NULL);
return (const char *const *) NM_DEVICE_ETHERNET_GET_PRIVATE(device)->s390_subchannels;
}
static gboolean
match_subchans(NMDeviceEthernet *self, NMSettingWired *s_wired, gboolean *try_mac)
{
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE(self);
const char *const * subchans;
gsize num1, num2;
gsize i, j;
*try_mac = TRUE;
subchans = nm_setting_wired_get_s390_subchannels(s_wired);
num1 = NM_PTRARRAY_LEN(subchans);
num2 = NM_PTRARRAY_LEN(priv->s390_subchannels);
/* connection has no subchannels */
if (num1 == 0)
return TRUE;
/* connection requires subchannels but the device has none */
if (num2 == 0)
return FALSE;
/* number of subchannels differ */
if (num1 != num2)
return FALSE;
/* Make sure each subchannel in the connection is a subchannel of this device */
for (i = 0; subchans[i]; i++) {
const char *candidate = subchans[i];
gboolean found = FALSE;
for (j = 0; priv->s390_subchannels[j]; j++) {
if (!g_strcmp0(priv->s390_subchannels[j], candidate))
found = TRUE;
}
if (!found)
return FALSE; /* a subchannel was not found */
}
*try_mac = FALSE;
return TRUE;
}
static gboolean
connection_compatible(NMDevice *device, NMConnection *connection, GError **error)
{
NMSettingWired *s_wired;
if (!NM_DEVICE_CLASS(nm_device_ethernet_parent_class)
->connection_compatible(device, connection, error))
return FALSE;
if (nm_connection_is_type(connection, NM_SETTING_PPPOE_SETTING_NAME)
|| nm_connection_is_type(connection, NM_SETTING_WIRED_SETTING_NAME)
|| (nm_connection_is_type(connection, NM_SETTING_VETH_SETTING_NAME)
&& NM_IS_DEVICE_VETH(device))) {
/* NOP */
} else {
g_set_error_literal(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("The connection was not an Ethernet or PPPoE connection."));
return FALSE;
}
s_wired = nm_connection_get_setting_wired(connection);
/* Wired setting optional for PPPoE */
if (s_wired) {
const char * perm_addr, *s_mac;
gboolean try_mac = TRUE;
const char *const *mac_blacklist;
int i;
/* Check s390 subchannels */
if (!match_subchans(NM_DEVICE_ETHERNET(device), s_wired, &try_mac)) {
g_set_error_literal(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("The connection and device differ in S390 subchannels."));
return FALSE;
}
/* Check MAC address */
perm_addr = nm_device_ethernet_get_permanent_hw_address(NM_DEVICE_ETHERNET(device));
s_mac = nm_setting_wired_get_mac_address(s_wired);
if (perm_addr) {
/* Virtual devices will have empty permanent addr but they should not be excluded
* from the MAC address check specified in the connection */
if (*perm_addr == 0)
perm_addr = nm_device_get_hw_address(NM_DEVICE(device));
if (!nm_utils_hwaddr_valid(perm_addr, ETH_ALEN)) {
g_set_error(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_FAILED,
_("Invalid device MAC address %s."),
perm_addr);
return FALSE;
}
if (try_mac && s_mac && !nm_utils_hwaddr_matches(s_mac, -1, perm_addr, -1)) {
g_set_error_literal(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("The MACs of the device and the connection do not match."));
return FALSE;
}
/* Check for MAC address blacklist */
mac_blacklist = nm_setting_wired_get_mac_address_blacklist(s_wired);
for (i = 0; mac_blacklist[i]; i++) {
if (!nm_utils_hwaddr_valid(mac_blacklist[i], ETH_ALEN)) {
g_warn_if_reached();
g_set_error(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("Invalid MAC in the blacklist: %s."),
mac_blacklist[i]);
return FALSE;
}
if (nm_utils_hwaddr_matches(mac_blacklist[i], -1, perm_addr, -1)) {
g_set_error(error,
NM_DEVICE_ERROR,
NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("Device MAC (%s) is blacklisted by the connection."),
perm_addr);
return FALSE;
}
}
}
}
return TRUE;
}
static GType
get_setting_type(NMDevice *device)
{
return NM_TYPE_SETTING_WIRED;
}
/*****************************************************************************/
static void
nm_device_ethernet_init(NMDeviceEthernet *device)
{
NMDeviceEthernetPrivate *priv;
priv = G_TYPE_INSTANCE_GET_PRIVATE(device, NM_TYPE_DEVICE_ETHERNET, NMDeviceEthernetPrivate);
device->_priv = priv;
}
static void
finalize(GObject *object)
{
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE(object);
g_free(priv->perm_hw_address);
g_strfreev(priv->s390_subchannels);
G_OBJECT_CLASS(nm_device_ethernet_parent_class)->finalize(object);
}
static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
NMDeviceEthernet * device = NM_DEVICE_ETHERNET(object);
NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE(device);
switch (prop_id) {
case PROP_PERM_HW_ADDRESS:
g_value_set_string(value, nm_device_ethernet_get_permanent_hw_address(device));
break;
case PROP_SPEED:
g_value_set_uint(value, nm_device_ethernet_get_speed(device));
break;
case PROP_CARRIER:
g_value_set_boolean(value, nm_device_ethernet_get_carrier(device));
break;
case PROP_S390_SUBCHANNELS:
g_value_set_boxed(value, priv->s390_subchannels);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
const NMLDBusMetaIface _nml_dbus_meta_iface_nm_device_wired = NML_DBUS_META_IFACE_INIT_PROP(
NM_DBUS_INTERFACE_DEVICE_WIRED,
nm_device_ethernet_get_type,
NML_DBUS_META_INTERFACE_PRIO_INSTANTIATE_30,
NML_DBUS_META_IFACE_DBUS_PROPERTIES(
NML_DBUS_META_PROPERTY_INIT_B("Carrier", PROP_CARRIER, NMDeviceEthernetPrivate, carrier),
NML_DBUS_META_PROPERTY_INIT_FCN("HwAddress",
0,
"s",
_nm_device_notify_update_prop_hw_address),
NML_DBUS_META_PROPERTY_INIT_S("PermHwAddress",
PROP_PERM_HW_ADDRESS,
NMDeviceEthernetPrivate,
perm_hw_address),
NML_DBUS_META_PROPERTY_INIT_AS("S390Subchannels",
PROP_S390_SUBCHANNELS,
NMDeviceEthernetPrivate,
s390_subchannels),
NML_DBUS_META_PROPERTY_INIT_U("Speed", PROP_SPEED, NMDeviceEthernetPrivate, speed), ),
.base_struct_offset = G_STRUCT_OFFSET(NMDeviceEthernet, _priv), );
static void
nm_device_ethernet_class_init(NMDeviceEthernetClass *klass)
{
GObjectClass * object_class = G_OBJECT_CLASS(klass);
NMDeviceClass *device_class = NM_DEVICE_CLASS(klass);
g_type_class_add_private(klass, sizeof(NMDeviceEthernetPrivate));
object_class->get_property = get_property;
object_class->finalize = finalize;
device_class->connection_compatible = connection_compatible;
device_class->get_setting_type = get_setting_type;
/**
* NMDeviceEthernet:perm-hw-address:
*
* The permanent hardware (MAC) address of the device.
**/
obj_properties[PROP_PERM_HW_ADDRESS] =
g_param_spec_string(NM_DEVICE_ETHERNET_PERMANENT_HW_ADDRESS,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMDeviceEthernet:speed:
*
* The speed of the device.
**/
obj_properties[PROP_SPEED] = g_param_spec_uint(NM_DEVICE_ETHERNET_SPEED,
"",
"",
0,
G_MAXUINT32,
0,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMDeviceEthernet:carrier:
*
* Whether the device has carrier.
**/
obj_properties[PROP_CARRIER] = g_param_spec_boolean(NM_DEVICE_ETHERNET_CARRIER,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMDeviceEthernet:s390-subchannels:
*
* Identifies subchannels of this network device used for
* communication with z/VM or s390 host.
*
* Since: 1.2
**/
obj_properties[PROP_S390_SUBCHANNELS] =
g_param_spec_boxed(NM_DEVICE_ETHERNET_S390_SUBCHANNELS,
"",
"",
G_TYPE_STRV,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
_nml_dbus_meta_class_init_with_properties(object_class, &_nml_dbus_meta_iface_nm_device_wired);
}
Reference in a new issue View git blame Copy permalink