libnm-core, etc: add nm_utils_hwaddr_matches()

Add nm_utils_hwaddr_matches(), for comparing hardware addresses for
equality, allowing either binary or ASCII hardware addresses to be
passed, and handling the special rules for InfiniBand hardware
addresses automatically. Update code to use it.

clients/tui/nmt-device-entry.c

@@ -327,7 +327,8 @@ nmt_device_entry_set_mac_address (NmtDeviceEntry *deventry,
 		g_clear_pointer (&priv->mac_address, g_byte_array_unref);
 		changed = TRUE;
 	} else if (   mac_address && priv->mac_address
-	           && memcmp (mac_address->data, priv->mac_address->data, mac_address->len) != 0) {
+	           && !nm_utils_hwaddr_matches (mac_address->data, mac_address->len,
+	                                        priv->mac_address->data, priv->mac_address->len)) {
 		g_byte_array_unref (priv->mac_address);
 		priv->mac_address = g_boxed_copy (DBUS_TYPE_G_UCHAR_ARRAY, mac_address);
 		changed = TRUE;

libnm-core/nm-utils.c

@@ -2113,6 +2113,94 @@ nm_utils_hwaddr_valid (const char *asc, gssize length)
 	return nm_utils_hwaddr_aton (asc, buf, length) != NULL;
 }
 
