// SPDX-License-Identifier: LGPL-2.1+

/*

 * Copyright (C) 2007 - 2014 Red Hat, Inc.

 * Copyright (C) 2007 - 2008 Novell, Inc.

 */

#include "nm-default.h"

#include "nm-setting-wired.h"

#include <net/ethernet.h>

#include "nm-utils.h"

#include "nm-libnm-core-intern/nm-common-macros.h"

#include "nm-utils-private.h"

#include "nm-setting-private.h"

/**

 * SECTION:nm-setting-wired

 * @short_description: Describes connection properties for Ethernet-based networks

 *

 * The #NMSettingWired object is a #NMSetting subclass that describes properties

 * necessary for connection to Ethernet networks.

 **/

/*****************************************************************************/

G_STATIC_ASSERT (NM_SETTING_WIRED_WAKE_ON_LAN_EXCLUSIVE_FLAGS == (  NM_SETTING_WIRED_WAKE_ON_LAN_DEFAULT

                                                                  | NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE));

/*****************************************************************************/

NM_GOBJECT_PROPERTIES_DEFINE (NMSettingWired,

	PROP_PORT,

	PROP_SPEED,

	PROP_DUPLEX,

	PROP_AUTO_NEGOTIATE,

	PROP_MAC_ADDRESS,

	PROP_CLONED_MAC_ADDRESS,

	PROP_GENERATE_MAC_ADDRESS_MASK,

	PROP_MAC_ADDRESS_BLACKLIST,

	PROP_MTU,

	PROP_S390_SUBCHANNELS,

	PROP_S390_NETTYPE,

	PROP_S390_OPTIONS,

	PROP_WAKE_ON_LAN,

	PROP_WAKE_ON_LAN_PASSWORD,

);

typedef struct {

	struct {

		NMUtilsNamedValue *arr;

		guint len;

		guint n_alloc;

	} s390_options;

	GArray *mac_address_blacklist;

	char **s390_subchannels;

	char *port;

	char *duplex;

	char *device_mac_address;

	char *cloned_mac_address;

	char *generate_mac_address_mask;

	char *s390_nettype;

	char *wol_password;

	NMSettingWiredWakeOnLan wol;

	guint32 speed;

	guint32 mtu;

	bool auto_negotiate:1;

} NMSettingWiredPrivate;

G_DEFINE_TYPE (NMSettingWired, nm_setting_wired, NM_TYPE_SETTING)

#define NM_SETTING_WIRED_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_SETTING_WIRED, NMSettingWiredPrivate))

/*****************************************************************************/

static const char *valid_s390_opts[] = {

	"broadcast_mode",

	"buffer_count",

	"canonical_macaddr",

	"checksumming",

	"ctcprot",

	"fake_broadcast",

	"inter",

	"inter_jumbo",

	"ipato_add4",

	"ipato_add6",

	"ipato_enable",

	"ipato_invert4",

	"ipato_invert6",

	"isolation",

	"lancmd_timeout",

	"large_send",

	"layer2",

	"portname",

	"portno",

	"priority_queueing",

	"protocol",

	"route4",

	"route6",

	"rxip_add4",

	"rxip_add6",

	"sniffer",

	"total",

	"vipa_add4",

	"vipa_add6",

	NULL,

};

static gboolean

valid_s390_opts_check (const char *option)

{

#if NM_MORE_ASSERTS > 5

	nm_assert (NM_PTRARRAY_LEN (valid_s390_opts) + 1 == G_N_ELEMENTS (valid_s390_opts));

	{

		gsize i;

		for (i = 0; i < G_N_ELEMENTS (valid_s390_opts); i++) {

			if (i == G_N_ELEMENTS (valid_s390_opts) - 1)

				nm_assert (!valid_s390_opts[i]);

			else {

				nm_assert (valid_s390_opts[i]);

				nm_assert (valid_s390_opts[i][0] != '\0');

				if (i > 0)

					g_assert (strcmp (valid_s390_opts[i - 1], valid_s390_opts[i]) < 0);

			}

		}

	}

#endif

	return    option

	       && (nm_utils_array_find_binary_search (valid_s390_opts,

	                                              sizeof (const char *),

	                                              G_N_ELEMENTS (valid_s390_opts) - 1,

	                                              &option,

	                                              nm_strcmp_p_with_data,

	                                              NULL) >= 0);

}

/**

 * nm_setting_wired_get_port:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:port property of the setting

 **/

const char *

nm_setting_wired_get_port (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->port;

}

