fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2025-12-20 08:10:06 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/libnm/nm-device-ethernet.c
Thomas Haller 0fca809bfd
all: explicit include <linux/if_{ether,infiniband,vlan}.h> as needed 
Currently libnm headers include <linux/if_{ether,infiniband,vlan}.h>.
These are public headers, that means we drag in the linux header to all
users of <NetworkManager.h>.

Often the linux headers work badly together with certain headers from libc.
Depending on the libc version, you have to order linux headers in the right
order with respect to libc headers.

We should do better about libnm headers. As a first step, assume that
the linux headers don't get included by libnm, and explicitly include
them where they are needed.
2020-12-22 16:33:33 +01:00

404 lines
14 KiB
C
Raw Permalink 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 <linux/if_ether.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_20,
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