+/**
+ * nm_utils_hwaddr_matches:
+ * @hwaddr1: pointer to a binary or ASCII hardware address, or %NULL
+ * @hwaddr1_len: size of @hwaddr1, or -1 if @hwaddr1 is ASCII
+ * @hwaddr2: pointer to a binary or ASCII hardware address, or %NULL
+ * @hwaddr2_len: size of @hwaddr2, or -1 if @hwaddr2 is ASCII
+ *
+ * Generalized hardware address comparison function. Tests if @hwaddr1 and
+ * @hwaddr2 "equal" (or more precisely, "equivalent"), with several advantages
+ * over a simple memcmp():
+ *
+ *   1. If @hwaddr1_len or @hwaddr2_len is -1, then the corresponding address is
+ *      assumed to be ASCII rather than binary, and will be converted to binary
+ *      before being compared.
+ *
+ *   2. If @hwaddr1 or @hwaddr2 is %NULL, it is treated instead as though it was
+ *      a zero-filled buffer @hwaddr1_len or @hwaddr2_len bytes long.
+ *
+ *   3. If @hwaddr1 and @hwaddr2 are InfiniBand hardware addresses (that is, if
+ *      they are %INFINIBAND_ALEN bytes long in binary form) then only the last
+ *      8 bytes are compared, since those are the only bytes that matter for
+ *      InfiniBand hardware address matching.
+ *
+ * If a passed-in ASCII hardware address cannot be parsed, or would parse to an
+ * address larger than %NM_UTILS_HWADDR_LEN_MAX, then it will silently fail to
+ * match. (This means that externally-provided address strings do not need to be
+ * sanity-checked before comparing them against known good addresses; they are
+ * guaranteed to not match if they are invalid.)
+ *
+ * Return value: %TRUE if @hwaddr1 and @hwaddr2 are equivalent, %FALSE if they are
+ *   different (or either of them is invalid).
+ */
+gboolean
+nm_utils_hwaddr_matches (gconstpointer hwaddr1,
+                         gssize        hwaddr1_len,
+                         gconstpointer hwaddr2,
+                         gssize        hwaddr2_len)
+{
+	guint8 buf1[NM_UTILS_HWADDR_LEN_MAX], buf2[NM_UTILS_HWADDR_LEN_MAX];
+
+	if (hwaddr1_len == -1) {
+		g_return_val_if_fail (hwaddr1 != NULL, FALSE);
+
+		hwaddr1_len = hwaddr_binary_len (hwaddr1);
+		if (hwaddr1_len > NM_UTILS_HWADDR_LEN_MAX)
+			return FALSE;
+		if (!nm_utils_hwaddr_aton (hwaddr1, buf1, hwaddr1_len))
+			return FALSE;
+
+		hwaddr1 = buf1;
+	} else {
+		g_return_val_if_fail (hwaddr1_len > 0 && hwaddr1_len <= NM_UTILS_HWADDR_LEN_MAX, FALSE);
+
+		if (!hwaddr1) {
+			memset (buf1, 0, hwaddr1_len);
+			hwaddr1 = buf1;
+		}
+	}
+
+	if (hwaddr2_len == -1) {
+		g_return_val_if_fail (hwaddr2 != NULL, FALSE);
+
+		if (!nm_utils_hwaddr_aton (hwaddr2, buf2, hwaddr1_len))
+			return FALSE;
+
+		hwaddr2 = buf2;
+		hwaddr2_len = hwaddr1_len;
+	} else {
+		g_return_val_if_fail (hwaddr2_len > 0 && hwaddr2_len <= NM_UTILS_HWADDR_LEN_MAX, FALSE);
+
+		if (!hwaddr2) {
+			memset (buf2, 0, hwaddr2_len);
+			hwaddr2 = buf2;
+		}
+	}
+
+	if (hwaddr1_len != hwaddr2_len)
+		return FALSE;
+
+	if (hwaddr1_len == INFINIBAND_ALEN) {
+		hwaddr1 = (guint8 *)hwaddr1 + INFINIBAND_ALEN - 8;
+		hwaddr2 = (guint8 *)hwaddr2 + INFINIBAND_ALEN - 8;
+		hwaddr1_len = hwaddr2_len = 8;
+	}
+
+	return !memcmp (hwaddr1, hwaddr2, hwaddr1_len);
+}
+
 /**
  * nm_utils_bin2hexstr:
  * @bytes: an array of bytes

libnm-core/nm-utils.h

@@ -146,6 +146,10 @@ GByteArray *nm_utils_hwaddr_atoba (const char *asc, gsize length);
 guint8     *nm_utils_hwaddr_aton  (const char *asc, gpointer buffer, gsize length);
 
 gboolean    nm_utils_hwaddr_valid (const char *asc, gssize length);
+gboolean    nm_utils_hwaddr_matches (gconstpointer hwaddr1,
+                                     gssize        hwaddr1_len,
+                                     gconstpointer hwaddr2,
+                                     gssize        hwaddr2_len);
 
 char *nm_utils_bin2hexstr (const char *bytes, int len, int final_len);
 int   nm_utils_hex2byte   (const char *hex);

libnm-core/tests/test-general.c

@@ -1943,6 +1943,69 @@ test_hwaddr_aton_malformed (void)
 	g_assert (nm_utils_hwaddr_aton ("0:1a:2B:3:a@%%", buf, ETH_ALEN) == NULL);
 }
 
+static void
+test_hwaddr_equal (void)
+{
+	const char *string = "00:1a:2b:03:44:05";
+	const char *upper_string = "00:1A:2B:03:44:05";
+	const char *bad_string = "0:1a:2b:3:44:5";
+	const guint8 binary[ETH_ALEN] = { 0x00, 0x1A, 0x2B, 0x03, 0x44, 0x05 };
+	const char *other_string = "1a:2b:03:44:05:00";
+	const guint8 other_binary[ETH_ALEN] = { 0x1A, 0x2B, 0x03, 0x44, 0x05, 0x00 };
+	const char *long_string = "00:1a:2b:03:44:05:06:07";
+	const guint8 long_binary[8] = { 0x00, 0x1A, 0x2B, 0x03, 0x44, 0x05, 0x06, 0x07 };
+	const char *null_string = "00:00:00:00:00:00";
+	const guint8 null_binary[ETH_ALEN] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+	g_assert (nm_utils_hwaddr_matches (string, -1, string, -1));
+	g_assert (nm_utils_hwaddr_matches (string, -1, upper_string, -1));
+	g_assert (nm_utils_hwaddr_matches (string, -1, bad_string, -1));
+	g_assert (nm_utils_hwaddr_matches (string, -1, binary, sizeof (binary)));
+	g_assert (!nm_utils_hwaddr_matches (string, -1, other_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (string, -1, other_binary, sizeof (other_binary)));
+	g_assert (!nm_utils_hwaddr_matches (string, -1, long_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (string, -1, long_binary, sizeof (long_binary)));
+	g_assert (!nm_utils_hwaddr_matches (string, -1, null_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (string, -1, null_binary, sizeof (null_binary)));
+	g_assert (!nm_utils_hwaddr_matches (string, -1, NULL, ETH_ALEN));
+
+	g_assert (nm_utils_hwaddr_matches (binary, sizeof (binary), string, -1));
+	g_assert (nm_utils_hwaddr_matches (binary, sizeof (binary), upper_string, -1));
+	g_assert (nm_utils_hwaddr_matches (binary, sizeof (binary), bad_string, -1));
+	g_assert (nm_utils_hwaddr_matches (binary, sizeof (binary), binary, sizeof (binary)));
+	g_assert (!nm_utils_hwaddr_matches (binary, sizeof (binary), other_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (binary, sizeof (binary), other_binary, sizeof (other_binary)));
+	g_assert (!nm_utils_hwaddr_matches (binary, sizeof (binary), long_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (binary, sizeof (binary), long_binary, sizeof (long_binary)));
+	g_assert (!nm_utils_hwaddr_matches (binary, sizeof (binary), null_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (binary, sizeof (binary), null_binary, sizeof (null_binary)));
+	g_assert (!nm_utils_hwaddr_matches (binary, sizeof (binary), NULL, ETH_ALEN));
+
+	g_assert (!nm_utils_hwaddr_matches (null_string, -1, string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_string, -1, upper_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_string, -1, bad_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_string, -1, binary, sizeof (binary)));
+	g_assert (!nm_utils_hwaddr_matches (null_string, -1, other_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_string, -1, other_binary, sizeof (other_binary)));
+	g_assert (!nm_utils_hwaddr_matches (null_string, -1, long_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_string, -1, long_binary, sizeof (long_binary)));
+	g_assert (nm_utils_hwaddr_matches (null_string, -1, null_string, -1));
+	g_assert (nm_utils_hwaddr_matches (null_string, -1, null_binary, sizeof (null_binary)));
+	g_assert (nm_utils_hwaddr_matches (null_string, -1, NULL, ETH_ALEN));
+
+	g_assert (!nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), upper_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), bad_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), binary, sizeof (binary)));
+	g_assert (!nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), other_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), other_binary, sizeof (other_binary)));
+	g_assert (!nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), long_string, -1));
+	g_assert (!nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), long_binary, sizeof (long_binary)));
+	g_assert (nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), null_string, -1));
+	g_assert (nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), null_binary, sizeof (null_binary)));
+	g_assert (nm_utils_hwaddr_matches (null_binary, sizeof (null_binary), NULL, ETH_ALEN));
+}
+
 static void
 test_connection_changed_cb (NMConnection *connection, gboolean *data)
 {
@@ -2656,6 +2719,7 @@ int main (int argc, char **argv)
 	test_hwaddr_aton_ib_normal ();
 	test_hwaddr_aton_no_leading_zeros ();
 	test_hwaddr_aton_malformed ();
+	test_hwaddr_equal ();
 
 	test_ip4_prefix_to_netmask ();
 	test_ip4_netmask_to_prefix ();

libnm/libnm.ver

@@ -884,6 +884,7 @@ global:
 	nm_utils_hwaddr_atoba;
 	nm_utils_hwaddr_aton;
 	nm_utils_hwaddr_len;
+	nm_utils_hwaddr_matches;
 	nm_utils_hwaddr_ntoa;
 	nm_utils_hwaddr_valid;
 	nm_utils_iface_valid_name;

libnm/nm-access-point.c

@@ -235,11 +235,10 @@ nm_access_point_connection_valid (NMAccessPoint *ap, NMConnection *connection)
 	NMSettingConnection *s_con;
 	NMSettingWireless *s_wifi;
 	NMSettingWirelessSecurity *s_wsec;
-	const char *ctype, *ap_bssid_str;
+	const char *ctype, *ap_bssid;
 	const GByteArray *setting_ssid;
 	const GByteArray *ap_ssid;
 	const GByteArray *setting_bssid;
-	guint8 ap_bssid[ETH_ALEN];
 	const char *setting_mode;
 	NM80211Mode ap_mode;
 	const char *setting_band;
@@ -265,16 +264,12 @@ nm_access_point_connection_valid (NMAccessPoint *ap, NMConnection *connection)
 		return FALSE;
 
 	/* BSSID checks */