/**

 * nm_setting_wired_get_speed:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:speed property of the setting

 **/

guint32

nm_setting_wired_get_speed (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), 0);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->speed;

}

/**

 * nm_setting_wired_get_duplex:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:duplex property of the setting

 **/

const char *

nm_setting_wired_get_duplex (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->duplex;

}

/**

 * nm_setting_wired_get_auto_negotiate:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:auto-negotiate property of the setting

 **/

gboolean

nm_setting_wired_get_auto_negotiate (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), FALSE);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->auto_negotiate;

}

/**

 * nm_setting_wired_get_mac_address:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:mac-address property of the setting

 **/

const char *

nm_setting_wired_get_mac_address (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->device_mac_address;

}

/**

 * nm_setting_wired_get_cloned_mac_address:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:cloned-mac-address property of the setting

 **/

const char *

nm_setting_wired_get_cloned_mac_address (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->cloned_mac_address;

}

/**

 * nm_setting_wired_get_generate_mac_address_mask:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:generate-mac-address-mask property of the setting

 *

 * Since: 1.4

 **/

const char *

nm_setting_wired_get_generate_mac_address_mask (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->generate_mac_address_mask;

}

/**

 * nm_setting_wired_get_mac_address_blacklist:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:mac-address-blacklist property of the setting

 **/

const char * const *

nm_setting_wired_get_mac_address_blacklist (NMSettingWired *setting)

{

	NMSettingWiredPrivate *priv;

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	return (const char * const *) priv->mac_address_blacklist->data;

}

/**

 * nm_setting_wired_get_num_mac_blacklist_items:

 * @setting: the #NMSettingWired

 *

 * Returns: the number of blacklisted MAC addresses

 **/

guint32

nm_setting_wired_get_num_mac_blacklist_items (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), 0);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->mac_address_blacklist->len;

}

/**

 * nm_setting_wired_get_mac_blacklist_item:

 * @setting: the #NMSettingWired

 * @idx: the zero-based index of the MAC address entry

 *

 * Returns: the blacklisted MAC address string (hex-digits-and-colons notation)

 * at index @idx

 **/

const char *

nm_setting_wired_get_mac_blacklist_item (NMSettingWired *setting, guint32 idx)

{

	NMSettingWiredPrivate *priv;

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	g_return_val_if_fail (idx <= priv->mac_address_blacklist->len, NULL);

	return g_array_index (priv->mac_address_blacklist, const char *, idx);

}

/**

 * nm_setting_wired_add_mac_blacklist_item:

 * @setting: the #NMSettingWired

 * @mac: the MAC address string (hex-digits-and-colons notation) to blacklist

 *

 * Adds a new MAC address to the #NMSettingWired:mac-address-blacklist property.

 *

 * Returns: %TRUE if the MAC address was added; %FALSE if the MAC address

 * is invalid or was already present

 **/

gboolean

nm_setting_wired_add_mac_blacklist_item (NMSettingWired *setting, const char *mac)

{

	NMSettingWiredPrivate *priv;

	const char *candidate;

	int i;

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), FALSE);

	g_return_val_if_fail (mac != NULL, FALSE);

	if (!nm_utils_hwaddr_valid (mac, ETH_ALEN))

		return FALSE;

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	for (i = 0; i < priv->mac_address_blacklist->len; i++) {

		candidate = g_array_index (priv->mac_address_blacklist, char *, i);

		if (nm_utils_hwaddr_matches (mac, -1, candidate, -1))

			return FALSE;

	}

	mac = nm_utils_hwaddr_canonical (mac, ETH_ALEN);

	g_array_append_val (priv->mac_address_blacklist, mac);

	_notify (setting, PROP_MAC_ADDRESS_BLACKLIST);

	return TRUE;

}

/**

 * nm_setting_wired_remove_mac_blacklist_item:

 * @setting: the #NMSettingWired

 * @idx: index number of the MAC address

 *

 * Removes the MAC address at index @idx from the blacklist.

 **/

void

nm_setting_wired_remove_mac_blacklist_item (NMSettingWired *setting, guint32 idx)

{

	NMSettingWiredPrivate *priv;

	g_return_if_fail (NM_IS_SETTING_WIRED (setting));

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	g_return_if_fail (idx < priv->mac_address_blacklist->len);

	g_array_remove_index (priv->mac_address_blacklist, idx);

	_notify (setting, PROP_MAC_ADDRESS_BLACKLIST);

}

