/**
* nm_device_vlan_get_carrier:
* @device: a #NMDeviceVlan
*
* Whether the device has carrier.
*
* Returns: %TRUE if the device has carrier
**/
gboolean
nm_device_vlan_get_carrier (NMDeviceVlan *device)
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), FALSE);
return NM_DEVICE_VLAN_GET_PRIVATE (device)->carrier;
}
/**
* nm_device_vlan_get_hw_address:
* @device: a #NMDeviceVlan
*
* Gets the hardware (MAC) address of the #NMDeviceVlan
*
* Returns: the hardware address. This is the internal string used by the
* device, and must not be modified.
**/
const char *
nm_device_vlan_get_hw_address (NMDeviceVlan *device)
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), NULL);
return nm_str_not_empty (NM_DEVICE_VLAN_GET_PRIVATE (device)->hw_address);
}
/**
* nm_device_vlan_get_parent:
* @device: a #NMDeviceVlan
*
* Returns: (transfer none): the device's parent device
**/
NMDevice *
nm_device_vlan_get_parent (NMDeviceVlan *device)
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), FALSE);
return NM_DEVICE_VLAN_GET_PRIVATE (device)->parent;
}
static void
nm_device_vlan_set_parent (NMDeviceVlan *self, NMDevice *parent)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
NMDevice *device = NM_DEVICE (self);
if (parent == priv->parent)
return;
if (priv->parent_state_id) {
g_signal_handler_disconnect (priv->parent, priv->parent_state_id);
priv->parent_state_id = 0;
}
g_clear_object (&priv->parent);
if (parent) {
priv->parent = g_object_ref (parent);
priv->parent_state_id = g_signal_connect (priv->parent,
"state-changed",
G_CALLBACK (parent_state_changed),
device);
/* Set parent-dependent unmanaged flag */
nm_device_set_unmanaged (device,
NM_UNMANAGED_PARENT,
!nm_device_get_managed (parent),
NM_DEVICE_STATE_REASON_PARENT_MANAGED_CHANGED);
}
/* Recheck availability now that the parent has changed */
nm_device_queue_recheck_available (self,
NM_DEVICE_STATE_REASON_PARENT_CHANGED,
NM_DEVICE_STATE_REASON_PARENT_CHANGED);
g_object_notify (G_OBJECT (device), NM_DEVICE_VLAN_PARENT);
}
static gboolean
match_parent (NMDeviceVlan *self, const char *parent)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
g_return_val_if_fail (parent != NULL, FALSE);
if (nm_utils_is_uuid (parent)) {
NMActRequest *parent_req;
NMConnection *parent_connection;
/* If the parent is a UUID, the connection matches if our parent
* device has that connection activated.
*/
parent_req = nm_device_get_act_request (priv->parent);
if (!parent_req)
return FALSE;
parent_connection = nm_active_connection_get_connection (NM_ACTIVE_CONNECTION (parent_req));
if (!parent_connection)
return FALSE;
if (g_strcmp0 (parent, nm_connection_get_uuid (parent_connection)) != 0)
return FALSE;
} else {
/* interface name */
if (g_strcmp0 (parent, nm_device_get_ip_iface (priv->parent)) != 0)
return FALSE;
}
return TRUE;
}
static gboolean
component_added (NMDevice *device, GObject *component)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (device);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
NMDevice *added_device;
int parent_ifindex = -1;
if (priv->parent)
return FALSE;
if (!NM_IS_DEVICE (component))
return FALSE;
added_device = NM_DEVICE (component);
if (!nm_platform_vlan_get_info (NM_PLATFORM_GET, nm_device_get_ifindex (device), &parent_ifindex, NULL)) {
_LOGW (LOGD_VLAN, "failed to get VLAN interface info while checking added component.");
return FALSE;
}
if ( parent_ifindex <= 0
|| nm_device_get_ifindex (added_device) != parent_ifindex)
return FALSE;
nm_device_vlan_set_parent (self, added_device);
/* Don't claim parent exclusively */
return FALSE;
}
/**
* nm_device_vlan_get_vlan_id:
* @device: a #NMDeviceVlan
*
* Returns: the device's VLAN ID
**/
guint
nm_device_vlan_get_vlan_id (NMDeviceVlan *device)
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), FALSE);
return NM_DEVICE_VLAN_GET_PRIVATE (device)->vlan_id;
}
/**
* nm_device_vlan_get_hw_address:
* @device: a #NMDeviceVlan
*
* Gets the hardware (MAC) address of the #NMDeviceVlan
*
* Returns: the hardware address. This is the internal string used by the
* device, and must not be modified.
**/
const char *
nm_device_vlan_get_hw_address (NMDeviceVlan *device)
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), NULL);
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_VLAN_GET_PRIVATE (device)->hw_address;
}
static gboolean
is_available (NMDevice *device, NMDeviceCheckDevAvailableFlags flags)
{
if (!NM_DEVICE_VLAN_GET_PRIVATE (device)->parent)
return FALSE;
return NM_DEVICE_CLASS (nm_device_vlan_parent_class)->is_available (device, flags);
}
/**
* nm_device_vlan_get_carrier:
* @device: a #NMDeviceVlan
*
* Whether the device has carrier.
*
* Returns: %TRUE if the device has carrier
**/
gboolean
nm_device_vlan_get_carrier (NMDeviceVlan *device)
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), FALSE);
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_VLAN_GET_PRIVATE (device)->carrier;
}
/**
* nm_device_vlan_get_vlan_id:
* @device: a #NMDeviceVlan
*
* Returns: the device's VLAN ID
**/
guint
nm_device_vlan_get_vlan_id (NMDeviceVlan *device)
{
g_return_val_if_fail (NM_IS_DEVICE_VLAN (device), FALSE);
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_VLAN_GET_PRIVATE (device)->vlan_id;
}
static void
deactivate (NMDevice *device)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (device);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
/* Reset MAC address back to initial address */
nm_device_set_hw_addr (device, priv->initial_hw_addr, "reset", LOGD_VLAN);
}
static void
finalize (GObject *object)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (object);
g_free (priv->hw_address);
G_OBJECT_CLASS (nm_device_vlan_parent_class)->finalize (object);
}
static void
dispose (GObject *object)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (object);
g_clear_object (&priv->proxy);
G_OBJECT_CLASS (nm_device_vlan_parent_class)->dispose (object);
}
static void
update_initial_hw_address (NMDevice *dev)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (dev);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
priv->initial_hw_addr = g_strdup (nm_device_get_hw_address (dev));
_LOGD (LOGD_DEVICE | LOGD_VLAN, "read initial MAC address %s", priv->initial_hw_addr);
}
static gboolean
connection_compatible (NMDevice *device, NMConnection *connection, GError **error)
{
NMSettingConnection *s_con;
NMSettingVlan *s_vlan;
NMSettingWired *s_wired;
const char *ctype, *dev_iface_name, *vlan_iface_name;
const GByteArray *mac_address;
char *mac_address_str;
s_con = nm_connection_get_setting_connection (connection);
g_assert (s_con);
ctype = nm_setting_connection_get_connection_type (s_con);
if (strcmp (ctype, NM_SETTING_VLAN_SETTING_NAME) != 0) {
g_set_error (error, NM_DEVICE_VLAN_ERROR, NM_DEVICE_VLAN_ERROR_NOT_VLAN_CONNECTION,
"The connection was not a VLAN connection.");
return FALSE;
}
s_vlan = nm_connection_get_setting_vlan (connection);
if (!s_vlan) {
g_set_error (error, NM_DEVICE_VLAN_ERROR, NM_DEVICE_VLAN_ERROR_INVALID_VLAN_CONNECTION,
"The connection was not a valid VLAN connection.");
return FALSE;
}
if (nm_setting_vlan_get_id (s_vlan) != nm_device_vlan_get_vlan_id (NM_DEVICE_VLAN (device))) {
g_set_error (error, NM_DEVICE_VLAN_ERROR, NM_DEVICE_VLAN_ERROR_ID_MISMATCH,
"The VLAN identifiers of the device and the connection didn't match.");
return FALSE;
}
dev_iface_name = nm_device_get_iface (device);
vlan_iface_name = nm_setting_vlan_get_interface_name (s_vlan);
if (vlan_iface_name && g_strcmp0 (dev_iface_name, vlan_iface_name) != 0) {
g_set_error (error, NM_DEVICE_VLAN_ERROR, NM_DEVICE_VLAN_ERROR_INTERFACE_MISMATCH,
"The interfaces of the device and the connection didn't match.");
return FALSE;
}
s_wired = nm_connection_get_setting_wired (connection);
if (s_wired)
mac_address = nm_setting_wired_get_mac_address (s_wired);
else
mac_address = NULL;
if (mac_address) {
mac_address_str = nm_utils_hwaddr_ntoa_len (mac_address->data, mac_address->len);
if (!g_strcmp0 (mac_address_str, NM_DEVICE_VLAN_GET_PRIVATE (device)->hw_address)) {
g_set_error (error, NM_DEVICE_VLAN_ERROR, NM_DEVICE_VLAN_ERROR_MAC_MISMATCH,
"The hardware address of the device and the connection didn't match.");
}
g_free (mac_address_str);
}
return NM_DEVICE_CLASS (nm_device_vlan_parent_class)->connection_compatible (device, connection, error);
}
static void
constructed (GObject *object)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (object);
G_OBJECT_CLASS (nm_device_vlan_parent_class)->constructed (object);
priv->proxy = _nm_object_new_proxy (NM_OBJECT (object), NULL, NM_DBUS_INTERFACE_DEVICE_VLAN);
register_properties (NM_DEVICE_VLAN (object));
}
static void
setup (NMDevice *device, NMPlatformLink *plink)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (device);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
NM_DEVICE_CLASS (nm_device_vlan_parent_class)->setup (device, plink);
_LOGI (LOGD_HW | LOGD_VLAN, "VLAN ID %d with parent %s",
priv->vlan_id, nm_device_get_iface (priv->parent));
}
static gboolean
create_and_realize (NMDevice *device,
NMConnection *connection,
NMDevice *parent,
NMPlatformLink *out_plink,
GError **error)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (device);
const char *iface = nm_device_get_iface (device);
NMSettingVlan *s_vlan;
int parent_ifindex, vlan_id;
NMPlatformError plerr;
g_assert (out_plink);
s_vlan = nm_connection_get_setting_vlan (connection);
g_assert (s_vlan);
if (!nm_device_supports_vlans (parent)) {
g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
"no support for VLANs on interface %s of type %s",
nm_device_get_iface (parent),
nm_device_get_type_desc (parent));
return FALSE;
}
parent_ifindex = nm_device_get_ifindex (parent);
g_warn_if_fail (parent_ifindex > 0);
vlan_id = nm_setting_vlan_get_id (s_vlan);
plerr = nm_platform_vlan_add (NM_PLATFORM_GET,
iface,
parent_ifindex,
vlan_id,
nm_setting_vlan_get_flags (s_vlan),
out_plink);
if (plerr != NM_PLATFORM_ERROR_SUCCESS && plerr != NM_PLATFORM_ERROR_EXISTS) {
g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_CREATION_FAILED,
"Failed to create VLAN interface '%s' for '%s': %s",
iface,
nm_connection_get_id (connection),
nm_platform_error_to_string (plerr));
return FALSE;
}
g_warn_if_fail (priv->parent == NULL);
nm_device_vlan_set_parent (NM_DEVICE_VLAN (device), parent);
priv->vlan_id = vlan_id;
return TRUE;
}
static void
update_connection (NMDevice *device, NMConnection *connection)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (device);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (device);
NMSettingVlan *s_vlan = nm_connection_get_setting_vlan (connection);
int ifindex = nm_device_get_ifindex (device);
int parent_ifindex = -1, vlan_id = -1;
NMDevice *parent;
const char *setting_parent, *new_parent;
if (!s_vlan) {
s_vlan = (NMSettingVlan *) nm_setting_vlan_new ();
nm_connection_add_setting (connection, (NMSetting *) s_vlan);
}
if (!nm_platform_vlan_get_info (NM_PLATFORM_GET, ifindex, &parent_ifindex, &vlan_id)) {
_LOGW (LOGD_VLAN, "failed to get VLAN interface info while updating connection.");
return;
}
if (priv->vlan_id != vlan_id) {
priv->vlan_id = vlan_id;
g_object_notify (G_OBJECT (device), NM_DEVICE_VLAN_ID);
}
if (vlan_id != nm_setting_vlan_get_id (s_vlan))
g_object_set (s_vlan, NM_SETTING_VLAN_ID, priv->vlan_id, NULL);
if (parent_ifindex != NM_PLATFORM_LINK_OTHER_NETNS)
parent = nm_manager_get_device_by_ifindex (nm_manager_get (), parent_ifindex);
else
parent = NULL;
nm_device_vlan_set_parent (NM_DEVICE_VLAN (device), parent);
/* Update parent in the connection; default to parent's interface name */
if (parent) {
new_parent = nm_device_get_iface (parent);
setting_parent = nm_setting_vlan_get_parent (s_vlan);
if (setting_parent && nm_utils_is_uuid (setting_parent)) {
NMConnection *parent_connection;
/* Don't change a parent specified by UUID if it's still valid */
parent_connection = nm_connection_provider_get_connection_by_uuid (nm_connection_provider_get (), setting_parent);
if (parent_connection && nm_device_check_connection_compatible (parent, parent_connection))
new_parent = NULL;
}
if (new_parent)
g_object_set (s_vlan, NM_SETTING_VLAN_PARENT, new_parent, NULL);
} else
g_object_set (s_vlan, NM_SETTING_VLAN_PARENT, NULL, NULL);
}
static void
get_property (GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (object);
switch (prop_id) {
case PROP_VLAN_ID:
g_value_set_uint (value, priv->vlan_id);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
dispose (GObject *object)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (object);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
if (priv->disposed) {
G_OBJECT_CLASS (nm_device_vlan_parent_class)->dispose (object);
return;
}
priv->disposed = TRUE;
nm_device_vlan_set_parent (self, NULL);
G_OBJECT_CLASS (nm_device_vlan_parent_class)->dispose (object);
}
static void
register_properties (NMDeviceVlan *device)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (device);
const NMPropertiesInfo property_info[] = {
{ NM_DEVICE_VLAN_HW_ADDRESS, &priv->hw_address },
{ NM_DEVICE_VLAN_CARRIER, &priv->carrier },
{ NM_DEVICE_VLAN_PARENT, &priv->parent, NULL, NM_TYPE_DEVICE },
{ NM_DEVICE_VLAN_VLAN_ID, &priv->vlan_id },
{ NULL },
};
_nm_object_register_properties (NM_OBJECT (device),
priv->proxy,
property_info);
}
NMDevice *
nm_device_vlan_new_for_connection (NMConnection *connection, NMDevice *parent)
{
NMDevice *device;
NMSettingVlan *s_vlan;
char *iface;
g_return_val_if_fail (connection != NULL, NULL);
g_return_val_if_fail (NM_IS_DEVICE (parent), NULL);
s_vlan = nm_connection_get_setting_vlan (connection);
g_return_val_if_fail (s_vlan != NULL, NULL);
iface = g_strdup (nm_connection_get_interface_name (connection));
if (!iface) {
iface = nm_utils_new_vlan_name (nm_device_get_ip_iface (parent),
nm_setting_vlan_get_id (s_vlan));
}
if ( !nm_platform_vlan_add (iface,
nm_device_get_ifindex (parent),
nm_setting_vlan_get_id (s_vlan),
nm_setting_vlan_get_flags (s_vlan))
&& nm_platform_get_error () != NM_PLATFORM_ERROR_EXISTS) {
nm_log_warn (LOGD_DEVICE | LOGD_VLAN, "(%s) failed to add VLAN interface for '%s'",
iface, nm_connection_get_id (connection));
g_free (iface);
return NULL;
}
device = (NMDevice *) g_object_new (NM_TYPE_DEVICE_VLAN,
NM_DEVICE_IFACE, iface,
NM_DEVICE_VLAN_PARENT, parent,
NM_DEVICE_DRIVER, "8021q",
NM_DEVICE_TYPE_DESC, "VLAN",
NM_DEVICE_DEVICE_TYPE, NM_DEVICE_TYPE_VLAN,
NULL);
g_free (iface);
if (NM_DEVICE_VLAN_GET_PRIVATE (device)->invalid) {
g_object_unref (device);
device = NULL;
}
return device;
}
static void
init_dbus (NMObject *object)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (object);
const NMPropertiesInfo property_info[] = {
{ NM_DEVICE_VLAN_HW_ADDRESS, &priv->hw_address },
{ NM_DEVICE_VLAN_CARRIER, &priv->carrier },
{ NM_DEVICE_VLAN_PARENT, &priv->parent, NULL, NM_TYPE_DEVICE },
{ NM_DEVICE_VLAN_VLAN_ID, &priv->vlan_id },
{ NULL },
};
NM_OBJECT_CLASS (nm_device_vlan_parent_class)->init_dbus (object);
_nm_object_register_properties (object,
NM_DBUS_INTERFACE_DEVICE_VLAN,
property_info);
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (object);
switch (prop_id) {
case PROP_PARENT:
nm_device_vlan_set_parent (NM_DEVICE_VLAN (object), g_value_get_object (value));
break;
case PROP_VLAN_ID:
priv->vlan_id = g_value_get_uint (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
constructed (GObject *object)
{
NMDeviceVlan *self = NM_DEVICE_VLAN (object);
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (self);
int ifindex = nm_device_get_ifindex (NM_DEVICE (self));
int parent_ifindex = -1, itype;
int vlan_id;
if (G_OBJECT_CLASS (nm_device_vlan_parent_class)->constructed)
G_OBJECT_CLASS (nm_device_vlan_parent_class)->constructed (object);
if (!priv->parent) {
_LOGE (LOGD_VLAN, "no parent specified.");
priv->invalid = TRUE;
return;
}
itype = nm_platform_link_get_type (ifindex);
if (itype != NM_LINK_TYPE_VLAN) {
_LOGE (LOGD_VLAN, "failed to get VLAN interface type.");
priv->invalid = TRUE;
return;
}
if (!nm_platform_vlan_get_info (ifindex, &parent_ifindex, &vlan_id)) {
_LOGW (LOGD_VLAN, "failed to get VLAN interface info.");
priv->invalid = TRUE;
return;
}
if ( parent_ifindex < 0
|| parent_ifindex != nm_device_get_ip_ifindex (priv->parent)
|| vlan_id < 0) {
_LOGW (LOGD_VLAN, "VLAN parent ifindex (%d) or VLAN ID (%d) invalid.",
parent_ifindex, priv->vlan_id);
priv->invalid = TRUE;
return;
}
priv->vlan_id = vlan_id;
_LOGI (LOGD_HW | LOGD_VLAN, "VLAN ID %d with parent %s",
priv->vlan_id, nm_device_get_iface (priv->parent));
}
static gboolean
realize (NMDevice *device,
NMPlatformLink *plink,
GError **error)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (device);
int parent_ifindex = -1, vlan_id = -1;
NMDevice *parent;
g_return_val_if_fail (plink, FALSE);
g_assert (plink->type == NM_LINK_TYPE_VLAN);
if (!nm_platform_vlan_get_info (NM_PLATFORM_GET, plink->ifindex, &parent_ifindex, &vlan_id)) {
g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
"(%s): failed to read VLAN properties", plink->name);
return FALSE;
}
if (vlan_id < 0) {
g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
"(%s): VLAN ID invalid", plink->name);
return FALSE;
}
if (parent_ifindex != NM_PLATFORM_LINK_OTHER_NETNS) {
parent = nm_manager_get_device_by_ifindex (nm_manager_get (), parent_ifindex);
if (!parent) {
nm_log_dbg (LOGD_HW, "(%s): VLAN parent interface unknown", plink->name);
g_set_error (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
"(%s): VLAN parent interface unknown", plink->name);
return FALSE;
}
} else
parent = NULL;
g_warn_if_fail (priv->parent == NULL);
nm_device_vlan_set_parent (NM_DEVICE_VLAN (device), parent);
priv->vlan_id = vlan_id;
return TRUE;
}
static void
nm_device_vlan_set_parent (NMDeviceVlan *device, NMDevice *parent)
{
NMDeviceVlanPrivate *priv = NM_DEVICE_VLAN_GET_PRIVATE (device);
if (priv->parent_state_id) {
g_signal_handler_disconnect (priv->parent, priv->parent_state_id);
priv->parent_state_id = 0;
}
g_clear_object (&priv->parent);
if (parent) {
priv->parent = g_object_ref (parent);
priv->parent_state_id = g_signal_connect (priv->parent,
"state-changed",
G_CALLBACK (parent_state_changed),
device);
}
g_object_notify (G_OBJECT (device), NM_DEVICE_VLAN_PARENT);
}
static gboolean
connection_compatible (NMDevice *device, NMConnection *connection, GError **error)
{
NMDeviceVlanPrivate *priv;
NMSettingVlan *s_vlan;
NMSettingWired *s_wired;
const char *setting_hwaddr;
if (!NM_DEVICE_CLASS (nm_device_vlan_parent_class)->connection_compatible (device, connection, error))
return FALSE;
if (!nm_connection_is_type (connection, NM_SETTING_VLAN_SETTING_NAME)) {
g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("The connection was not a VLAN connection."));
return FALSE;
}
s_vlan = nm_connection_get_setting_vlan (connection);
if (nm_setting_vlan_get_id (s_vlan) != nm_device_vlan_get_vlan_id (NM_DEVICE_VLAN (device))) {
g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("The VLAN identifiers of the device and the connection didn't match."));
return FALSE;
}
s_wired = nm_connection_get_setting_wired (connection);
if (s_wired)
setting_hwaddr = nm_setting_wired_get_mac_address (s_wired);
else
setting_hwaddr = NULL;
if (setting_hwaddr) {
priv = NM_DEVICE_VLAN_GET_PRIVATE (device);
if ( !priv->hw_address
|| !nm_utils_hwaddr_matches (setting_hwaddr, -1,
priv->hw_address, -1)) {
g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_INCOMPATIBLE_CONNECTION,
_("The hardware address of the device and the connection didn't match."));
}
}
return TRUE;
}