-	ap_bssid_str = nm_access_point_get_bssid (ap);
+	ap_bssid = nm_access_point_get_bssid (ap);
-	g_warn_if_fail (ap_bssid_str);
+	g_warn_if_fail (ap_bssid);
 	setting_bssid = nm_setting_wireless_get_bssid (s_wifi);
-	if (setting_bssid && ap_bssid_str) {
+	if (setting_bssid && ap_bssid) {
-		g_assert (setting_bssid->len == ETH_ALEN);
+		if (!nm_utils_hwaddr_matches (ap_bssid, -1, setting_bssid->data, setting_bssid->len))
-		if (nm_utils_hwaddr_aton (ap_bssid_str, ap_bssid, ETH_ALEN)) {
+			return FALSE;
-			if (memcmp (ap_bssid, setting_bssid->data, ETH_ALEN) != 0)
-				return FALSE;
-		} else
-			g_warn_if_reached ();
 	}
 
 	/* Mode */

libnm/nm-device-bt.c

@@ -147,8 +147,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 	NMSettingBluetooth *s_bt;
 	const char *ctype;
 	const GByteArray *mac;
-	const char *hw_str;
+	const char *hw_addr;
-	guint8 hw_mac[ETH_ALEN];
 	NMBluetoothCapabilities dev_caps;
 	NMBluetoothCapabilities bt_type;
 
@@ -170,15 +169,15 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 	}
 
 	/* Check BT address */