/**

 * nm_setting_wired_remove_mac_blacklist_item_by_value:

 * @setting: the #NMSettingWired

 * @mac: the MAC address string (hex-digits-and-colons notation) to remove from

 * the blacklist

 *

 * Removes the MAC address @mac from the blacklist.

 *

 * Returns: %TRUE if the MAC address was found and removed; %FALSE if it was not.

 **/

gboolean

nm_setting_wired_remove_mac_blacklist_item_by_value (NMSettingWired *setting, const char *mac)

{

	NMSettingWiredPrivate *priv;

	const char *candidate;

	int i;

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), FALSE);

	g_return_val_if_fail (mac != NULL, FALSE);

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	for (i = 0; i < priv->mac_address_blacklist->len; i++) {

		candidate = g_array_index (priv->mac_address_blacklist, char *, i);

		if (!nm_utils_hwaddr_matches (mac, -1, candidate, -1)) {

			g_array_remove_index (priv->mac_address_blacklist, i);

			_notify (setting, PROP_MAC_ADDRESS_BLACKLIST);

			return TRUE;

		}

	}

	return FALSE;

}

/**

 * nm_setting_wired_clear_mac_blacklist_items:

 * @setting: the #NMSettingWired

 *

 * Removes all blacklisted MAC addresses.

 **/

void

nm_setting_wired_clear_mac_blacklist_items (NMSettingWired *setting)

{

	g_return_if_fail (NM_IS_SETTING_WIRED (setting));

	g_array_set_size (NM_SETTING_WIRED_GET_PRIVATE (setting)->mac_address_blacklist, 0);

	_notify (setting, PROP_MAC_ADDRESS_BLACKLIST);

}

/**

 * nm_setting_wired_get_mtu:

 * @setting: the #NMSettingWired

 *

 * Returns: the #NMSettingWired:mtu property of the setting

 **/

guint32

nm_setting_wired_get_mtu (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), 0);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->mtu;

}

/**

 * nm_setting_wired_get_s390_subchannels:

 * @setting: the #NMSettingWired

 *

 * Return the list of s390 subchannels that identify the device that this

 * connection is applicable to.  The connection should only be used in

 * conjunction with that device.

 *

 * Returns: (transfer none) (element-type utf8): array of strings, each specifying

 *   one subchannel the s390 device uses to communicate to the host.

 **/

const char * const *

nm_setting_wired_get_s390_subchannels (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	return (const char * const *) NM_SETTING_WIRED_GET_PRIVATE (setting)->s390_subchannels;

}

/**

 * nm_setting_wired_get_s390_nettype:

 * @setting: the #NMSettingWired

 *

 * Returns the s390 device type this connection should apply to.  Will be one

 * of 'qeth', 'lcs', or 'ctc'.

 *

 * Returns: the s390 device type

 **/

const char *

nm_setting_wired_get_s390_nettype (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->s390_nettype;

}

/**

 * nm_setting_wired_get_num_s390_options:

 * @setting: the #NMSettingWired

 *

 * Returns the number of s390-specific options that should be set for this

 * device when it is activated.  This can be used to retrieve each s390

 * option individually using nm_setting_wired_get_s390_option().

 *

 * Returns: the number of s390-specific device options

 **/

guint32

nm_setting_wired_get_num_s390_options (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), 0);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->s390_options.len;

}

/**

 * nm_setting_wired_get_s390_option:

 * @setting: the #NMSettingWired

 * @idx: index of the desired option, from 0 to

 * nm_setting_wired_get_num_s390_options() - 1

 * @out_key: (out) (transfer none): on return, the key name of the s390 specific

 *   option; this value is owned by the setting and should not be modified

 * @out_value: (out) (transfer none): on return, the value of the key of the

 *   s390 specific option; this value is owned by the setting and should not be

 *   modified

 *

 * Given an index, return the value of the s390 option at that index.  indexes

 * are *not* guaranteed to be static across modifications to options done by

 * nm_setting_wired_add_s390_option() and nm_setting_wired_remove_s390_option(),

 * and should not be used to refer to options except for short periods of time

 * such as during option iteration.

 *

 * Returns: %TRUE on success if the index was valid and an option was found,

 * %FALSE if the index was invalid (ie, greater than the number of options

 * currently held by the setting)

 **/

gboolean

nm_setting_wired_get_s390_option (NMSettingWired *setting,

                                  guint32 idx,

                                  const char **out_key,

                                  const char **out_value)

{

	NMSettingWiredPrivate *priv;

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), FALSE);

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	g_return_val_if_fail (idx < priv->s390_options.len, FALSE);

	NM_SET_OUT (out_key,   priv->s390_options.arr[idx].name);

	NM_SET_OUT (out_value, priv->s390_options.arr[idx].value_str);

	return TRUE;

}

/**

 * nm_setting_wired_get_s390_option_by_key:

 * @setting: the #NMSettingWired

 * @key: the key for which to retrieve the value

 *

 * Returns the value associated with the s390-specific option specified by

 * @key, if it exists.

 *

 * Returns: the value, or %NULL if the key/value pair was never added to the

 * setting; the value is owned by the setting and must not be modified

 **/

const char *

nm_setting_wired_get_s390_option_by_key (NMSettingWired *setting,

                                         const char *key)

{

	NMSettingWiredPrivate *priv;

	gssize idx;

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	g_return_val_if_fail (key && key[0], NULL);

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	idx = nm_utils_named_value_list_find (priv->s390_options.arr,

	                                      priv->s390_options.len,

	                                      key,

	                                      TRUE);

	if (idx < 0)

		return NULL;

	return priv->s390_options.arr[idx].value_str;

}

/**

 * nm_setting_wired_add_s390_option:

 * @setting: the #NMSettingWired

 * @key: key name for the option

 * @value: value for the option

 *

 * Add an option to the table.  The option is compared to an internal list

 * of allowed options.  Key names may contain only alphanumeric characters

 * (ie [a-zA-Z0-9]).  Adding a new key replaces any existing key/value pair that

 * may already exist.

 *

 * Returns: %TRUE if the option was valid and was added to the internal option

 * list, %FALSE if it was not.

 **/

gboolean

nm_setting_wired_add_s390_option (NMSettingWired *setting,

                                  const char *key,

                                  const char *value)

{

	NMSettingWiredPrivate *priv;

	gssize idx;

	NMUtilsNamedValue *v;

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), FALSE);

	g_return_val_if_fail (value, FALSE);

	if (!valid_s390_opts_check (key)) {

		g_return_val_if_fail (key, FALSE);

		return FALSE;

	}

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	idx = nm_utils_named_value_list_find (priv->s390_options.arr,

	                                      priv->s390_options.len,

	                                      key,

	                                      TRUE);

	if (idx < 0) {

		gsize dst_idx = ~idx;

		if (priv->s390_options.n_alloc < priv->s390_options.len + 1) {

			priv->s390_options.n_alloc = NM_MAX (4,

			                                     (priv->s390_options.len + 1) * 2);

			priv->s390_options.arr = g_realloc (priv->s390_options.arr,

			                                    priv->s390_options.n_alloc * sizeof (NMUtilsNamedValue));

		}

		if (dst_idx < priv->s390_options.len) {

			memmove (&priv->s390_options.arr[dst_idx + 1],

			         &priv->s390_options.arr[dst_idx],

			         (priv->s390_options.len - dst_idx) * sizeof (NMUtilsNamedValue));

		}

		priv->s390_options.arr[dst_idx] = (NMUtilsNamedValue) {

			.name      = g_strdup (key),

			.value_str = g_strdup (value),

		};

		priv->s390_options.len++;

	} else {

		v = &priv->s390_options.arr[idx];

		if (nm_streq (value, v->value_str))

			return TRUE;

		g_free ((char *) v->value_str);

		v->value_str = g_strdup (value);

	}

	_notify (setting, PROP_S390_OPTIONS);

	return TRUE;

}

/**

 * nm_setting_wired_remove_s390_option:

 * @setting: the #NMSettingWired

 * @key: key name for the option to remove

 *

 * Remove the s390-specific option referenced by @key from the internal option

 * list.

 *

 * Returns: %TRUE if the option was found and removed from the internal option

 * list, %FALSE if it was not.

 **/

gboolean

nm_setting_wired_remove_s390_option (NMSettingWired *setting,

                                     const char *key)

{

	NMSettingWiredPrivate *priv;

	gsize dst_idx;

	gssize idx;

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), FALSE);

	g_return_val_if_fail (key, FALSE);

	priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	idx = nm_utils_named_value_list_find (priv->s390_options.arr,

	                                      priv->s390_options.len,

	                                      key,

	                                      TRUE);

	if (idx < 0)

		return FALSE;

	dst_idx = idx;

	g_free ((char *) priv->s390_options.arr[dst_idx].name);

	g_free ((char *) priv->s390_options.arr[dst_idx].value_str);

	if (dst_idx + 1 != priv->s390_options.len) {

		memmove (&priv->s390_options.arr[dst_idx],

		         &priv->s390_options.arr[dst_idx + 1],

		         (priv->s390_options.len - dst_idx - 1) * sizeof (NMUtilsNamedValue));

	}

	priv->s390_options.len--;

	_notify (setting, PROP_S390_OPTIONS);

	return TRUE;

}