-	hw_str = nm_device_bt_get_hw_address (NM_DEVICE_BT (device));
+	hw_addr = nm_device_bt_get_hw_address (NM_DEVICE_BT (device));
-	if (hw_str) {
+	if (hw_addr) {
-		if (!nm_utils_hwaddr_aton (hw_str, hw_mac, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_valid (hw_addr, ETH_ALEN)) {
 			g_set_error (error, NM_DEVICE_BT_ERROR, NM_DEVICE_BT_ERROR_INVALID_DEVICE_MAC,
 			             "Invalid device MAC address.");
 			return FALSE;
 		}
 		mac = nm_setting_bluetooth_get_bdaddr (s_bt);
-		if (mac && memcmp (mac->data, hw_mac, ETH_ALEN)) {
+		if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, hw_addr, -1)) {
 			g_set_error (error, NM_DEVICE_BT_ERROR, NM_DEVICE_BT_ERROR_MAC_MISMATCH,
 			             "The MACs of the device and the connection didn't match.");
 			return FALSE;

libnm/nm-device-ethernet.c

@@ -169,21 +169,20 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 
 	if (s_wired) {
 		const GByteArray *mac;
-		const char *perm_str;
+		const char *perm_addr;
-		guint8 perm_mac[ETH_ALEN];
 
 		/* FIXME: filter using s390 subchannels when they are exported over the bus */
 
 		/* Check MAC address */
-		perm_str = nm_device_ethernet_get_permanent_hw_address (NM_DEVICE_ETHERNET (device));
+		perm_addr = nm_device_ethernet_get_permanent_hw_address (NM_DEVICE_ETHERNET (device));
-		if (perm_str) {
+		if (perm_addr) {
-			if (!nm_utils_hwaddr_aton (perm_str, perm_mac, ETH_ALEN)) {
+			if (!nm_utils_hwaddr_valid (perm_addr, ETH_ALEN)) {
 				g_set_error (error, NM_DEVICE_ETHERNET_ERROR, NM_DEVICE_ETHERNET_ERROR_INVALID_DEVICE_MAC,
 				             "Invalid device MAC address.");
 				return FALSE;
 			}
 			mac = nm_setting_wired_get_mac_address (s_wired);
-			if (mac && memcmp (mac->data, perm_mac, ETH_ALEN)) {
+			if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, perm_addr, -1)) {
 				g_set_error (error, NM_DEVICE_ETHERNET_ERROR, NM_DEVICE_ETHERNET_ERROR_MAC_MISMATCH,
 				             "The MACs of the device and the connection didn't match.");
 				return FALSE;

libnm/nm-device-infiniband.c

@@ -105,9 +105,8 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 {
 	NMSettingConnection *s_con;
 	NMSettingInfiniband *s_infiniband;
-	const char *ctype, *hwaddr_str;
+	const char *ctype, *hwaddr;
 	const GByteArray *mac;
-	guint8 *hwaddr, hwaddr_buf[INFINIBAND_ALEN];
 
 	s_con = nm_connection_get_setting_connection (connection);
 	g_assert (s_con);
@@ -126,18 +125,16 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 		return FALSE;
 	}
 
-	hwaddr_str = nm_device_infiniband_get_hw_address (NM_DEVICE_INFINIBAND (device));
+	hwaddr = nm_device_infiniband_get_hw_address (NM_DEVICE_INFINIBAND (device));
-	if (hwaddr_str) {
+	if (hwaddr) {
-		hwaddr = nm_utils_hwaddr_aton (hwaddr_str, hwaddr_buf, INFINIBAND_ALEN);
+		if (!nm_utils_hwaddr_valid (hwaddr, INFINIBAND_ALEN)) {
-		if (!hwaddr) {
 			g_set_error (error, NM_DEVICE_INFINIBAND_ERROR, NM_DEVICE_INFINIBAND_ERROR_INVALID_DEVICE_MAC,
 			             "Invalid device MAC address.");
 			return FALSE;
 		}
 		mac = nm_setting_infiniband_get_mac_address (s_infiniband);
 
-		/* We only match against the last 8 bytes */
+		if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, hwaddr, -1)) {
-		if (mac && hwaddr && memcmp (mac->data + INFINIBAND_ALEN - 8, hwaddr + INFINIBAND_ALEN - 8, 8)) {
 			g_set_error (error, NM_DEVICE_INFINIBAND_ERROR, NM_DEVICE_INFINIBAND_ERROR_MAC_MISMATCH,
 			             "The MACs of the device and the connection didn't match.");
 			return FALSE;

libnm/nm-device-wifi.c

@@ -419,8 +419,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 	NMSettingWirelessSecurity *s_wsec;
 	const char *ctype;
 	const GByteArray *mac;
-	const char *hw_str;
+	const char *hw_addr;
-	guint8 hw_mac[ETH_ALEN];
 	NMDeviceWifiCapabilities wifi_caps;
 	const char *key_mgmt;
 
@@ -442,15 +441,15 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 	}
 
 	/* Check MAC address */
-	hw_str = nm_device_wifi_get_permanent_hw_address (NM_DEVICE_WIFI (device));
+	hw_addr = nm_device_wifi_get_permanent_hw_address (NM_DEVICE_WIFI (device));
-	if (hw_str) {
+	if (hw_addr) {
-		if (!nm_utils_hwaddr_aton (hw_str, hw_mac, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_valid (hw_addr, ETH_ALEN)) {
 			g_set_error (error, NM_DEVICE_WIFI_ERROR, NM_DEVICE_WIFI_ERROR_INVALID_DEVICE_MAC,
 			             "Invalid device MAC address.");
 			return FALSE;
 		}
 		mac = nm_setting_wireless_get_mac_address (s_wifi);
-		if (mac && memcmp (mac->data, hw_mac, ETH_ALEN)) {
+		if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, hw_addr, -1)) {
 			g_set_error (error, NM_DEVICE_WIFI_ERROR, NM_DEVICE_WIFI_ERROR_MAC_MISMATCH,
 			             "The MACs of the device and the connection didn't match.");
 			return FALSE;

libnm/nm-device-wimax.c

@@ -323,8 +323,7 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 	NMSettingWimax *s_wimax;
 	const char *ctype;
 	const GByteArray *mac;
-	const char *hw_str;
+	const char *hw_addr;
-	guint8 hw_mac[ETH_ALEN];
 
 	s_con = nm_connection_get_setting_connection (connection);
 	g_assert (s_con);
@@ -344,15 +343,15 @@ connection_compatible (NMDevice *device, NMConnection *connection, GError **erro
 	}
 
 	/* Check MAC address */
-	hw_str = nm_device_wimax_get_hw_address (NM_DEVICE_WIMAX (device));
+	hw_addr = nm_device_wimax_get_hw_address (NM_DEVICE_WIMAX (device));
-	if (hw_str) {
+	if (hw_addr) {
-		if (!nm_utils_hwaddr_aton (hw_str, hw_mac, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_valid (hw_addr, ETH_ALEN)) {
 			g_set_error (error, NM_DEVICE_WIMAX_ERROR, NM_DEVICE_WIMAX_ERROR_INVALID_DEVICE_MAC,
 			             "Invalid device MAC address.");
 			return FALSE;
 		}
 		mac = nm_setting_wimax_get_mac_address (s_wimax);
-		if (mac && memcmp (mac->data, hw_mac, ETH_ALEN)) {
+		if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, hw_addr, -1)) {
 			g_set_error (error, NM_DEVICE_WIMAX_ERROR, NM_DEVICE_WIMAX_ERROR_MAC_MISMATCH,
 			             "The MACs of the device and the connection didn't match.");
 			return FALSE;

src/NetworkManagerUtils.c

@@ -585,18 +585,22 @@ nm_match_spec_string (const GSList *specs, const char *match)
 gboolean
 nm_match_spec_hwaddr (const GSList *specs, const char *hwaddr)
 {
-	char *hwaddr_match;
+	const GSList *iter;
-	gboolean matched;
 
 	g_return_val_if_fail (hwaddr != NULL, FALSE);
 
-	if (nm_match_spec_string (specs, hwaddr))
+	for (iter = specs; iter; iter = g_slist_next (iter)) {
-		return TRUE;
+		const char *spec_str = iter->data;
 
-	hwaddr_match = g_strdup_printf ("mac:%s", hwaddr);
+		if (   !g_ascii_strncasecmp (spec_str, "mac:", 4)
-	matched = nm_match_spec_string (specs, hwaddr_match);
+		    && nm_utils_hwaddr_matches (spec_str + 4, -1, hwaddr, -1))
-	g_free (hwaddr_match);
+			return TRUE;
-	return matched;
+
+		if (nm_utils_hwaddr_matches (spec_str, -1, hwaddr, -1))
+			return TRUE;
+	}
+
+	return FALSE;
 }
 
 gboolean

src/devices/bluetooth/nm-bluez-device.c

@@ -314,9 +314,9 @@ connection_compatible (NMBluezDevice *self, NMConnection *connection)
 		return FALSE;
 	}
 	bdaddr = nm_setting_bluetooth_get_bdaddr (s_bt);
-	if (!bdaddr || bdaddr->len != ETH_ALEN)
+	if (!bdaddr)
 		return FALSE;
-	if (memcmp (bdaddr->data, priv->bin_address, ETH_ALEN) != 0)
+	if (!nm_utils_hwaddr_matches (bdaddr->data, bdaddr->len, priv->bin_address, ETH_ALEN))
 		return FALSE;
 
 	bt_type = nm_setting_bluetooth_get_connection_type (s_bt);

src/devices/bluetooth/nm-device-bt.c

@@ -179,10 +179,9 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
 		return FALSE;
 
 	array = nm_setting_bluetooth_get_bdaddr (s_bt);
-	if (!array || (array->len != ETH_ALEN))
+	if (!array)
 		return FALSE;
-
+	if (!nm_utils_hwaddr_matches (priv->bdaddr, ETH_ALEN, array->data, array->len))
-	if (memcmp (priv->bdaddr, array->data, ETH_ALEN) != 0)
 		return FALSE;
 
 	return TRUE;
@@ -324,7 +323,7 @@ complete_connection (NMDevice *device,
 	setting_bdaddr = nm_setting_bluetooth_get_bdaddr (s_bt);
 	if (setting_bdaddr) {
 		/* Make sure the setting BT Address (if any) matches the device's */
-		if (memcmp (setting_bdaddr->data, priv->bdaddr, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_matches (setting_bdaddr->data, setting_bdaddr->len, priv->bdaddr, ETH_ALEN)) {
 			g_set_error_literal (error,
 			                     NM_SETTING_BLUETOOTH_ERROR,
 			                     NM_SETTING_BLUETOOTH_ERROR_INVALID_PROPERTY,
@@ -333,10 +332,9 @@ complete_connection (NMDevice *device,
 		}
 	} else {
 		GByteArray *bdaddr;
-		const guint8 null_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 
 		/* Lock the connection to this device by default */
-		if (memcmp (priv->bdaddr, null_mac, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_matches (priv->bdaddr, ETH_ALEN, NULL, ETH_ALEN)) {
 			bdaddr = g_byte_array_sized_new (ETH_ALEN);
 			g_byte_array_append (bdaddr, priv->bdaddr, ETH_ALEN);
 			g_object_set (G_OBJECT (s_bt), NM_SETTING_BLUETOOTH_BDADDR, bdaddr, NULL);

src/devices/nm-device-bridge.c

@@ -122,8 +122,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
 
 		hw_addr = nm_device_get_hw_address (device, &hw_len);
 		if (   !hw_addr
-		    || hw_len != mac_address->len
+		    || !nm_utils_hwaddr_matches (mac_address->data, mac_address->len, hw_addr, hw_len))
-		    || memcmp (mac_address->data, hw_addr, hw_len) != 0)
 			return FALSE;
 	}
 

src/devices/nm-device-ethernet.c

@@ -369,7 +369,7 @@ update_permanent_hw_address (NMDevice *dev)
 			memset (epaddr->data, 0, ETH_ALEN);
 	}
 
-	if (memcmp (priv->perm_hw_addr, epaddr->data, ETH_ALEN)) {
+	if (!nm_utils_hwaddr_matches (priv->perm_hw_addr, ETH_ALEN, epaddr->data, ETH_ALEN)) {
 		memcpy (priv->perm_hw_addr, epaddr->data, ETH_ALEN);
 		g_object_notify (G_OBJECT (dev), NM_DEVICE_ETHERNET_PERMANENT_HW_ADDRESS);
 	}
@@ -473,7 +473,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
 			return FALSE;
 
 		mac = nm_setting_wired_get_mac_address (s_wired);
-		if (try_mac && mac && memcmp (mac->data, priv->perm_hw_addr, ETH_ALEN))
+		if (try_mac && mac && !nm_utils_hwaddr_matches (mac->data, mac->len, priv->perm_hw_addr, ETH_ALEN))
 			return FALSE;
 
 		/* Check for MAC address blacklist */
@@ -487,7 +487,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
 				return FALSE;
 			}
 
-			if (memcmp (addr, priv->perm_hw_addr, ETH_ALEN) == 0)
+			if (nm_utils_hwaddr_matches (addr, ETH_ALEN, priv->perm_hw_addr, ETH_ALEN))
 				return FALSE;
 		}
 	}
@@ -1462,7 +1462,7 @@ complete_connection (NMDevice *device,
 	setting_mac = nm_setting_wired_get_mac_address (s_wired);
 	if (setting_mac) {
 		/* Make sure the setting MAC (if any) matches the device's permanent MAC */
-		if (memcmp (setting_mac->data, priv->perm_hw_addr, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, priv->perm_hw_addr, ETH_ALEN)) {
 			g_set_error_literal (error,
 			                     NM_SETTING_WIRED_ERROR,
 			                     NM_SETTING_WIRED_ERROR_INVALID_PROPERTY,
@@ -1471,10 +1471,9 @@ complete_connection (NMDevice *device,
 		}
 	} else {
 		GByteArray *mac;
-		const guint8 null_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 
 		/* Lock the connection to this device by default */
-		if (memcmp (priv->perm_hw_addr, null_mac, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_matches (priv->perm_hw_addr, ETH_ALEN, NULL, ETH_ALEN)) {
 			mac = g_byte_array_sized_new (ETH_ALEN);
 			g_byte_array_append (mac, priv->perm_hw_addr, ETH_ALEN);
 			g_object_set (G_OBJECT (s_wired), NM_SETTING_WIRED_MAC_ADDRESS, mac, NULL);
@@ -1503,7 +1502,6 @@ update_connection (NMDevice *device, NMConnection *connection)
 	NMSettingWired *s_wired = nm_connection_get_setting_wired (connection);
 	guint maclen;
 	const guint8 *mac = nm_device_get_hw_address (device, &maclen);
-	static const guint8 null_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 	const char *mac_prop = NM_SETTING_WIRED_MAC_ADDRESS;
 	GByteArray *array;
 	GHashTableIter iter;
@@ -1517,14 +1515,14 @@ update_connection (NMDevice *device, NMConnection *connection)
 	/* If the device reports a permanent address, use that for the MAC address
 	 * and the current MAC, if different, is the cloned MAC.
 	 */
-	if (memcmp (priv->perm_hw_addr, null_mac, ETH_ALEN)) {
+	if (!nm_utils_hwaddr_matches (priv->perm_hw_addr, ETH_ALEN, NULL, ETH_ALEN)) {
 		array = g_byte_array_sized_new (ETH_ALEN);
 		g_byte_array_append (array, priv->perm_hw_addr, ETH_ALEN);
 		g_object_set (s_wired, NM_SETTING_WIRED_MAC_ADDRESS, array, NULL);
 		g_byte_array_unref (array);
 
 		mac_prop = NULL;
-		if (mac && memcmp (priv->perm_hw_addr, mac, ETH_ALEN))
+		if (mac && !nm_utils_hwaddr_matches (priv->perm_hw_addr, ETH_ALEN, mac, ETH_ALEN))
 			mac_prop = NM_SETTING_WIRED_CLONED_MAC_ADDRESS;
 	}
 

src/devices/nm-device-infiniband.c

@@ -208,10 +208,8 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
 
 	if (s_infiniband) {
 		mac = nm_setting_infiniband_get_mac_address (s_infiniband);
-		/* We only compare the last 8 bytes */
+		if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len,
-		if (mac && memcmp (mac->data + INFINIBAND_ALEN - 8,
+		                                     nm_device_get_hw_address (device, NULL), INFINIBAND_ALEN))
-		                   nm_device_get_hw_address (device, NULL) + INFINIBAND_ALEN - 8,
-		                   8))
 			return FALSE;
 	}
 
@@ -246,7 +244,7 @@ complete_connection (NMDevice *device,
 	hw_address = nm_device_get_hw_address (device, NULL);
 	if (setting_mac) {
 		/* Make sure the setting MAC (if any) matches the device's MAC */
-		if (memcmp (setting_mac->data, hw_address, INFINIBAND_ALEN)) {
+		if (!nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, hw_address, INFINIBAND_ALEN)) {
 			g_set_error_literal (error,
 			                     NM_SETTING_INFINIBAND_ERROR,
 			                     NM_SETTING_INFINIBAND_ERROR_INVALID_PROPERTY,
@@ -275,7 +273,6 @@ update_connection (NMDevice *device, NMConnection *connection)
 	NMSettingInfiniband *s_infiniband = nm_connection_get_setting_infiniband (connection);
 	guint maclen;
 	gconstpointer mac = nm_device_get_hw_address (device, &maclen);
-	static const guint8 null_mac[INFINIBAND_ALEN] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 	GByteArray *array;
 	char *mode_path, *contents = NULL;
 	const char *transport_mode = "datagram";
@@ -285,7 +282,7 @@ update_connection (NMDevice *device, NMConnection *connection)
 		nm_connection_add_setting (connection, (NMSetting *) s_infiniband);
 	}
 
-	if (mac && (maclen == INFINIBAND_ALEN) && (memcmp (mac, null_mac, maclen) != 0)) {
+	if (mac && !nm_utils_hwaddr_matches (mac, maclen, NULL, INFINIBAND_ALEN)) {
 		array = g_byte_array_sized_new (maclen);
 		g_byte_array_append (array, (guint8 *) mac, maclen);
 		g_object_set (s_infiniband, NM_SETTING_INFINIBAND_MAC_ADDRESS, array, NULL);
@@ -306,37 +303,6 @@ update_connection (NMDevice *device, NMConnection *connection)
 	g_object_set (G_OBJECT (s_infiniband), NM_SETTING_INFINIBAND_TRANSPORT_MODE, transport_mode, NULL);
 }
 
-static gboolean
-spec_match_list (NMDevice *device, const GSList *specs)
-{
-	char *hwaddr_str, *spec_str;
-	const GSList *iter;
-
-	if (NM_DEVICE_CLASS (nm_device_infiniband_parent_class)->spec_match_list (device, specs))
-		return TRUE;
-
-	hwaddr_str = nm_utils_hwaddr_ntoa (nm_device_get_hw_address (device, NULL), INFINIBAND_ALEN);
-
-	/* InfiniBand hardware address matches only need to match the last
-	 * 8 bytes. In string format, that means we skip the first 36
-	 * characters of hwaddr_str, and the first 40 of the spec (to skip
-	 * "mac:" too).
-	 */
-	for (iter = specs; iter; iter = g_slist_next (iter)) {
-		spec_str = iter->data;
-
-		if (   !g_ascii_strncasecmp (spec_str, "mac:", 4)
-		    && strlen (spec_str) > 40
-		    && !g_ascii_strcasecmp (spec_str + 40, hwaddr_str + 36)) {
-			g_free (hwaddr_str);
-			return TRUE;
-		}
-	}
-
-	g_free (hwaddr_str);
-	return FALSE;
-}
-
 static void
 get_property (GObject *object, guint prop_id,
               GValue *value, GParamSpec *pspec)
@@ -375,7 +341,6 @@ nm_device_infiniband_class_init (NMDeviceInfinibandClass *klass)
 	parent_class->check_connection_compatible = check_connection_compatible;
 	parent_class->complete_connection = complete_connection;
 	parent_class->update_connection = update_connection;
-	parent_class->spec_match_list = spec_match_list;
 
 	parent_class->act_stage1_prepare = act_stage1_prepare;
 	parent_class->ip4_config_pre_commit = ip4_config_pre_commit;

src/devices/nm-device-vlan.c

@@ -171,8 +171,7 @@ match_hwaddr (NMDevice *device, NMConnection *connection, gboolean fail_if_no_hw
 
 	  device_mac = nm_device_get_hw_address (device, &device_mac_len);
 
-	  return (   mac->len == device_mac_len
+	  return nm_utils_hwaddr_matches (mac->data, mac->len, device_mac, device_mac_len);
-	          && memcmp (mac->data, device_mac, device_mac_len) == 0);
 }
 
 static gboolean

src/devices/nm-device.c

@@ -6953,7 +6953,7 @@ nm_device_set_hw_addr (NMDevice *self, const guint8 *addr,
 	g_return_val_if_fail (addr != NULL, FALSE);
 
 	/* Do nothing if current MAC is same */
-	if (cur_addr && !memcmp (cur_addr, addr, len)) {
+	if (cur_addr && nm_utils_hwaddr_matches (cur_addr, len, addr, len)) {
 		_LOGD (LOGD_DEVICE | hw_log_domain, "no MAC address change needed");
 		return TRUE;
 	}
@@ -6968,7 +6968,7 @@ nm_device_set_hw_addr (NMDevice *self, const guint8 *addr,
 		/* MAC address succesfully changed; update the current MAC to match */
 		nm_device_update_hw_address (self);
 		cur_addr = nm_device_get_hw_address (self, NULL);
-		if (memcmp (cur_addr, addr, len) == 0) {
+		if (nm_utils_hwaddr_matches (cur_addr, len, addr, len)) {
 			_LOGI (LOGD_DEVICE | hw_log_domain, "%s MAC address to %s",
 			       detail, mac_str);
 		} else {

src/devices/wifi/nm-device-olpc-mesh.c

@@ -349,8 +349,7 @@ check_companion (NMDeviceOlpcMesh *self, NMDevice *other)
 
 	my_addr = nm_device_get_hw_address (NM_DEVICE (self), NULL);
 	their_addr = nm_device_get_hw_address (other, &their_addr_len);
-	if (   (their_addr_len != ETH_ALEN)
+	if (!nm_utils_hwaddr_matches (my_addr, ETH_ALEN, their_addr, their_addr_len))
-	    || (memcmp (my_addr, their_addr, ETH_ALEN) != 0))
 		return FALSE;
 
 	g_assert (priv->companion == NULL);

src/devices/wifi/nm-device-wifi.c

@@ -416,7 +416,7 @@ find_active_ap (NMDeviceWifi *self,
 				continue;
 			}
 
-			if (memcmp (bssid, ap_bssid, ETH_ALEN)) {
+			if (!nm_utils_hwaddr_matches (bssid, ETH_ALEN, ap_bssid, ETH_ALEN)) {
 				_LOGD (LOGD_WIFI, "      BSSID mismatch");
 				continue;
 			}
@@ -828,7 +828,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
 		return FALSE;
 
 	mac = nm_setting_wireless_get_mac_address (s_wireless);
-	if (mac && memcmp (mac->data, priv->perm_hw_addr, ETH_ALEN))
+	if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, priv->perm_hw_addr, ETH_ALEN))
 		return FALSE;
 
 	/* Check for MAC address blacklist */
@@ -839,10 +839,10 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
 
 		if (!nm_utils_hwaddr_aton (mac_blacklist_iter->data, addr, ETH_ALEN)) {
 			g_warn_if_reached ();
-			continue;
+			return FALSE;
 		}
 
-		if (memcmp (&addr, priv->perm_hw_addr, ETH_ALEN) == 0)
+		if (nm_utils_hwaddr_matches (addr, ETH_ALEN, priv->perm_hw_addr, ETH_ALEN))
 			return FALSE;
 	}
 
@@ -1120,7 +1120,7 @@ complete_connection (NMDevice *device,
 	setting_mac = nm_setting_wireless_get_mac_address (s_wifi);
 	if (setting_mac) {
 		/* Make sure the setting MAC (if any) matches the device's permanent MAC */
-		if (memcmp (setting_mac->data, priv->perm_hw_addr, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, priv->perm_hw_addr, ETH_ALEN)) {
 			g_set_error (error,
 			             NM_SETTING_WIRELESS_ERROR,
 			             NM_SETTING_WIRELESS_ERROR_INVALID_PROPERTY,
@@ -1129,13 +1129,12 @@ complete_connection (NMDevice *device,
 		}
 	} else {
 		GByteArray *mac;
-		const guint8 null_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 
 		/* Lock the connection to this device by default if it uses a
 		 * permanent MAC address (ie not a 'locally administered' one)
 		 */
 		if (   !(priv->perm_hw_addr[0] & 0x02)
-		    && memcmp (priv->perm_hw_addr, null_mac, ETH_ALEN)) {
+		    && !nm_utils_hwaddr_matches (priv->perm_hw_addr, ETH_ALEN, NULL, ETH_ALEN)) {
 			mac = g_byte_array_sized_new (ETH_ALEN);
 			g_byte_array_append (mac, priv->perm_hw_addr, ETH_ALEN);
 			g_object_set (G_OBJECT (s_wifi), NM_SETTING_WIRELESS_MAC_ADDRESS, mac, NULL);
@@ -2539,7 +2538,7 @@ update_permanent_hw_address (NMDevice *device)
 		memcpy (epaddr->data, nm_device_get_hw_address (device, NULL), ETH_ALEN);
 	}
 
-	if (memcmp (priv->perm_hw_addr, epaddr->data, ETH_ALEN)) {
+	if (!nm_utils_hwaddr_matches (priv->perm_hw_addr, ETH_ALEN, epaddr->data, ETH_ALEN)) {
 		memcpy (priv->perm_hw_addr, epaddr->data, ETH_ALEN);
 		g_object_notify (G_OBJECT (device), NM_DEVICE_WIFI_PERMANENT_HW_ADDRESS);
 	}

src/devices/wifi/nm-wifi-ap.c

@@ -901,7 +901,7 @@ nm_ap_set_address (NMAccessPoint *ap, const guint8 *addr)
 
 	priv = NM_AP_GET_PRIVATE (ap);
 
-	if (memcmp (addr, priv->address, sizeof (priv->address))) {
+	if (!nm_utils_hwaddr_matches (addr, ETH_ALEN, priv->address, sizeof (priv->address))) {
 		memcpy (NM_AP_GET_PRIVATE (ap)->address, addr, sizeof (priv->address));
 		g_object_notify (G_OBJECT (ap), NM_AP_HW_ADDRESS);
 	}
@@ -1124,7 +1124,7 @@ nm_ap_check_compatible (NMAccessPoint *self,
 		return FALSE;
 
 	bssid = nm_setting_wireless_get_bssid (s_wireless);
-	if (bssid && memcmp (bssid->data, priv->address, ETH_ALEN))
+	if (bssid && !nm_utils_hwaddr_matches (bssid->data, bssid->len, priv->address, ETH_ALEN))
 		return FALSE;
 
 	mode = nm_setting_wireless_get_mode (s_wireless);
@@ -1237,7 +1237,7 @@ nm_ap_match_in_list (NMAccessPoint *find_ap,
 		/* BSSID match */
 		if (   (strict_match || nm_ethernet_address_is_valid (find_addr))
 		    && nm_ethernet_address_is_valid (list_addr)
-		    && memcmp (list_addr, find_addr, ETH_ALEN) != 0)
+		    && !nm_utils_hwaddr_matches (list_addr, ETH_ALEN, find_addr, ETH_ALEN))
 			continue;
 
 		/* mode match */

src/devices/wimax/nm-device-wimax.c

@@ -332,7 +332,7 @@ check_connection_compatible (NMDevice *device, NMConnection *connection)
 		return FALSE;
 
 	mac = nm_setting_wimax_get_mac_address (s_wimax);
-	if (mac && memcmp (mac->data, nm_device_get_hw_address (device, NULL), ETH_ALEN))
+	if (mac && !nm_utils_hwaddr_matches (mac->data, mac->len, nm_device_get_hw_address (device, NULL), ETH_ALEN))
 		return FALSE;
 
 	return TRUE;
@@ -452,7 +452,7 @@ complete_connection (NMDevice *device,
 	hw_address = nm_device_get_hw_address (device, NULL);
 	if (setting_mac) {
 		/* Make sure the setting MAC (if any) matches the device's permanent MAC */
-		if (memcmp (setting_mac->data, hw_address, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, hw_address, ETH_ALEN)) {
 			g_set_error (error,
 				         NM_SETTING_WIMAX_ERROR,
 				         NM_SETTING_WIMAX_ERROR_INVALID_PROPERTY,
@@ -461,10 +461,9 @@ complete_connection (NMDevice *device,
 		}
 	} else {
 		GByteArray *mac;
-		const guint8 null_mac[ETH_ALEN] = { 0, 0, 0, 0, 0, 0 };
 
 		/* Lock the connection to this device by default */
-		if (memcmp (hw_address, null_mac, ETH_ALEN)) {
+		if (!nm_utils_hwaddr_matches (hw_address, ETH_ALEN, NULL, ETH_ALEN)) {
 			mac = g_byte_array_sized_new (ETH_ALEN);
 			g_byte_array_append (mac, hw_address, ETH_ALEN);
 			g_object_set (G_OBJECT (s_wimax), NM_SETTING_WIMAX_MAC_ADDRESS, mac, NULL);

src/nm-manager.c

@@ -856,8 +856,7 @@ get_device_from_hwaddr (NMManager *self, const GByteArray *setting_mac)
 		NMDevice *device = iter->data;
 
 		device_mac = nm_device_get_hw_address (iter->data, &device_mac_len);
-		if (   setting_mac->len == device_mac_len
+		if (nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, device_mac, device_mac_len))
-		    && memcmp (setting_mac->data, device_mac, device_mac_len) == 0)
 			return device;
 	}
 	return NULL;

src/settings/nm-settings.c

@@ -1508,8 +1508,7 @@ have_connection_for_device (NMSettings *self, NMDevice *device)
 		setting_mac = nm_setting_wired_get_mac_address (s_wired);
 		if (setting_mac) {
 			/* A connection mac-locked to this device */
-			if (hwaddr_len == setting_mac->len &&
+			if (nm_utils_hwaddr_matches (setting_mac->data, setting_mac->len, hwaddr, hwaddr_len))
-				!memcmp (setting_mac->data, hwaddr, hwaddr_len))
 				return TRUE;
 		} else {
 			/* A connection that applies to any wired device */

src/settings/plugins/ifcfg-rh/reader.c

@@ -440,7 +440,7 @@ fill_ip4_setting_from_ibft (shvarFile *ifcfg,
 				continue;
 			}
 
-			if (memcmp (ifcfg_mac->data, ibft_mac, ETH_ALEN)) {
+			if (!nm_utils_hwaddr_matches (ibft_mac, ETH_ALEN, ifcfg_mac->data, ifcfg_mac->len)) {
 				/* This record isn't for the current device, ignore it */
 				skip = TRUE;
 				continue;