static void

_s390_options_clear (NMSettingWiredPrivate *priv)

{

	guint i;

	for (i = 0; i < priv->s390_options.len; i++) {

		g_free ((char *) priv->s390_options.arr[i].name);

		g_free ((char *) priv->s390_options.arr[i].value_str);

	}

	nm_clear_g_free (&priv->s390_options.arr);

	priv->s390_options.len = 0;

	priv->s390_options.n_alloc = 0;

}

void

_nm_setting_wired_clear_s390_options (NMSettingWired *setting)

{

	g_return_if_fail (NM_IS_SETTING_WIRED (setting));

	_s390_options_clear (NM_SETTING_WIRED_GET_PRIVATE (setting));

}

/**

 * nm_setting_wired_get_valid_s390_options:

 * @setting: (allow-none): the #NMSettingWired. This argument is unused

 *   and you may pass %NULL.

 *

 * Returns a list of valid s390 options.

 *

 * The @setting argument is unused and %NULL may be passed instead.

 *

 * Returns: (transfer none): a %NULL-terminated array of strings of valid s390 options.

 **/

const char **

nm_setting_wired_get_valid_s390_options (NMSettingWired *setting)

{

	return valid_s390_opts;

}

/**

 * nm_setting_wired_get_wake_on_lan:

 * @setting: the #NMSettingWired

 *

 * Returns the Wake-on-LAN options enabled for the connection

 *

 * Returns: the Wake-on-LAN options

 *

 * Since: 1.2

 */

NMSettingWiredWakeOnLan

nm_setting_wired_get_wake_on_lan (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NM_SETTING_WIRED_WAKE_ON_LAN_NONE);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->wol;

}

/**

 * nm_setting_wired_get_wake_on_lan_password:

 * @setting: the #NMSettingWired

 *

 * Returns the Wake-on-LAN password. This only applies to

 * %NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC.

 *

 * Returns: the Wake-on-LAN setting password, or %NULL if there is no password.

 *

 * Since: 1.2

 */

const char *

nm_setting_wired_get_wake_on_lan_password (NMSettingWired *setting)

{

	g_return_val_if_fail (NM_IS_SETTING_WIRED (setting), NULL);

	return NM_SETTING_WIRED_GET_PRIVATE (setting)->wol_password;

}

static gboolean

verify (NMSetting *setting, NMConnection *connection, GError **error)

{

	NMSettingWiredPrivate *priv = NM_SETTING_WIRED_GET_PRIVATE (setting);

	GError *local = NULL;

	guint i;

	if (!NM_IN_STRSET (priv->port, NULL, "tp", "aui", "bnc", "mii")) {

		g_set_error (error,

		             NM_CONNECTION_ERROR,

		             NM_CONNECTION_ERROR_INVALID_PROPERTY,

		             _("'%s' is not a valid Ethernet port value"),

		             priv->port);

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_PORT);

		return FALSE;

	}

	if (!NM_IN_STRSET (priv->duplex, NULL, "half", "full")) {

		g_set_error (error,

		             NM_CONNECTION_ERROR,

		             NM_CONNECTION_ERROR_INVALID_PROPERTY,

		             _("'%s' is not a valid duplex value"),

		             priv->duplex);

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_DUPLEX);

		return FALSE;

	}

	if (priv->device_mac_address && !nm_utils_hwaddr_valid (priv->device_mac_address, ETH_ALEN)) {

		g_set_error (error,

		             NM_CONNECTION_ERROR,

		             NM_CONNECTION_ERROR_INVALID_PROPERTY,

		             _("'%s' is not a valid MAC address"),

		             priv->device_mac_address);

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_MAC_ADDRESS);

		return FALSE;

	}

	for (i = 0; i < priv->mac_address_blacklist->len; i++) {

		const char *mac = g_array_index (priv->mac_address_blacklist, const char *, i);

		if (!nm_utils_hwaddr_valid (mac, ETH_ALEN)) {

			g_set_error (error,

			             NM_CONNECTION_ERROR,

			             NM_CONNECTION_ERROR_INVALID_PROPERTY,

			             _("'%s' is not a valid MAC address"),

			             mac);

			g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_MAC_ADDRESS_BLACKLIST);

			return FALSE;

		}

	}

	if (priv->s390_subchannels) {

		guint len = g_strv_length (priv->s390_subchannels);

		if (len != 2 && len != 3) {

			g_set_error_literal (error,

			                     NM_CONNECTION_ERROR,

			                     NM_CONNECTION_ERROR_INVALID_PROPERTY,

			                     _("property is invalid"));

			g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_SUBCHANNELS);

			return FALSE;

		}

	}

	if (!NM_IN_STRSET (priv->s390_nettype, NULL, "qeth", "lcs", "ctc")) {

		g_set_error_literal (error,

		                     NM_CONNECTION_ERROR,

		                     NM_CONNECTION_ERROR_INVALID_PROPERTY,

		                     _("property is invalid"));

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_NETTYPE);

		return FALSE;

	}

	for (i = 0; i < priv->s390_options.len; i++) {

		const NMUtilsNamedValue *v = &priv->s390_options.arr[i];

		nm_assert (v->name);

		if (   !valid_s390_opts_check (v->name)

		    || v->value_str[0] == '\0'

		    || strlen (v->value_str) > 200) {

			g_set_error (error,

			             NM_CONNECTION_ERROR,

			             NM_CONNECTION_ERROR_INVALID_PROPERTY,

			             _("invalid '%s' or its value '%s'"),

			             v->name, v->value_str);

			g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_S390_OPTIONS);

			return FALSE;

		}

	}

	if (   priv->cloned_mac_address

	    && !NM_CLONED_MAC_IS_SPECIAL (priv->cloned_mac_address)

	    && !nm_utils_hwaddr_valid (priv->cloned_mac_address, ETH_ALEN)) {

		g_set_error (error,

		             NM_CONNECTION_ERROR,

		             NM_CONNECTION_ERROR_INVALID_PROPERTY,

		             _("'%s' is not a valid MAC address"),

		             priv->cloned_mac_address);

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_CLONED_MAC_ADDRESS);

		return FALSE;

	}

	/* generate-mac-address-mask only makes sense with cloned-mac-address "random" or

	 * "stable". Still, let's not be so strict about that and accept the value

	 * even if it is unused. */

	if (!_nm_utils_generate_mac_address_mask_parse (priv->generate_mac_address_mask,

	                                                NULL, NULL, NULL, &local)) {

		g_set_error_literal (error,

		                     NM_CONNECTION_ERROR,

		                     NM_CONNECTION_ERROR_INVALID_PROPERTY,

		                     local->message);

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_GENERATE_MAC_ADDRESS_MASK);

		g_error_free (local);

		return FALSE;

	}

	if (   NM_FLAGS_ANY (priv->wol, NM_SETTING_WIRED_WAKE_ON_LAN_EXCLUSIVE_FLAGS)

	    && !nm_utils_is_power_of_two (priv->wol)) {

		g_set_error_literal (error,

		                     NM_CONNECTION_ERROR,

		                     NM_CONNECTION_ERROR_INVALID_PROPERTY,

		                     _("Wake-on-LAN mode 'default' and 'ignore' are exclusive flags"));

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_WAKE_ON_LAN);

		return FALSE;

	}

	if (priv->wol_password && !NM_FLAGS_HAS (priv->wol, NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC)) {

		g_set_error_literal (error,

		                     NM_CONNECTION_ERROR,

		                     NM_CONNECTION_ERROR_INVALID_PROPERTY,

		                     _("Wake-on-LAN password can only be used with magic packet mode"));

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_WAKE_ON_LAN_PASSWORD);

		return FALSE;

	}

	if (priv->wol_password && !nm_utils_hwaddr_valid (priv->wol_password, ETH_ALEN)) {

		g_set_error (error,

		             NM_CONNECTION_ERROR,

		             NM_CONNECTION_ERROR_INVALID_PROPERTY,

		             _("'%s' is not a valid MAC address"),

		             priv->wol_password);

		g_prefix_error (error, "%s.%s: ", NM_SETTING_WIRED_SETTING_NAME, NM_SETTING_WIRED_WAKE_ON_LAN_PASSWORD);

		return FALSE;

	}

	/* Normalizable properties - just return NM_SETTING_VERIFY_NORMALIZABLE for compatibility

	 * with legacy nm-connection-editor which used to save "full" duplex connection as default

	 */

	if (   ((priv->speed) && (!priv->duplex))

	    || ((!priv->speed) && (priv->duplex))) {

		g_set_error_literal (error,