core: track addresses for NMIP4Config/NMIP6Config via NMDedupMultiIndex

Reasons:

 - it adds an O(1) lookup index for accessing NMIPxConfig's addresses.
   Hence, operations like merge/intersect have now runtime O(n) instead
   of O(n^2).
   Arguably, we expect low numbers of addresses in general. For low
   numbers, the O(n^2) doesn't matter and quite likely in those cases
   the previous implementation was just fine -- maybe even faster.
   But the simple case works fine either way. It's important to scale
   well in the exceptional case.
 - the tracked objects can be shared between the various NMPI4Config,
   NMIP6Config instances with NMPlatform and everybody else.
 - the NMPObject can be treated generically, meaning it enables code to
   handle both IPv4 and IPv6, or addresses and routes. See for example
   _nm_ip_config_add_obj().
 - I want core to evolve to somewhere where we don't keep copies of
   NMPlatformIP4Address, et al. instances. Instead they shall all be
   shared. I hope this will reduce memory consumption (although tracking a
   reference consumes some memory too). Also, it shortcuts nmp_object_equal()
   when comparing the same object. Calling nmp_object_equal() on the
   identical objects would be a common case after the hash function
   pre-evaluates equality.

21 files changed, 1162 insertions, 822 deletions

diff --git a/shared/nm-utils/nm-dedup-multi.c b/shared/nm-utils/nm-dedup-multi.c
index f94bdf853e..000f8a7214 100644
--- a/shared/nm-utils/nm-dedup-multi.c
+++ b/shared/nm-utils/nm-dedup-multi.c
@@ -927,21 +927,60 @@ nm_dedup_multi_obj_clone (const NMDedupMultiObj *obj)
 	return o;
 }
 
+gconstpointer *
+nm_dedup_multi_objs_to_array_head (const NMDedupMultiHeadEntry *head_entry,
+                                   NMDedupMultiFcnSelectPredicate predicate,
+                                   gpointer user_data,
+                                   guint *out_len)
+{
+	gconstpointer *result;
+	CList *iter;
+	guint i;
+
+	if (!head_entry) {
+		NM_SET_OUT (out_len, 0);
+		return NULL;
+	}
+
+	result = g_new (gconstpointer, head_entry->len + 1);
+	i = 0;
+	c_list_for_each (iter, &head_entry->lst_entries_head) {
+		const NMDedupMultiObj *obj = c_list_entry (iter, NMDedupMultiEntry, lst_entries)->obj;
+
+		if (   !predicate
+		    || predicate (obj, user_data)) {
+			nm_assert (i < head_entry->len);
+			result[i++] = obj;
+		}
+	}
+
+	if (i == 0) {
+		g_free (result);
+		NM_SET_OUT (out_len, 0);
+		return NULL;
+	}
+
+	nm_assert (i <= head_entry->len);
+	NM_SET_OUT (out_len, i);
+	result[i++] = NULL;
+	return result;
+}
+
 GPtrArray *
 nm_dedup_multi_objs_to_ptr_array_head (const NMDedupMultiHeadEntry *head_entry,
                                        NMDedupMultiFcnSelectPredicate predicate,
                                        gpointer user_data)
 {
 	GPtrArray *result;
-	NMDedupMultiIter iter;
+	CList *iter;
 
 	if (!head_entry)
 		return NULL;
 
 	result = g_ptr_array_new_full (head_entry->len,
 	                               (GDestroyNotify) nm_dedup_multi_obj_unref);
-	nm_dedup_multi_iter_for_each (&iter, head_entry) {
-		const NMDedupMultiObj *obj = iter.current->obj;
+	c_list_for_each (iter, &head_entry->lst_entries_head) {
+		const NMDedupMultiObj *obj = c_list_entry (iter, NMDedupMultiEntry, lst_entries)->obj;
 
 		if (   !predicate
 		    || predicate (obj, user_data))
diff --git a/shared/nm-utils/nm-dedup-multi.h b/shared/nm-utils/nm-dedup-multi.h
index e44fbe451b..8edd021c23 100644
--- a/shared/nm-utils/nm-dedup-multi.h
+++ b/shared/nm-utils/nm-dedup-multi.h
@@ -23,7 +23,7 @@
 #define __NM_DEDUP_MULTI_H__
 
 #include "nm-obj.h"
-#include "c-list.h"
+#include "c-list-util.h"
 
 /*****************************************************************************/
 
@@ -370,10 +370,27 @@ nm_dedup_multi_iter_rewind (NMDedupMultiIter *iter)
 typedef gboolean (*NMDedupMultiFcnSelectPredicate) (/* const NMDedupMultiObj * */ gconstpointer obj,
                                                     gpointer user_data);
 
+gconstpointer *nm_dedup_multi_objs_to_array_head (const NMDedupMultiHeadEntry *head_entry,
+                                                  NMDedupMultiFcnSelectPredicate predicate,
+                                                  gpointer user_data,
+                                                  guint *out_len);
 GPtrArray *nm_dedup_multi_objs_to_ptr_array_head (const NMDedupMultiHeadEntry *head_entry,
                                                   NMDedupMultiFcnSelectPredicate predicate,
                                                   gpointer user_data);
 
+static inline void
+nm_dedup_multi_head_entry_sort (const NMDedupMultiHeadEntry *head_entry,
+                                CListSortCmp cmp,
+                                gconstpointer user_data)
+{
+	if (head_entry) {
+		/* the head entry can be sorted directly without messing up the
+		 * index to which it belongs. Of course, this does mess up any
+		 * NMDedupMultiIter instances. */
+		c_list_sort ((CList *) &head_entry->lst_entries_head, cmp, user_data);
+	}
+}
+
 /*****************************************************************************/
 
 #endif /* __NM_DEDUP_MULTI_H__ */
diff --git a/src/devices/nm-device.c b/src/devices/nm-device.c
index 4bf34cd5b2..503b87ed4b 100644
--- a/src/devices/nm-device.c
+++ b/src/devices/nm-device.c
@@ -2454,16 +2454,19 @@ ndisc_set_router_config (NMNDisc *ndisc, NMDevice *self)
 	gint32 now;
 	GArray *addresses, *dns_servers, *dns_domains;
 	guint len, i;
+	const NMDedupMultiHeadEntry *head_entry;
+	NMDedupMultiIter ipconf_iter;
 
 	if (nm_ndisc_get_node_type (ndisc) != NM_NDISC_NODE_TYPE_ROUTER)
 		return;
 
 	now = nm_utils_get_monotonic_timestamp_s ();
 
-	len = nm_ip6_config_get_num_addresses (priv->ip6_config);
-	addresses = g_array_sized_new (FALSE, TRUE, sizeof (NMNDiscAddress), len);
-	for (i = 0; i < len; i++) {
-		const NMPlatformIP6Address *addr = nm_ip6_config_get_address (priv->ip6_config, i);
+	head_entry = nm_ip6_config_lookup_addresses (priv->ip6_config);
+	addresses = g_array_sized_new (FALSE, TRUE, sizeof (NMNDiscAddress),
+	                               head_entry ? head_entry->len : 0);
+	nm_dedup_multi_iter_for_each (&ipconf_iter, head_entry) {
+		const NMPlatformIP6Address *addr = NMP_OBJECT_CAST_IP6_ADDRESS (ipconf_iter.current->obj);
 		NMNDiscAddress *ndisc_addr;
 
 		if (IN6_IS_ADDR_LINKLOCAL (&addr->address))
@@ -5095,17 +5098,17 @@ arping_manager_probe_terminated (NMArpingManager *arping_manager, ArpingData *da
 {
 	NMDevice *self;
 	NMDevicePrivate *priv;
+	NMDedupMultiIter ipconf_iter;
 	const NMPlatformIP4Address *address;
 	gboolean result, success = TRUE;
-	int i, j;
+	int i;
 
 	g_assert (data);
 	self = data->device;
 	priv = NM_DEVICE_GET_PRIVATE (self);
 
 	for (i = 0; data->configs && data->configs[i]; i++) {
-		for (j = 0; j < nm_ip4_config_get_num_addresses (data->configs[i]); j++) {
-			address = nm_ip4_config_get_address (data->configs[i], j);
+		nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, data->configs[i], &address) {
 			result = nm_arping_manager_check_address (arping_manager, address->address);
 			success &= result;
 
@@ -5139,13 +5142,14 @@ ipv4_dad_start (NMDevice *self, NMIP4Config **configs, ArpingCallback cb)
 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
 	NMArpingManager *arping_manager;
 	const NMPlatformIP4Address *address;
+	NMDedupMultiIter ipconf_iter;
 	ArpingData *data;
 	guint timeout;
 	gboolean ret, addr_found;
 	const guint8 *hw_addr;
 	size_t hw_addr_len = 0;
 	GError *error = NULL;
-	guint i, j;
+	guint i;
 
 	g_return_if_fail (NM_IS_DEVICE (self));
 	g_return_if_fail (configs);
@@ -5191,10 +5195,8 @@ ipv4_dad_start (NMDevice *self, NMIP4Config **configs, ArpingCallback cb)
 	data->device = self;
 
 	for (i = 0; configs[i]; i++) {
-		for (j = 0; j < nm_ip4_config_get_num_addresses (configs[i]); j++) {
-			address = nm_ip4_config_get_address (configs[i], j);
+		nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, configs[i], &address)
 			nm_arping_manager_add_address (arping_manager, address->address);
-		}
 	}
 
 	g_signal_connect_data (arping_manager, NM_ARPING_MANAGER_PROBE_TERMINATED,
@@ -6618,7 +6620,6 @@ dhcp6_state_changed (NMDhcpClient *client,
 {
 	NMDevice *self = NM_DEVICE (user_data);
 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
-	guint i;
 
 	g_return_if_fail (nm_dhcp_client_get_ipv6 (client) == TRUE);
 	g_return_if_fail (!ip6_config || NM_IS_IP6_CONFIG (ip6_config));
@@ -6635,10 +6636,11 @@ dhcp6_state_changed (NMDhcpClient *client,
 		    && event_id
 		    && priv->dhcp6.event_id
 		    && !strcmp (event_id, priv->dhcp6.event_id)) {
-			for (i = 0; i < nm_ip6_config_get_num_addresses (ip6_config); i++) {
-				nm_ip6_config_add_address (priv->dhcp6.ip6_config,
-				                           nm_ip6_config_get_address (ip6_config, i));
-			}
+			NMDedupMultiIter ipconf_iter;
+			const NMPlatformIP6Address *a;
+
+			nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ip6_config, &a)
+				nm_ip6_config_add_address (priv->dhcp6.ip6_config, a);
 		} else {
 			g_clear_object (&priv->dhcp6.ip6_config);
 			g_clear_pointer (&priv->dhcp6.event_id, g_free);
@@ -6978,7 +6980,6 @@ check_and_add_ipv6ll_addr (NMDevice *self)
 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
 	int ip_ifindex = nm_device_get_ip_ifindex (self);
 	struct in6_addr lladdr;
-	guint i, n;
 	NMConnection *connection;
 	NMSettingIP6Config *s_ip6 = NULL;
 	GError *error = NULL;
@@ -6987,11 +6988,10 @@ check_and_add_ipv6ll_addr (NMDevice *self)
 		return;
 
 	if (priv->ip6_config) {
-		n = nm_ip6_config_get_num_addresses (priv->ip6_config);
-		for (i = 0; i < n; i++) {
-			const NMPlatformIP6Address *addr;
+		NMDedupMultiIter ipconf_iter;
+		const NMPlatformIP6Address *addr;
 
-			addr = nm_ip6_config_get_address (priv->ip6_config, i);
+		nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, priv->ip6_config, &addr) {
 			if (   IN6_IS_ADDR_LINKLOCAL (&addr->address)
 			    && !(addr->n_ifa_flags & IFA_F_DADFAILED)) {
 				/* Already have an LL address, nothing to do */
@@ -8292,15 +8292,15 @@ start_sharing (NMDevice *self, NMIP4Config *config)
 	char str_addr[INET_ADDRSTRLEN + 1];
 	char str_mask[INET_ADDRSTRLEN + 1];
 	guint32 netmask, network;
-	const NMPlatformIP4Address *ip4_addr;
+	const NMPlatformIP4Address *ip4_addr = NULL;
 	const char *ip_iface;
 
 	g_return_val_if_fail (config != NULL, FALSE);
 
 	ip_iface = nm_device_get_ip_iface (self);
 
-	ip4_addr = nm_ip4_config_get_address (config, 0);
-	if (!ip4_addr || !ip4_addr->address)
+	ip4_addr = nm_ip4_config_get_first_address (config);
+	if (ip4_addr || !ip4_addr->address)
 		return FALSE;
 
 	netmask = nm_utils_ip4_prefix_to_netmask (ip4_addr->plen);
@@ -8513,7 +8513,8 @@ dad6_get_pending_addresses (NMDevice *self)
 	                         priv->wwan_ip6_config };
 	const NMPlatformIP6Address *addr, *pl_addr;
 	NMIP6Config *dad6_config = NULL;
-	guint i, j, num;
+	NMDedupMultiIter ipconf_iter;
+	guint i;
 	int ifindex;
 
 	ifindex = nm_device_get_ip_ifindex (self);
@@ -8524,9 +8525,8 @@ dad6_get_pending_addresses (NMDevice *self)
 	 */
 	for (i = 0; i < G_N_ELEMENTS (confs); i++) {
 		if (confs[i]) {
-			num = nm_ip6_config_get_num_addresses (confs[i]);
-			for (j = 0; j < num; j++) {
-				addr = nm_ip6_config_get_address (confs[i], j);
+
+			nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, confs[i], &addr) {
 				pl_addr = nm_platform_ip6_address_get (nm_device_get_platform (self),
 				                                       ifindex,
 				                                       addr->address);
@@ -8738,16 +8738,15 @@ static void
 _update_ip4_address (NMDevice *self)
 {
 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
-	guint32 addr;
+	const NMPlatformIP4Address *address;
 
 	g_return_if_fail (NM_IS_DEVICE (self));
 
 	if (   priv->ip4_config
 	    && ip_config_valid (priv->state)
-	    && nm_ip4_config_get_num_addresses (priv->ip4_config)) {
-		addr = nm_ip4_config_get_address (priv->ip4_config, 0)->address;
-		if (addr != priv->ip4_address) {
-			priv->ip4_address = addr;
+	    && (address = nm_ip4_config_get_first_address (priv->ip4_config))) {
+		if (address->address != priv->ip4_address) {
+			priv->ip4_address = address->address;
 			_notify (self, PROP_IP4_ADDRESS);
 		}
 	}
@@ -10598,7 +10597,7 @@ find_ip4_lease_config (NMDevice *self,
 	                                               nm_device_get_ip4_route_metric (self));
 	for (liter = leases; liter && !found; liter = liter->next) {
 		NMIP4Config *lease_config = liter->data;
-		const NMPlatformIP4Address *address = nm_ip4_config_get_address (lease_config, 0);
+		const NMPlatformIP4Address *address = nm_ip4_config_get_first_address (lease_config);
 		guint32 gateway = nm_ip4_config_get_gateway (lease_config);
 
 		g_assert (address);
@@ -10624,23 +10623,24 @@ capture_lease_config (NMDevice *self,
 	NMSettingsConnection *const*connections;
 	guint i;
 	gboolean dhcp_used = FALSE;
+	NMDedupMultiIter ipconf_iter;
 
 	/* Ensure at least one address on the device has a non-infinite lifetime,
 	 * otherwise DHCP cannot possibly be active on the device right now.
 	 */
 	if (ext_ip4_config && out_ip4_config) {
-		for (i = 0; i < nm_ip4_config_get_num_addresses (ext_ip4_config); i++) {
-			const NMPlatformIP4Address *addr = nm_ip4_config_get_address (ext_ip4_config, i);
+		const NMPlatformIP4Address *addr;
 
+		nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, ext_ip4_config, &addr) {
 			if (addr->lifetime != NM_PLATFORM_LIFETIME_PERMANENT) {
 				dhcp_used = TRUE;
 				break;
 			}
 		}
 	} else if (ext_ip6_config && out_ip6_config) {
-		for (i = 0; i < nm_ip6_config_get_num_addresses (ext_ip6_config); i++) {
-			const NMPlatformIP6Address *addr = nm_ip6_config_get_address (ext_ip6_config, i);
+		const NMPlatformIP6Address *addr;
 
+		nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ext_ip6_config, &addr) {
 			if (addr->lifetime != NM_PLATFORM_LIFETIME_PERMANENT) {
 				dhcp_used = TRUE;
 				break;
@@ -12227,15 +12227,13 @@ static char *
 find_dhcp4_address (NMDevice *self)
 {
 	NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
-	guint i, n;
+	const NMPlatformIP4Address *a;
+	NMDedupMultiIter ipconf_iter;
 
 	if (!priv->ip4_config)
 		return NULL;
 
-	n = nm_ip4_config_get_num_addresses (priv->ip4_config);
-	for (i = 0; i < n; i++) {
-		const NMPlatformIP4Address *a = nm_ip4_config_get_address (priv->ip4_config, i);
-
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, priv->ip4_config, &a) {
 		if (a->addr_source == NM_IP_CONFIG_SOURCE_DHCP)
 			return g_strdup (nm_utils_inet4_ntop (a->address, NULL));
 	}
diff --git a/src/devices/wwan/nm-modem.c b/src/devices/wwan/nm-modem.c
index c6885cef7d..76df89e58b 100644
--- a/src/devices/wwan/nm-modem.c
+++ b/src/devices/wwan/nm-modem.c
@@ -682,7 +682,7 @@ nm_modem_ip4_pre_commit (NMModem *modem,
 	 */
 	if (   priv->ip4_method == NM_MODEM_IP_METHOD_STATIC
 	    || priv->ip4_method == NM_MODEM_IP_METHOD_AUTO) {
-		const NMPlatformIP4Address *address = nm_ip4_config_get_address (config, 0);
+		const NMPlatformIP4Address *address = nm_ip4_config_get_first_address (config);
 
 		g_assert (address);
 		if (address->plen == 32)
@@ -698,7 +698,8 @@ nm_modem_emit_ip6_config_result (NMModem *self,
                                  GError *error)
 {
 	NMModemPrivate *priv = NM_MODEM_GET_PRIVATE (self);
-	guint i, num;
+	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP6Address *addr;
 	gboolean do_slaac = TRUE;
 
 	if (error) {
@@ -710,11 +711,7 @@ nm_modem_emit_ip6_config_result (NMModem *self,
 		/* If the IPv6 configuration only included a Link-Local address, then
 		 * we have to run SLAAC to get the full IPv6 configuration.
 		 */
-		num = nm_ip6_config_get_num_addresses (config);
-		g_assert (num > 0);
-		for (i = 0; i < num; i++) {
-			const NMPlatformIP6Address * addr = nm_ip6_config_get_address (config, i);
-
+		nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, config, &addr) {
 			if (IN6_IS_ADDR_LINKLOCAL (&addr->address)) {
 				if (!priv->iid.id)
 					priv->iid.id = ((guint64 *)(&addr->address.s6_addr))[1];
diff --git a/src/dhcp/tests/test-dhcp-dhclient.c b/src/dhcp/tests/test-dhcp-dhclient.c
index c8e225e441..2e68a6e081 100644
--- a/src/dhcp/tests/test-dhcp-dhclient.c
+++ b/src/dhcp/tests/test-dhcp-dhclient.c
@@ -37,6 +37,8 @@
 
 #define DEBUG 1
 
+static const int IFINDEX = 5;
+
 static void
 test_config (const char *orig,
              const char *expected,
@@ -910,7 +912,7 @@ test_read_lease_ip4_config_basic (void)
 
 	/* Date from before the least expiration */
 	now = g_date_time_new_utc (2013, 11, 1, 19, 55, 32);
-	leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", -1, contents, FALSE, now);
+	leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", IFINDEX, contents, FALSE, now);
 	g_assert_cmpint (g_slist_length (leases), ==, 2);
 
 	/* IP4Config #1 */
@@ -920,7 +922,7 @@ test_read_lease_ip4_config_basic (void)
 	/* Address */
 	g_assert_cmpint (nm_ip4_config_get_num_addresses (config), ==, 1);
 	expected_addr = nmtst_inet4_from_string ("192.168.1.180");
-	addr = nm_ip4_config_get_address (config, 0);
+	addr = _nmtst_nm_ip4_config_get_address (config, 0);
 	g_assert_cmpint (addr->address, ==, expected_addr);
 	g_assert_cmpint (addr->peer_address, ==, expected_addr);
 	g_assert_cmpint (addr->plen, ==, 24);
@@ -943,7 +945,7 @@ test_read_lease_ip4_config_basic (void)
 	/* Address */
 	g_assert_cmpint (nm_ip4_config_get_num_addresses (config), ==, 1);
 	expected_addr = nmtst_inet4_from_string ("10.77.52.141");
-	addr = nm_ip4_config_get_address (config, 0);
+	addr = _nmtst_nm_ip4_config_get_address (config, 0);
 	g_assert_cmpint (addr->address, ==, expected_addr);
 	g_assert_cmpint (addr->peer_address, ==, expected_addr);
 	g_assert_cmpint (addr->plen, ==, 8);
@@ -985,7 +987,7 @@ test_read_lease_ip4_config_expired (void)
 
 	/* Date from *after* the lease expiration */
 	now = g_date_time_new_utc (2013, 12, 1, 19, 55, 32);
-	leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", -1, contents, FALSE, now);
+	leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", IFINDEX, contents, FALSE, now);
 	g_assert (leases == NULL);
 
 	g_date_time_unref (now);
@@ -1008,7 +1010,7 @@ test_read_lease_ip4_config_expect_failure (gconstpointer user_data)
 
 	/* Date from before the least expiration */
 	now = g_date_time_new_utc (2013, 11, 1, 1, 1, 1);
-	leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", -1, contents, FALSE, now);
+	leases = nm_dhcp_dhclient_read_lease_ip_configs (multi_idx, "wlan0", IFINDEX, contents, FALSE, now);
 	g_assert (leases == NULL);
 
 	g_date_time_unref (now);
diff --git a/src/dhcp/tests/test-dhcp-utils.c b/src/dhcp/tests/test-dhcp-utils.c
index f3fa963e52..f31d7d6456 100644
--- a/src/dhcp/tests/test-dhcp-utils.c
+++ b/src/dhcp/tests/test-dhcp-utils.c
@@ -105,7 +105,7 @@ test_generic_options (void)
 
 	/* IP4 address */
 	g_assert_cmpint (nm_ip4_config_get_num_addresses (ip4_config), ==, 1);
-	address = nm_ip4_config_get_address (ip4_config, 0);
+	address = _nmtst_nm_ip4_config_get_address (ip4_config, 0);
 	g_assert (inet_pton (AF_INET, expected_addr, &tmp) > 0);
 	g_assert (address->address == tmp);
 	g_assert (address->peer_address == tmp);
@@ -175,7 +175,7 @@ test_wins_options (void)
 
 	/* IP4 address */
 	g_assert_cmpint (nm_ip4_config_get_num_addresses (ip4_config), ==, 1);
-	address = nm_ip4_config_get_address (ip4_config, 0);
+	address = _nmtst_nm_ip4_config_get_address (ip4_config, 0);
 	g_assert (address);
 	g_assert_cmpint (nm_ip4_config_get_num_wins (ip4_config), ==, 2);
 	g_assert (inet_pton (AF_INET, expected_wins1, &tmp) > 0);
@@ -624,7 +624,7 @@ test_ip4_missing_prefix (const char *ip, guint32 expected_prefix)
 	ip4_config = _ip4_config_from_options (1, "eth0", options, 0);
 
 	g_assert_cmpint (nm_ip4_config_get_num_addresses (ip4_config), ==, 1);
-	address = nm_ip4_config_get_address (ip4_config, 0);
+	address = _nmtst_nm_ip4_config_get_address (ip4_config, 0);
 	g_assert (address);
 	g_assert_cmpint (address->plen, ==, expected_prefix);
 
@@ -668,7 +668,7 @@ test_ip4_prefix_classless (void)
 	ip4_config = _ip4_config_from_options (1, "eth0", options, 0);
 
 	g_assert_cmpint (nm_ip4_config_get_num_addresses (ip4_config), ==, 1);
-	address = nm_ip4_config_get_address (ip4_config, 0);
+	address = _nmtst_nm_ip4_config_get_address (ip4_config, 0);
 	g_assert (address);
 	g_assert_cmpint (address->plen, ==, 22);
 
diff --git a/src/dns/nm-dns-dnsmasq.c b/src/dns/nm-dns-dnsmasq.c
index d5b51af25e..cb311dffda 100644
--- a/src/dns/nm-dns-dnsmasq.c
+++ b/src/dns/nm-dns-dnsmasq.c
@@ -80,21 +80,18 @@ get_ip4_rdns_domains (NMIP4Config *ip4)
 {
 	char **strv;
 	GPtrArray *domains = NULL;
-	guint i;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP4Address *address;
 	const NMPlatformIP4Route *route;
 
 	g_return_val_if_fail (ip4 != NULL, NULL);
 
 	domains = g_ptr_array_sized_new (5);
 
-	for (i = 0; i < nm_ip4_config_get_num_addresses (ip4); i++) {
-		const NMPlatformIP4Address *address = nm_ip4_config_get_address (ip4, i);
-
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, ip4, &address)
 		nm_utils_get_reverse_dns_domains_ip4 (address->address, address->plen, domains);
-	}
 
-	nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &route)
+	nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &route)
 		nm_utils_get_reverse_dns_domains_ip4 (route->network, route->plen, domains);
 
 	/* Terminating NULL so we can use g_strfreev() to free it */
@@ -111,21 +108,18 @@ get_ip6_rdns_domains (NMIP6Config *ip6)
 {
 	char **strv;
 	GPtrArray *domains = NULL;
-	guint i;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP6Address *address;
 	const NMPlatformIP6Route *route;
 
 	g_return_val_if_fail (ip6 != NULL, NULL);
 
 	domains = g_ptr_array_sized_new (5);
 
-	for (i = 0; i < nm_ip6_config_get_num_addresses (ip6); i++) {
-		const NMPlatformIP6Address *address = nm_ip6_config_get_address (ip6, i);
-
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ip6, &address)
 		nm_utils_get_reverse_dns_domains_ip6 (&address->address, address->plen, domains);
-	}
 
-	nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &route)
+	nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &route)
 		nm_utils_get_reverse_dns_domains_ip6 (&route->network, route->plen, domains);
 
 	/* Terminating NULL so we can use g_strfreev() to free it */
diff --git a/src/dnsmasq/nm-dnsmasq-manager.c b/src/dnsmasq/nm-dnsmasq-manager.c
index f76c983dcd..3296cd0e73 100644
--- a/src/dnsmasq/nm-dnsmasq-manager.c
+++ b/src/dnsmasq/nm-dnsmasq-manager.c
@@ -162,7 +162,7 @@ create_dm_cmd_line (const char *iface,
 	const NMPlatformIP4Address *listen_address;
 	guint i, n;
 
-	listen_address = nm_ip4_config_get_address (ip4_config, 0);
+	listen_address = nm_ip4_config_get_first_address (ip4_config);
 	g_return_val_if_fail (listen_address, NULL);
 
 	dm_binary = nm_utils_find_helper ("dnsmasq", DNSMASQ_PATH, error);
diff --git a/src/nm-dispatcher.c b/src/nm-dispatcher.c
index 2393e8035f..cb7bb3c5a3 100644
--- a/src/nm-dispatcher.c
+++ b/src/nm-dispatcher.c
@@ -114,6 +114,7 @@ dump_ip4_to_props (NMIP4Config *ip4, GVariantBuilder *builder)
 {
 	GVariantBuilder int_builder;
 	NMDedupMultiIter ipconf_iter;
+	gboolean first;
 	guint n, i;
 	const NMPlatformIP4Address *addr;
 	const NMPlatformIP4Route *route;
@@ -121,15 +122,15 @@ dump_ip4_to_props (NMIP4Config *ip4, GVariantBuilder *builder)
 
 	/* Addresses */
 	g_variant_builder_init (&int_builder, G_VARIANT_TYPE ("aau"));
-	n = nm_ip4_config_get_num_addresses (ip4);
-	for (i = 0; i < n; i++) {
-		addr = nm_ip4_config_get_address (ip4, i);
+	first = TRUE;
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, ip4, &addr) {
 		array[0] = addr->address;
 		array[1] = addr->plen;
-		array[2] = (i == 0) ? nm_ip4_config_get_gateway (ip4) : 0;
+		array[2] = first ? nm_ip4_config_get_gateway (ip4) : 0;
 		g_variant_builder_add (&int_builder, "@au",
 		                       g_variant_new_fixed_array (G_VARIANT_TYPE_UINT32,
 		                                                  array, 3, sizeof (guint32)));
+		first = FALSE;
 	}
 	g_variant_builder_add (builder, "{sv}",
 	                       "addresses",
@@ -164,7 +165,7 @@ dump_ip4_to_props (NMIP4Config *ip4, GVariantBuilder *builder)
 
 	/* Static routes */
 	g_variant_builder_init (&int_builder, G_VARIANT_TYPE ("aau"));
-	nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &route) {
+	nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &route) {
 		array[0] = route->network;
 		array[1] = route->plen;
 		array[2] = route->gateway;
@@ -184,24 +185,26 @@ dump_ip6_to_props (NMIP6Config *ip6, GVariantBuilder *builder)
 	GVariantBuilder int_builder;
 	NMDedupMultiIter ipconf_iter;
 	guint n, i;
+	gboolean first;
 	const NMPlatformIP6Address *addr;
-	const struct in6_addr *gw_bytes;
 	const NMPlatformIP6Route *route;
 	GVariant *ip, *gw;
 
 	/* Addresses */
 	g_variant_builder_init (&int_builder, G_VARIANT_TYPE ("a(ayuay)"));
-	n = nm_ip6_config_get_num_addresses (ip6);
-	for (i = 0; i < n; i++) {
-		addr = nm_ip6_config_get_address (ip6, i);
-		gw_bytes = nm_ip6_config_get_gateway (ip6);
+
+	first = TRUE;
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ip6, &addr) {
 		ip = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
 		                                &addr->address,
 		                                sizeof (struct in6_addr), 1);
 		gw = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
-		                                (i == 0 && gw_bytes) ? gw_bytes : &in6addr_any,
+		                                first
+		                                  ? (nm_ip6_config_get_gateway (ip6) ?: &in6addr_any)
+		                                  : &in6addr_any,
 		                                sizeof (struct in6_addr), 1);
 		g_variant_builder_add (&int_builder, "(@ayu@ay)", ip, addr->plen, gw);
+		first = FALSE;
 	}
 	g_variant_builder_add (builder, "{sv}",
 	                       "addresses",
@@ -231,7 +234,7 @@ dump_ip6_to_props (NMIP6Config *ip6, GVariantBuilder *builder)
 
 	/* Static routes */
 	g_variant_builder_init (&int_builder, G_VARIANT_TYPE ("a(ayuayu)"));
-	nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &route) {
+	nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &route) {
 		ip = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
 		                                &route->network,
 		                                sizeof (struct in6_addr), 1);
diff --git a/src/nm-ip4-config.c b/src/nm-ip4-config.c
index 3b84df2e58..7372cf2511 100644
--- a/src/nm-ip4-config.c
+++ b/src/nm-ip4-config.c
@@ -47,6 +47,22 @@ G_STATIC_ASSERT (G_MAXUINT >= 0xFFFFFFFF);
 /*****************************************************************************/
 
 gboolean
+nm_ip_config_obj_id_equal_ip4_address (const NMPlatformIP4Address *a,
+                                       const NMPlatformIP4Address *b)
+{
+	return    a->address == b->address
+	       && a->plen == b->plen
+	       && ((a->peer_address ^ b->peer_address) & nm_utils_ip4_prefix_to_netmask (a->plen)) == 0;
+}
+
+gboolean
+nm_ip_config_obj_id_equal_ip6_address (const NMPlatformIP6Address *a,
+                                       const NMPlatformIP6Address *b)
+{
+	return IN6_ARE_ADDR_EQUAL (&a->address, &b->address);
+}
+
+gboolean
 nm_ip_config_obj_id_equal_ip4_route (const NMPlatformIP4Route *r_a,
                                      const NMPlatformIP4Route *r_b)
 {
@@ -71,8 +87,15 @@ _idx_obj_id_hash (const NMDedupMultiIdxType *idx_type,
 
 	switch (NMP_OBJECT_GET_TYPE (o)) {
 	case NMP_OBJECT_TYPE_IP4_ADDRESS:
+		h = 1550630563;
+		h = NM_HASH_COMBINE (h, o->ip4_address.address);
+		h = NM_HASH_COMBINE (h, o->ip_address.plen);
+		h = NM_HASH_COMBINE (h, nm_utils_ip4_address_clear_host_address (o->ip4_address.peer_address, o->ip_address.plen));
+		break;
 	case NMP_OBJECT_TYPE_IP6_ADDRESS:
-		g_return_val_if_reached (0);
+		h = 851146661;
+		h = NM_HASH_COMBINE_IN6_ADDR (h, &o->ip6_address.address);
+		break;
 	case NMP_OBJECT_TYPE_IP4_ROUTE:
 		h = 40303327;
 		h = NM_HASH_COMBINE (h, o->ip4_route.network);
@@ -102,8 +125,9 @@ _idx_obj_id_equal (const NMDedupMultiIdxType *idx_type,
 
 	switch (NMP_OBJECT_GET_TYPE (o_a)) {
 	case NMP_OBJECT_TYPE_IP4_ADDRESS:
+		return nm_ip_config_obj_id_equal_ip4_address (NMP_OBJECT_CAST_IP4_ADDRESS (o_a), NMP_OBJECT_CAST_IP4_ADDRESS (o_b));
 	case NMP_OBJECT_TYPE_IP6_ADDRESS:
-		g_return_val_if_reached (FALSE);
+		return nm_ip_config_obj_id_equal_ip6_address (NMP_OBJECT_CAST_IP6_ADDRESS (o_a), NMP_OBJECT_CAST_IP6_ADDRESS (o_b));
 	case NMP_OBJECT_TYPE_IP4_ROUTE:
 		return nm_ip_config_obj_id_equal_ip4_route (&o_a->ip4_route, &o_b->ip4_route);
 	case NMP_OBJECT_TYPE_IP6_ROUTE:
@@ -129,6 +153,120 @@ nm_ip_config_dedup_multi_idx_type_init (NMIPConfigDedupMultiIdxType *idx_type,
 
 /*****************************************************************************/
 
+gboolean
+_nm_ip_config_add_obj (NMDedupMultiIndex *multi_idx,
+                       NMIPConfigDedupMultiIdxType *idx_type,
+                       int ifindex,
+                       const NMPObject *obj_new,
+                       const NMPlatformObject *pl_new)
+{
+	NMPObject obj_new_stackinit;
+	const NMDedupMultiEntry *entry_old;
+
+	nm_assert (multi_idx);
+	nm_assert (idx_type);
+	nm_assert (NM_IN_SET (idx_type->obj_type, NMP_OBJECT_TYPE_IP4_ADDRESS,
+	                                          NMP_OBJECT_TYPE_IP4_ROUTE,
+	                                          NMP_OBJECT_TYPE_IP6_ADDRESS,
+	                                          NMP_OBJECT_TYPE_IP6_ROUTE));
+	nm_assert (ifindex > 0);
+
+	/* we go through extra lengths to accept a full obj_new object. That one,
+	 * can be reused by increasing the ref-count. */
+	if (!obj_new) {
+		nm_assert (pl_new);
+		obj_new = nmp_object_stackinit (&obj_new_stackinit, idx_type->obj_type, pl_new);
+		obj_new_stackinit.object.ifindex = ifindex;
+	} else {
+		nm_assert (!pl_new);
+		nm_assert (NMP_OBJECT_GET_TYPE (obj_new) == idx_type->obj_type);
+		if (obj_new->object.ifindex != ifindex) {
+			obj_new = nmp_object_stackinit_obj (&obj_new_stackinit, obj_new);
+			obj_new_stackinit.object.ifindex = ifindex;
+		}
+	}
+	nm_assert (NMP_OBJECT_GET_TYPE (obj_new) == idx_type->obj_type);
+	nm_assert (nmp_object_is_alive (obj_new));
+
+	entry_old = nm_dedup_multi_index_lookup_obj (multi_idx, &idx_type->parent, obj_new);
+
+	if (entry_old) {
+		gboolean modified = FALSE;
+		const NMPObject *obj_old = entry_old->obj;
+
+		if (nmp_object_equal (obj_new, obj_old))
+			return FALSE;
+
+		switch (idx_type->obj_type) {
+		case NMP_OBJECT_TYPE_IP4_ADDRESS:
+		case NMP_OBJECT_TYPE_IP6_ADDRESS:
+			/* we want to keep the maximum addr_source. But since we expect
+			 * that usually we already add the maxiumum right away, we first try to
+			 * add the new address (replacing the old one). Only if we later
+			 * find out that addr_source is now lower, we fix it.
+			 */
+			if (obj_new->ip_address.addr_source < obj_old->ip_address.addr_source) {
+				obj_new = nmp_object_stackinit_obj (&obj_new_stackinit, obj_new);
+				obj_new_stackinit.ip_address.addr_source = obj_old->ip_address.addr_source;
+				modified = TRUE;
+			}
+
+			/* for addresses that we read from the kernel, we keep the timestamps as defined
+			 * by the previous source (item_old). The reason is, that the other source configured the lifetimes
+			 * with "what should be" and the kernel values are "what turned out after configuring it".
+			 *
+			 * For other sources, the longer lifetime wins. */
+			if (   (   obj_new->ip_address.addr_source == NM_IP_CONFIG_SOURCE_KERNEL
+			        && obj_old->ip_address.addr_source != NM_IP_CONFIG_SOURCE_KERNEL)
+			    || nm_platform_ip_address_cmp_expiry (NMP_OBJECT_CAST_IP_ADDRESS (obj_old), NMP_OBJECT_CAST_IP_ADDRESS(obj_new)) > 0) {
+				obj_new = nmp_object_stackinit_obj (&obj_new_stackinit, obj_new);
+				obj_new_stackinit.ip_address.timestamp = NMP_OBJECT_CAST_IP_ADDRESS (obj_old)->timestamp;
+				obj_new_stackinit.ip_address.lifetime  = NMP_OBJECT_CAST_IP_ADDRESS (obj_old)->lifetime;
+				obj_new_stackinit.ip_address.preferred = NMP_OBJECT_CAST_IP_ADDRESS (obj_old)->preferred;
+				modified = TRUE;
+			}
+			break;
+		case NMP_OBJECT_TYPE_IP4_ROUTE:
+		case NMP_OBJECT_TYPE_IP6_ROUTE:
+			/* we want to keep the maximum rt_source. But since we expect
+			 * that usually we already add the maxiumum right away, we first try to
+			 * add the new route (replacing the old one). Only if we later
+			 * find out that rt_source is now lower, we fix it.
+			 */
+			if (obj_new->ip_route.rt_source < obj_old->ip_route.rt_source) {
+				obj_new = nmp_object_stackinit_obj (&obj_new_stackinit, obj_new);
+				obj_new_stackinit.ip_route.rt_source = obj_old->ip_route.rt_source;
+				modified = TRUE;
+			}
+			break;
+		default:
+			nm_assert_not_reached ();
+			break;
+		}
+
+		if (   modified
+		    && nmp_object_equal (obj_new, obj_old))
+			return FALSE;
+	}
+
+	if (!nm_dedup_multi_index_add_full (multi_idx,
+	                                    &idx_type->parent,
+	                                    obj_new,
+	                                    NM_DEDUP_MULTI_IDX_MODE_APPEND,
+	                                    NULL,
+	                                    entry_old ?: NM_DEDUP_MULTI_ENTRY_MISSING,
+	                                    NULL,
+	                                    NULL,
+	                                    NULL)) {
+		nm_assert_not_reached ();
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+/*****************************************************************************/
+
 NM_GOBJECT_PROPERTIES_DEFINE (NMIP4Config,
 	PROP_MULTI_IDX,
 	PROP_IFINDEX,
@@ -156,7 +294,6 @@ typedef struct {
 	NMIPConfigSource mtu_source;
 	gint dns_priority;
 	gint64 route_metric;
-	GArray *addresses;
 	GArray *nameservers;
 	GPtrArray *domains;
 	GPtrArray *searches;
@@ -168,6 +305,10 @@ typedef struct {
 	GVariant *addresses_variant;
 	NMDedupMultiIndex *multi_idx;
 	union {
+		NMIPConfigDedupMultiIdxType idx_ip4_addresses_;
+		NMDedupMultiIdxType idx_ip4_addresses;
+	};
+	union {
 		NMIPConfigDedupMultiIdxType idx_ip4_routes_;
 		NMDedupMultiIdxType idx_ip4_routes;
 	};
@@ -188,7 +329,8 @@ G_DEFINE_TYPE (NMIP4Config, nm_ip4_config, NM_TYPE_EXPORTED_OBJECT)
 
 /*****************************************************************************/
 
-static void _add_route (NMIP4Config *self, const NMPObject *o_new, const NMPlatformIP4Route *new);
+static void _add_address (NMIP4Config *self, const NMPObject *obj_new, const NMPlatformIP4Address *new);
+static void _add_route (NMIP4Config *self, const NMPObject *obj_new, const NMPlatformIP4Route *new);
 
 /*****************************************************************************/
 
@@ -215,45 +357,60 @@ _ipv4_is_zeronet (in_addr_t network)
 
 /*****************************************************************************/
 
-static const NMDedupMultiHeadEntry *
-_idx_ip4_routes (const NMIP4Config *self)
+const NMDedupMultiHeadEntry *
+nm_ip4_config_lookup_addresses (const NMIP4Config *self)
 {
 	const NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 
 	return nm_dedup_multi_index_lookup_head (priv->multi_idx,
-	                                         &priv->idx_ip4_routes,
+	                                         &priv->idx_ip4_addresses,
 	                                         NULL);
 }
 
-static const NMPlatformIP4Route *
-_entry_iter_get_ip4_route (const CList *iter)
+void
+nm_ip_config_iter_ip4_address_init (NMDedupMultiIter *ipconf_iter, const NMIP4Config *self)
 {
-	const NMDedupMultiEntry *e = c_list_entry (iter, NMDedupMultiEntry, lst_entries);
-	const NMPObject *o = e->obj;
+	g_return_if_fail (NM_IS_IP4_CONFIG (self));
+	nm_dedup_multi_iter_init (ipconf_iter, nm_ip4_config_lookup_addresses (self));
+}
+
+/*****************************************************************************/
 
-	nm_assert (o);
-	nm_assert (NMP_OBJECT_GET_TYPE (o) == NMP_OBJECT_TYPE_IP4_ROUTE);
-	return &o->ip4_route;
+const NMDedupMultiHeadEntry *
+nm_ip4_config_lookup_routes (const NMIP4Config *self)
+{
+	const NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
+
+	return nm_dedup_multi_index_lookup_head (priv->multi_idx,
+	                                         &priv->idx_ip4_routes,
+	                                         NULL);
 }
 
 void
-nm_ip4_config_iter_ip4_route_init (NMDedupMultiIter *ipconf_iter, const NMIP4Config *self)
+nm_ip_config_iter_ip4_route_init (NMDedupMultiIter *ipconf_iter, const NMIP4Config *self)
 {
 	g_return_if_fail (NM_IS_IP4_CONFIG (self));
-	nm_dedup_multi_iter_init (ipconf_iter, _idx_ip4_routes (self));
+	nm_dedup_multi_iter_init (ipconf_iter, nm_ip4_config_lookup_routes (self));
 }
 
-gboolean
-nm_ip4_config_iter_ip4_route_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP4Route **out_route)
+/*****************************************************************************/
+
+static void
+_notify_addresses (NMIP4Config *self)
 {
-	gboolean has_next;
+	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 
-	has_next = nm_dedup_multi_iter_next (ipconf_iter);
-	if (has_next) {
-		nm_assert (NMP_OBJECT_GET_TYPE (ipconf_iter->current->obj) == NMP_OBJECT_TYPE_IP4_ROUTE);
-		NM_SET_OUT (out_route, &(((const NMPObject *) ipconf_iter->current->obj)->ip4_route));
-	}
-	return has_next;
+	nm_clear_g_variant (&priv->address_data_variant);
+	nm_clear_g_variant (&priv->addresses_variant);
+	_notify (self, PROP_ADDRESS_DATA);
+	_notify (self, PROP_ADDRESSES);
+}
+
+static void
+_notify_routes (NMIP4Config *self)
+{
+	_notify (self, PROP_ROUTE_DATA);
+	_notify (self, PROP_ROUTES);
 }
 
 /*****************************************************************************/
@@ -322,14 +479,6 @@ nm_ip4_config_capture_resolv_conf (GArray *nameservers,
 	return changed;
 }
 
-static gboolean
-addresses_are_duplicate (const NMPlatformIP4Address *a, const NMPlatformIP4Address *b)
-{
-	return    a->address == b->address
-	       && a->plen == b->plen
-	       && ((a->peer_address ^ b->peer_address) & nm_utils_ip4_prefix_to_netmask (a->plen)) == 0;
-}
-
 /*****************************************************************************/
 
 static gint
@@ -340,11 +489,12 @@ _addresses_sort_cmp_get_prio (in_addr_t addr)
 	return 1;
 }
 
-static gint
-_addresses_sort_cmp (gconstpointer a, gconstpointer b)
+static int
+_addresses_sort_cmp (gconstpointer a, gconstpointer b, gpointer user_data)
 {
 	gint p1, p2;
-	const NMPlatformIP4Address *a1 = a, *a2 = b;
+	const NMPlatformIP4Address *a1 = NMP_OBJECT_CAST_IP4_ADDRESS (*((const NMPObject **) a));
+	const NMPlatformIP4Address *a2 = NMP_OBJECT_CAST_IP4_ADDRESS (*((const NMPObject **) b));
 	guint32 n1, n2;
 
 	/* Sort by address type. For example link local will
@@ -374,21 +524,11 @@ _addresses_sort_cmp (gconstpointer a, gconstpointer b)
 
 /*****************************************************************************/
 
-static void
-notify_addresses (NMIP4Config *self)
-{
-	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
-
-	nm_clear_g_variant (&priv->address_data_variant);
-	nm_clear_g_variant (&priv->addresses_variant);
-	_notify (self, PROP_ADDRESS_DATA);
-	_notify (self, PROP_ADDRESSES);
-}
-
-static gint
-sort_captured_addresses (gconstpointer a, gconstpointer b)
+static int
+sort_captured_addresses (const CList *lst_a, const CList *lst_b, gconstpointer user_data)
 {
-	const NMPlatformIP4Address *addr_a = a, *addr_b = b;
+	const NMPlatformIP4Address *addr_a = NMP_OBJECT_CAST_IP4_ADDRESS (c_list_entry (lst_a, NMDedupMultiEntry, lst_entries)->obj);
+	const NMPlatformIP4Address *addr_b = NMP_OBJECT_CAST_IP4_ADDRESS (c_list_entry (lst_b, NMDedupMultiEntry, lst_entries)->obj);
 
 	/* Primary addresses first */
 	return NM_FLAGS_HAS (addr_a->n_ifa_flags, IFA_F_SECONDARY) -
@@ -403,9 +543,12 @@ nm_ip4_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 	guint32 lowest_metric;
 	guint32 old_gateway = 0;
 	gboolean old_has_gateway = FALSE;
-	const NMDedupMultiHeadEntry *pl_head_entry;
+	const NMDedupMultiHeadEntry *head_entry;
 	NMDedupMultiIter iter;
 	const NMPObject *plobj = NULL;
+	gboolean has_addresses = FALSE;
+
+	nm_assert (ifindex > 0);
 
 	/* Slaves have no IP configuration */
 	if (nm_platform_link_get_master (platform, ifindex) > 0)
@@ -414,15 +557,31 @@ nm_ip4_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 	self = nm_ip4_config_new (multi_idx, ifindex);
 	priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 
-	g_array_unref (priv->addresses);
-
-	priv->addresses = nm_platform_ip4_address_get_all (platform, ifindex);
-	g_array_sort (priv->addresses, sort_captured_addresses);
+	head_entry = nm_platform_lookup_addrroute (platform,
+	                                           NMP_OBJECT_TYPE_IP4_ADDRESS,
+	                                           ifindex);
+	if (head_entry) {
+		nmp_cache_iter_for_each (&iter, head_entry, &plobj) {
+			if (!nm_dedup_multi_index_add (priv->multi_idx,
+			                               &priv->idx_ip4_addresses,
+			                               plobj,
+			                               NM_DEDUP_MULTI_IDX_MODE_APPEND,
+			                               NULL,
+			                               NULL))
+				nm_assert_not_reached ();
+		}
+		head_entry = nm_ip4_config_lookup_addresses (self);
+		nm_assert (head_entry);
+		nm_dedup_multi_head_entry_sort (head_entry,
+		                                sort_captured_addresses,
+		                                NULL);
+		has_addresses = TRUE;
+	}
 
-	pl_head_entry = nm_platform_lookup_route_visible (platform,
-	                                                  NMP_OBJECT_TYPE_IP4_ROUTE,
-	                                                  ifindex,
-	                                                  FALSE);
+	head_entry = nm_platform_lookup_route_visible (platform,
+	                                               NMP_OBJECT_TYPE_IP4_ROUTE,
+	                                               ifindex,
+	                                               FALSE);
 
 	/* Extract gateway from default route */
 	old_gateway = priv->gateway;
@@ -430,7 +589,7 @@ nm_ip4_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 
 	lowest_metric = G_MAXUINT32;
 	priv->has_gateway = FALSE;
-	nmp_cache_iter_for_each (&iter, pl_head_entry, &plobj) {
+	nmp_cache_iter_for_each (&iter, head_entry, &plobj) {
 		const NMPlatformIP4Route *route = NMP_OBJECT_CAST_IP4_ROUTE (plobj);
 
 		if (   NM_PLATFORM_IP_ROUTE_IS_DEFAULT (route)
@@ -448,7 +607,7 @@ nm_ip4_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 	priv->route_metric = priv->has_gateway ? (gint64) lowest_metric : (gint64) -1;
 
 	nm_dedup_multi_iter_rewind (&iter);
-	nmp_cache_iter_for_each (&iter, pl_head_entry, &plobj) {
+	nmp_cache_iter_for_each (&iter, head_entry, &plobj) {
 		const NMPlatformIP4Route *route = NMP_OBJECT_CAST_IP4_ROUTE (plobj);
 
 		if (route->rt_source == NM_IP_CONFIG_SOURCE_RTPROT_KERNEL)
@@ -471,16 +630,14 @@ nm_ip4_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 	/* If the interface has the default route, and has IPv4 addresses, capture
 	 * nameservers from /etc/resolv.conf.
 	 */
-	if (priv->addresses->len && priv->has_gateway && capture_resolv_conf) {
+	if (has_addresses && priv->has_gateway && capture_resolv_conf) {
 		if (nm_ip4_config_capture_resolv_conf (priv->nameservers, priv->dns_options, NULL))
 			_notify (self, PROP_NAMESERVERS);
 	}
 
 	/* actually, nobody should be connected to the signal, just to be sure, notify */
-	_notify (self, PROP_ADDRESS_DATA);
-	_notify (self, PROP_ROUTE_DATA);
-	_notify (self, PROP_ADDRESSES);
-	_notify (self, PROP_ROUTES);
+	_notify_addresses (self);
+	_notify_routes (self);
 	if (   priv->gateway != old_gateway
 	    || priv->has_gateway != old_has_gateway)
 		_notify (self, PROP_GATEWAY);
@@ -491,25 +648,39 @@ nm_ip4_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 gboolean
 nm_ip4_config_commit (const NMIP4Config *self, NMPlatform *platform, NMRouteManager *route_manager, int ifindex, gboolean routes_full_sync, gint64 default_route_metric)
 {
-	const NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 	gs_unref_ptrarray GPtrArray *added_addresses = NULL;
+	gs_unref_array GArray *addresses = NULL;
+	const NMDedupMultiHeadEntry *head_entry;
 
 	g_return_val_if_fail (ifindex > 0, FALSE);
 	g_return_val_if_fail (self != NULL, FALSE);
 
 	/* Addresses */
-	nm_platform_ip4_address_sync (platform, ifindex, priv->addresses,
+	{
+		NMDedupMultiIter iter;
+
+		head_entry = nm_ip4_config_lookup_addresses (self);
+		addresses = g_array_sized_new (FALSE, FALSE,
+		                               sizeof (NMPlatformIP4Address),
+		                               head_entry ? head_entry->len : 0);
+		nm_dedup_multi_iter_for_each (&iter, head_entry) {
+			g_array_append_vals (addresses,
+			                     NMP_OBJECT_CAST_IP4_ADDRESS (iter.current->obj),
+			                     1);
+		}
+	}
+
+	nm_platform_ip4_address_sync (platform, ifindex, addresses,
 	                              default_route_metric >= 0 ? &added_addresses : NULL);
 
 	/* Routes */
 	{
-		const NMDedupMultiHeadEntry *head_entry;
 		guint i;
 		gs_unref_array GArray *routes = NULL;
 		gs_unref_array GArray *device_route_purge_list = NULL;
 		const CList *iter;
 
-		head_entry = _idx_ip4_routes (self);
+		head_entry = nm_ip4_config_lookup_routes (self);
 
 		routes = g_array_sized_new (FALSE, FALSE, sizeof (NMPlatformIP4Route), head_entry ? head_entry->len : 0);
 
@@ -555,8 +726,11 @@ nm_ip4_config_commit (const NMIP4Config *self, NMPlatform *platform, NMRouteMana
 		}
 
 		if (head_entry) {
-			c_list_for_each (iter, &head_entry->lst_entries_head)
-				g_array_append_vals (routes, _entry_iter_get_ip4_route (iter), 1);
+			c_list_for_each (iter, &head_entry->lst_entries_head) {
+				g_array_append_vals (routes,
+				                     NMP_OBJECT_CAST_IP4_ROUTE (c_list_entry (iter, NMDedupMultiEntry, lst_entries)->obj),
+				                     1);
+			}
 		}
 
 		nm_route_manager_ip4_route_register_device_route_purge_list (route_manager, device_route_purge_list);
@@ -656,7 +830,7 @@ nm_ip4_config_merge_setting (NMIP4Config *self, NMSettingIPConfig *setting, guin
 		if (label)
 			g_strlcpy (address.label, g_variant_get_string (label, NULL), sizeof (address.label));
 
-		nm_ip4_config_add_address (self, &address);
+		_add_address (self, NULL, &address);
 	}
 
 	/* Routes */
@@ -718,11 +892,12 @@ nm_ip4_config_create_setting (const NMIP4Config *self)
 {
 	NMSettingIPConfig *s_ip4;
 	guint32 gateway;
-	guint naddresses, nnameservers, nsearches, noptions;
+	guint nnameservers, nsearches, noptions;
 	const char *method = NULL;
 	int i;
 	gint64 route_metric;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP4Address *address;
 	const NMPlatformIP4Route *route;
 
 	s_ip4 = NM_SETTING_IP_CONFIG (nm_setting_ip4_config_new ());
@@ -735,15 +910,13 @@ nm_ip4_config_create_setting (const NMIP4Config *self)
 	}
 
 	gateway = nm_ip4_config_get_gateway (self);
-	naddresses = nm_ip4_config_get_num_addresses (self);
 	nnameservers = nm_ip4_config_get_num_nameservers (self);
 	nsearches = nm_ip4_config_get_num_searches (self);
 	noptions = nm_ip4_config_get_num_dns_options (self);
 	route_metric = nm_ip4_config_get_route_metric (self);
 
 	/* Addresses */
-	for (i = 0; i < naddresses; i++) {
-		const NMPlatformIP4Address *address = nm_ip4_config_get_address (self, i);
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, self, &address) {
 		NMIPAddress *s_addr;
 
 		/* Detect dynamic address */
@@ -782,7 +955,7 @@ nm_ip4_config_create_setting (const NMIP4Config *self)
 	              NULL);
 
 	/* Routes */
-	nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, self, &route) {
+	nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, self, &route) {
 		NMIPRoute *s_route;
 
 		/* Ignore default route. */
@@ -836,6 +1009,7 @@ nm_ip4_config_merge (NMIP4Config *dst, const NMIP4Config *src, NMIPConfigMergeFl
 	const NMIP4ConfigPrivate *src_priv;
 	guint32 i;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP4Address *address = NULL;
 
 	g_return_if_fail (src != NULL);
 	g_return_if_fail (dst != NULL);
@@ -846,8 +1020,8 @@ nm_ip4_config_merge (NMIP4Config *dst, const NMIP4Config *src, NMIPConfigMergeFl
 	g_object_freeze_notify (G_OBJECT (dst));
 
 	/* addresses */
-	for (i = 0; i < nm_ip4_config_get_num_addresses (src); i++)
-		nm_ip4_config_add_address (dst, nm_ip4_config_get_address (src, i));
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, src, &address)
+		_add_address (dst, NMP_OBJECT_UP_CAST (address), NULL);
 
 	/* nameservers */
 	if (!NM_FLAGS_HAS (merge_flags, NM_IP_CONFIG_MERGE_NO_DNS)) {
@@ -863,7 +1037,7 @@ nm_ip4_config_merge (NMIP4Config *dst, const NMIP4Config *src, NMIPConfigMergeFl
 	if (!NM_FLAGS_HAS (merge_flags, NM_IP_CONFIG_MERGE_NO_ROUTES)) {
 		const NMPlatformIP4Route *route;
 
-		nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, src, &route)
+		nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, src, &route)
 			_add_route (dst, NMP_OBJECT_UP_CAST (route), NULL);
 	}
 
@@ -930,21 +1104,6 @@ nm_ip4_config_merge (NMIP4Config *dst, const NMIP4Config *src, NMIPConfigMergeFl
 /*****************************************************************************/
 
 static int
-_addresses_get_index (const NMIP4Config *self, const NMPlatformIP4Address *addr)
-{
-	const NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
-	guint i;
-
-	for (i = 0; i < priv->addresses->len; i++) {
-		const NMPlatformIP4Address *a = &g_array_index (priv->addresses, NMPlatformIP4Address, i);
-
-		if (addresses_are_duplicate (addr, a))
-			return (int) i;
-	}
-	return -1;
-}
-
-static int
 _nameservers_get_index (const NMIP4Config *self, guint32 ns)
 {
 	const NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
@@ -1049,8 +1208,10 @@ nm_ip4_config_subtract (NMIP4Config *dst, const NMIP4Config *src)
 	NMIP4ConfigPrivate *priv_dst;
 	guint i;
 	gint idx;
+	const NMPlatformIP4Address *a;
 	const NMPlatformIP4Route *r;
 	NMDedupMultiIter ipconf_iter;
+	gboolean changed;
 
 	g_return_if_fail (src != NULL);
 	g_return_if_fail (dst != NULL);
@@ -1060,11 +1221,15 @@ nm_ip4_config_subtract (NMIP4Config *dst, const NMIP4Config *src)
 	g_object_freeze_notify (G_OBJECT (dst));
 
 	/* addresses */
-	for (i = 0; i < nm_ip4_config_get_num_addresses (src); i++) {
-		idx = _addresses_get_index (dst, nm_ip4_config_get_address (src, i));
-		if (idx >= 0)
-			nm_ip4_config_del_address (dst, idx);
+	changed = FALSE;
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, src, &a) {
+		if (nm_dedup_multi_index_remove_obj (priv_dst->multi_idx,
+		                                     &priv_dst->idx_ip4_addresses,
+		                                     NMP_OBJECT_UP_CAST (a)))
+			changed = TRUE;
 	}
+	if (changed)
+		_notify_addresses (dst);
 
 	/* nameservers */
 	for (i = 0; i < nm_ip4_config_get_num_nameservers (src); i++) {
@@ -1084,11 +1249,15 @@ nm_ip4_config_subtract (NMIP4Config *dst, const NMIP4Config *src)
 	/* ignore route_metric */
 
 	/* routes */
-	nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, src, &r) {
-		nm_dedup_multi_index_remove_obj (priv_dst->multi_idx,
-		                                 &priv_dst->idx_ip4_routes,
-		                                 NMP_OBJECT_UP_CAST (r));
+	changed = FALSE;
+	nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, src, &r) {
+		if (nm_dedup_multi_index_remove_obj (priv_dst->multi_idx,
+		                                     &priv_dst->idx_ip4_routes,
+		                                     NMP_OBJECT_UP_CAST (r)))
+			changed = TRUE;
 	}
+	if (changed)
+		_notify_routes (dst);
 
 	/* domains */
 	for (i = 0; i < nm_ip4_config_get_num_domains (src); i++) {
@@ -1149,9 +1318,8 @@ nm_ip4_config_intersect (NMIP4Config *dst, const NMIP4Config *src)
 {
 	NMIP4ConfigPrivate *priv_dst;
 	const NMIP4ConfigPrivate *priv_src;
-	guint i;
-	gint idx;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP4Address *a;
 	const NMPlatformIP4Route *r;
 
 	g_return_if_fail (src);
@@ -1163,12 +1331,15 @@ nm_ip4_config_intersect (NMIP4Config *dst, const NMIP4Config *src)
 	priv_src = NM_IP4_CONFIG_GET_PRIVATE (src);
 
 	/* addresses */
-	for (i = 0; i < nm_ip4_config_get_num_addresses (dst); ) {
-		idx = _addresses_get_index (src, nm_ip4_config_get_address (dst, i));
-		if (idx < 0)
-			nm_ip4_config_del_address (dst, i);
-		else
-			i++;
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, dst, &a) {
+		if (nm_dedup_multi_index_lookup_obj (priv_src->multi_idx,
+		                                     &priv_src->idx_ip4_addresses,
+		                                     NMP_OBJECT_UP_CAST (a)))
+			continue;
+
+		if (nm_dedup_multi_index_remove_entry (priv_dst->multi_idx,
+		                                       ipconf_iter.current) != 1)
+			nm_assert_not_reached ();
 	}
 
 	/* ignore route_metric */
@@ -1182,7 +1353,7 @@ nm_ip4_config_intersect (NMIP4Config *dst, const NMIP4Config *src)
 	}
 
 	/* routes */
-	nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, dst, &r) {
+	nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, dst, &r) {
 		if (nm_dedup_multi_index_lookup_obj (priv_src->multi_idx,
 		                                     &priv_src->idx_ip4_routes,
 		                                     NMP_OBJECT_UP_CAST (r)))
@@ -1227,7 +1398,6 @@ nm_ip4_config_replace (NMIP4Config *dst, const NMIP4Config *src, gboolean *relev
 	guint i, num;
 	NMIP4ConfigPrivate *dst_priv;
 	const NMIP4ConfigPrivate *src_priv;
-	const NMPlatformIP4Address *dst_addr, *src_addr;
 	NMDedupMultiIter ipconf_iter_src, ipconf_iter_dst;
 
 	g_return_val_if_fail (src != NULL, FALSE);
@@ -1271,39 +1441,60 @@ nm_ip4_config_replace (NMIP4Config *dst, const NMIP4Config *src, gboolean *relev
 	}
 
 	/* addresses */
-	num = nm_ip4_config_get_num_addresses (src);
-	are_equal = num == nm_ip4_config_get_num_addresses (dst);
-	if (are_equal) {
-		for (i = 0; i < num; i++ ) {
-			if (nm_platform_ip4_address_cmp (src_addr = nm_ip4_config_get_address (src, i),
-			                                 dst_addr = nm_ip4_config_get_address (dst, i))) {
-				are_equal = FALSE;
-				if (   !addresses_are_duplicate (src_addr, dst_addr)
-				    || src_addr->peer_address != dst_addr->peer_address) {
-					has_relevant_changes = TRUE;
-					break;
-				}
+	nm_ip_config_iter_ip4_address_init (&ipconf_iter_src, src);
+	nm_ip_config_iter_ip4_address_init (&ipconf_iter_dst, dst);
+	are_equal = TRUE;
+	while (TRUE) {
+		gboolean has;
+		const NMPlatformIP4Address *r_src = NULL;
+		const NMPlatformIP4Address *r_dst = NULL;
+
+		has = nm_ip_config_iter_ip4_address_next (&ipconf_iter_src, &r_src);
+		if (has != nm_ip_config_iter_ip4_address_next (&ipconf_iter_dst, &r_dst)) {
+			are_equal = FALSE;
+			has_relevant_changes = TRUE;
+			break;
+		}
+		if (!has)
+			break;
+
+		if (nm_platform_ip4_address_cmp (r_src, r_dst) != 0) {
+			are_equal = FALSE;
+			if (   !nm_ip_config_obj_id_equal_ip4_address (r_src, r_dst)
+			    || r_src->peer_address != r_dst->peer_address) {
+				has_relevant_changes = TRUE;
+				break;
 			}
 		}
-	} else
-		has_relevant_changes = TRUE;
+	}
 	if (!are_equal) {
-		nm_ip4_config_reset_addresses (dst);
-		for (i = 0; i < num; i++)
-			nm_ip4_config_add_address (dst, nm_ip4_config_get_address (src, i));
+		const NMPlatformIP4Address *r_src;
+
 		has_minor_changes = TRUE;
+		nm_dedup_multi_index_dirty_set_idx (dst_priv->multi_idx, &dst_priv->idx_ip4_addresses);
+		nm_dedup_multi_iter_rewind (&ipconf_iter_src);
+		while (nm_ip_config_iter_ip4_address_next (&ipconf_iter_src, &r_src)) {
+			nm_dedup_multi_index_add (dst_priv->multi_idx,
+			                          &dst_priv->idx_ip4_addresses,
+			                          NMP_OBJECT_UP_CAST (r_src),
+			                          NM_DEDUP_MULTI_IDX_MODE_APPEND_FORCE,
+			                          NULL,
+			                          NULL);
+		}
+		nm_dedup_multi_index_dirty_remove_idx (dst_priv->multi_idx, &dst_priv->idx_ip4_addresses, FALSE);
 	}
 
 	/* routes */
-	nm_ip4_config_iter_ip4_route_init (&ipconf_iter_src, src);
-	nm_ip4_config_iter_ip4_route_init (&ipconf_iter_dst, dst);
+	nm_ip_config_iter_ip4_route_init (&ipconf_iter_src, src);
+	nm_ip_config_iter_ip4_route_init (&ipconf_iter_dst, dst);
 	are_equal = TRUE;
 	while (TRUE) {
 		gboolean has;
-		const NMPlatformIP4Route *r_src, *r_dst;
+		const NMPlatformIP4Route *r_src = NULL;
+		const NMPlatformIP4Route *r_dst = NULL;
 
-		has = nm_ip4_config_iter_ip4_route_next (&ipconf_iter_src, &r_src);
-		if (has != nm_ip4_config_iter_ip4_route_next (&ipconf_iter_dst, &r_dst)) {
+		has = nm_ip_config_iter_ip4_route_next (&ipconf_iter_src, &r_src);
+		if (has != nm_ip_config_iter_ip4_route_next (&ipconf_iter_dst, &r_dst)) {
 			are_equal = FALSE;
 			has_relevant_changes = TRUE;
 			break;
@@ -1325,7 +1516,7 @@ nm_ip4_config_replace (NMIP4Config *dst, const NMIP4Config *src, gboolean *relev
 		has_minor_changes = TRUE;
 		nm_dedup_multi_index_dirty_set_idx (dst_priv->multi_idx, &dst_priv->idx_ip4_routes);
 		nm_dedup_multi_iter_rewind (&ipconf_iter_src);
-		while (nm_ip4_config_iter_ip4_route_next (&ipconf_iter_src, &r_src)) {
+		while (nm_ip_config_iter_ip4_route_next (&ipconf_iter_src, &r_src)) {
 			nm_dedup_multi_index_add (dst_priv->multi_idx,
 			                          &dst_priv->idx_ip4_routes,
 			                          NMP_OBJECT_UP_CAST (r_src),
@@ -1499,6 +1690,7 @@ nm_ip4_config_dump (const NMIP4Config *self, const char *detail)
 	guint i;
 	const char *str;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP4Address *address;
 	const NMPlatformIP4Route *route;
 
 	g_message ("--------- NMIP4Config %p (%s)", self, detail);
@@ -1513,8 +1705,8 @@ nm_ip4_config_dump (const NMIP4Config *self, const char *detail)
 		g_message ("   path: %s", str);
 
 	/* addresses */
-	for (i = 0; i < nm_ip4_config_get_num_addresses (self); i++)
-		g_message ("      a: %s", nm_platform_ip4_address_to_string (nm_ip4_config_get_address (self, i), NULL, 0));
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, self, &address)
+		g_message ("      a: %s", nm_platform_ip4_address_to_string (address, NULL, 0));
 
 	/* default gateway */
 	if (nm_ip4_config_has_gateway (self)) {
@@ -1529,7 +1721,7 @@ nm_ip4_config_dump (const NMIP4Config *self, const char *detail)
 	}
 
 	/* routes */
-	nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, self, &route)
+	nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, self, &route)
 		g_message ("     rt: %s", nm_platform_ip4_route_to_string (route, NULL, 0));
 
 	/* domains */
@@ -1570,13 +1762,11 @@ nm_ip4_config_dump (const NMIP4Config *self, const char *detail)
 gboolean
 nm_ip4_config_destination_is_direct (const NMIP4Config *self, guint32 network, guint8 plen)
 {
-	guint naddresses = nm_ip4_config_get_num_addresses (self);
-	guint i;
+	const NMPlatformIP4Address *item;
 	in_addr_t peer_network;
+	NMDedupMultiIter iter;
 
-	for (i = 0; i < naddresses; i++) {
-		const NMPlatformIP4Address *item = nm_ip4_config_get_address (self, i);
-
+	nm_ip_config_iter_ip4_address_for_each (&iter, self, &item) {
 		if (item->plen > plen)
 			continue;
 
@@ -1676,10 +1866,22 @@ nm_ip4_config_reset_addresses (NMIP4Config *self)
 {
 	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 
-	if (priv->addresses->len != 0) {
-		g_array_set_size (priv->addresses, 0);
-		notify_addresses (self);
-	}
+	if (nm_dedup_multi_index_remove_idx (priv->multi_idx,
+	                                     &priv->idx_ip4_addresses) > 0)
+		_notify_addresses (self);
+}
+
+static void
+_add_address (NMIP4Config *self, const NMPObject *obj_new, const NMPlatformIP4Address *new)
+{
+	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
+
+	if (_nm_ip_config_add_obj (priv->multi_idx,
+	                           &priv->idx_ip4_addresses_,
+	                           priv->ifindex,
+	                           obj_new,
+	                           (const NMPlatformObject *) new))
+		_notify_addresses (self);
 }
 
 /**
@@ -1695,82 +1897,81 @@ nm_ip4_config_reset_addresses (NMIP4Config *self)
 void
 nm_ip4_config_add_address (NMIP4Config *self, const NMPlatformIP4Address *new)
 {
-	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
-	NMPlatformIP4Address item_old;
-	int i;
-
-	g_return_if_fail (new != NULL);
-
-	for (i = 0; i < priv->addresses->len; i++ ) {
-		NMPlatformIP4Address *item = &g_array_index (priv->addresses, NMPlatformIP4Address, i);
-
-		if (addresses_are_duplicate (item, new)) {
-			if (nm_platform_ip4_address_cmp (item, new) == 0)
-				return;
-
-			/* remember the old values. */
-			item_old = *item;
-			/* Copy over old item to get new lifetime, timestamp, preferred */
-			*item = *new;
-
-			/* But restore highest priority source */
-			item->addr_source = MAX (item_old.addr_source, new->addr_source);
-
-			/* for addresses that we read from the kernel, we keep the timestamps as defined
-			 * by the previous source (item_old). The reason is, that the other source configured the lifetimes
-			 * with "what should be" and the kernel values are "what turned out after configuring it".
-			 *
-			 * For other sources, the longer lifetime wins. */
-			if (   (new->addr_source == NM_IP_CONFIG_SOURCE_KERNEL && new->addr_source != item_old.addr_source)
-			    || nm_platform_ip_address_cmp_expiry ((const NMPlatformIPAddress *) &item_old, (const NMPlatformIPAddress *) new) > 0) {
-				item->timestamp = item_old.timestamp;
-				item->lifetime = item_old.lifetime;
-				item->preferred = item_old.preferred;
-			}
-			if (nm_platform_ip4_address_cmp (&item_old, item) == 0)
-				return;
-			goto NOTIFY;
-		}
-	}
+	g_return_if_fail (self);
+	g_return_if_fail (new);
+	g_return_if_fail (new->plen > 0 && new->plen <= 32);
+	g_return_if_fail (NM_IP4_CONFIG_GET_PRIVATE (self)->ifindex > 0);
 
-	g_array_append_val (priv->addresses, *new);
-NOTIFY:
-	notify_addresses (self);
+	_add_address (self, NULL, new);
 }
 
 void
-nm_ip4_config_del_address (NMIP4Config *self, guint i)
+_nmtst_nm_ip4_config_del_address (NMIP4Config *self, guint i)
 {
 	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
+	const NMPlatformIP4Address *a;
 
-	g_return_if_fail (i < priv->addresses->len);
-
-	g_array_remove_index (priv->addresses, i);
+	a = _nmtst_nm_ip4_config_get_address (self, i);
+	g_return_if_fail (a);
 
-	notify_addresses (self);
+	if (nm_dedup_multi_index_remove_obj (priv->multi_idx,
+	                                     &priv->idx_ip4_addresses,
+	                                     NMP_OBJECT_UP_CAST (a)) != 1)
+		g_return_if_reached ();
+	_notify_addresses (self);
 }
 
 guint
 nm_ip4_config_get_num_addresses (const NMIP4Config *self)
 {
-	const NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
+	const NMDedupMultiHeadEntry *head_entry;
 
-	return priv->addresses->len;
+	head_entry = nm_ip4_config_lookup_addresses (self);
+	return head_entry ? head_entry->len : 0;
 }
 
 const NMPlatformIP4Address *
-nm_ip4_config_get_address (const NMIP4Config *self, guint i)
+nm_ip4_config_get_first_address (const NMIP4Config *self)
 {
-	const NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
+	NMDedupMultiIter iter;
+	const NMPlatformIP4Address *a = NULL;
 
-	return &g_array_index (priv->addresses, NMPlatformIP4Address, i);
+	nm_ip_config_iter_ip4_address_for_each (&iter, self, &a)
+		return a;
+	return NULL;
+}
+
+const NMPlatformIP4Address *
+_nmtst_nm_ip4_config_get_address (const NMIP4Config *self, guint i)
+{
+	NMDedupMultiIter iter;
+	const NMPlatformIP4Address *a = NULL;
+	guint j;
+
+	j = 0;
+	nm_ip_config_iter_ip4_address_for_each (&iter, self, &a) {
+		if (i == j)
+			return a;
+		j++;
+	}
+	g_return_val_if_reached (NULL);
 }
 
 gboolean
 nm_ip4_config_address_exists (const NMIP4Config *self,
                               const NMPlatformIP4Address *needle)
 {
-	return _addresses_get_index (self, needle) >= 0;
+	const NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
+	NMPObject obj_stack;
+
+	nmp_object_stackinit_id_ip4_address (&obj_stack,
+	                                     priv->ifindex,
+	                                     needle->address,
+	                                     needle->plen,
+	                                     needle->peer_address);
+	return !!nm_dedup_multi_index_lookup_obj (priv->multi_idx,
+	                                          &priv->idx_ip4_routes,
+	                                          &obj_stack);
 }
 
 /*****************************************************************************/
@@ -1781,81 +1982,21 @@ nm_ip4_config_reset_routes (NMIP4Config *self)
 	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 
 	if (nm_dedup_multi_index_remove_idx (priv->multi_idx,
-	                                     &priv->idx_ip4_routes) > 0) {
-		_notify (self, PROP_ROUTE_DATA);
-		_notify (self, PROP_ROUTES);
-	}
+	                                     &priv->idx_ip4_routes) > 0)
+		_notify_routes (self);
 }
 
 static void
-_add_route (NMIP4Config *self, const NMPObject *o_new, const NMPlatformIP4Route *new)
+_add_route (NMIP4Config *self, const NMPObject *obj_new, const NMPlatformIP4Route *new)
 {
-	NMIP4ConfigPrivate *priv;
-	NMPObject o_new_storage;
-	nm_auto_nmpobj const NMPObject *obj_old = NULL;
-
-	nm_assert (NM_IS_IP4_CONFIG (self));
-
-	priv = NM_IP4_CONFIG_GET_PRIVATE (self);
-
-	nm_assert (priv->ifindex > 0);
-
-	/* we go through extra lengths to accept a full o_new object. That one,
-	 * can be reused by increasing the ref-count. */
-	if (!o_new) {
-		nm_assert (new);
-		nm_assert (new->plen > 0 && new->plen <= 32);
-		nmp_object_stackinit (&o_new_storage, NMP_OBJECT_TYPE_IP4_ROUTE,
-		                      (const NMPlatformObject *) new);
-		o_new_storage.ip4_route.ifindex = priv->ifindex;
-		o_new = &o_new_storage;
-	} else {
-		nm_assert (!new);
-		nm_assert (NMP_OBJECT_GET_TYPE (o_new) == NMP_OBJECT_TYPE_IP4_ROUTE);
-		nm_assert (o_new->ip4_route.plen > 0 && o_new->ip4_route.plen <= 32);
-		if (o_new->ip4_route.ifindex != priv->ifindex) {
-			nmp_object_stackinit (&o_new_storage, NMP_OBJECT_TYPE_IP4_ROUTE, &o_new->object);
-			o_new_storage.ip4_route.ifindex = priv->ifindex;
-			o_new = &o_new_storage;
-		}
-	}
-
-	if (!nm_dedup_multi_index_add (priv->multi_idx,
-	                               &priv->idx_ip4_routes,
-	                               o_new,
-	                               NM_DEDUP_MULTI_IDX_MODE_APPEND,
-	                               NULL,
-	                               &obj_old))
-		return;
-
-	if (obj_old) {
-		NMIPConfigSource old_source;
-
-		old_source = obj_old->ip_route.rt_source;
-		/* we want to keep the maximum rt_source. But since we expect
-		 * that usually we already add the maxiumum right away, we first try to
-		 * add the new route (replacing the old one). Only if we later
-		 * find out that rt_source is now lower, we fix it.
-		 */
-		if (o_new->ip_route.rt_source < old_source) {
-			if (o_new != &o_new_storage) {
-				nmp_object_stackinit (&o_new_storage, NMP_OBJECT_TYPE_IP4_ROUTE,
-				                      &o_new->object);
-				o_new = &o_new_storage;
-			}
-			o_new_storage.ip_route.rt_source = old_source;
-			if (!nm_dedup_multi_index_add (priv->multi_idx,
-			                               &priv->idx_ip4_routes,
-			                               o_new,
-			                               NM_DEDUP_MULTI_IDX_MODE_APPEND,
-			                               NULL,
-			                               NULL))
-				nm_assert_not_reached ();
-		}
-	}
+	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 
-	_notify (self, PROP_ROUTE_DATA);
-	_notify (self, PROP_ROUTES);
+	if (_nm_ip_config_add_obj (priv->multi_idx,
+	                           &priv->idx_ip4_routes_,
+	                           priv->ifindex,
+	                           obj_new,
+	                           (const NMPlatformObject *) new))
+		_notify_routes (self);
 }
 
 /**
@@ -1892,8 +2033,7 @@ _nmtst_nm_ip4_config_del_route (NMIP4Config *self, guint i)
 	                                     &priv->idx_ip4_routes,
 	                                     NMP_OBJECT_UP_CAST (r)) != 1)
 		g_return_if_reached ();
-	_notify (self, PROP_ROUTE_DATA);
-	_notify (self, PROP_ROUTES);
+	_notify_routes (self);
 }
 
 guint
@@ -1901,7 +2041,7 @@ nm_ip4_config_get_num_routes (const NMIP4Config *self)
 {
 	const NMDedupMultiHeadEntry *head_entry;
 
-	head_entry = _idx_ip4_routes (self);
+	head_entry = nm_ip4_config_lookup_routes (self);
 	nm_assert ((head_entry ? head_entry->len : 0) == c_list_length (&head_entry->lst_entries_head));
 	return head_entry ? head_entry->len : 0;
 }
@@ -1909,18 +2049,15 @@ nm_ip4_config_get_num_routes (const NMIP4Config *self)
 const NMPlatformIP4Route *
 _nmtst_nm_ip4_config_get_route (const NMIP4Config *self, guint i)
 {
-	const NMDedupMultiHeadEntry *head_entry;
-	CList *iter;
+	NMDedupMultiIter iter;
+	const NMPlatformIP4Route *r = NULL;
 	guint j;
 
-	head_entry = _idx_ip4_routes (self);
-	if (head_entry) {
-		j = 0;
-		c_list_for_each (iter, &head_entry->lst_entries_head) {
-			if (i == j)
-				return _entry_iter_get_ip4_route (iter);
-			j++;
-		}
+	j = 0;
+	nm_ip_config_iter_ip4_route_for_each (&iter, self, &r) {
+		if (i == j)
+			return r;
+		j++;
 	}
 	g_return_val_if_reached (NULL);
 }
@@ -1934,7 +2071,7 @@ nm_ip4_config_get_direct_route_for_host (const NMIP4Config *self, guint32 host)
 
 	g_return_val_if_fail (host, NULL);
 
-	nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, self, &item) {
+	nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, self, &item) {
 		if (item->gateway != 0)
 			continue;
 
@@ -2417,6 +2554,7 @@ nm_ip4_config_hash (const NMIP4Config *self, GChecksum *sum, gboolean dns_only)
 	guint i;
 	const char *s;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP4Address *address;
 	const NMPlatformIP4Route *route;
 
 	g_return_if_fail (self);
@@ -2426,15 +2564,13 @@ nm_ip4_config_hash (const NMIP4Config *self, GChecksum *sum, gboolean dns_only)
 		hash_u32 (sum, nm_ip4_config_has_gateway (self));
 		hash_u32 (sum, nm_ip4_config_get_gateway (self));
 
-		for (i = 0; i < nm_ip4_config_get_num_addresses (self); i++) {
-			const NMPlatformIP4Address *address = nm_ip4_config_get_address (self, i);
+		nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, self, &address) {
 			hash_u32 (sum, address->address);
 			hash_u32 (sum, address->plen);
 			hash_u32 (sum, address->peer_address & nm_utils_ip4_prefix_to_netmask (address->plen));
 		}
 
-
-		nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, self, &route) {
+		nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, self, &route) {
 			hash_u32 (sum, route->network);
 			hash_u32 (sum, route->plen);
 			hash_u32 (sum, route->gateway);
@@ -2519,9 +2655,10 @@ get_property (GObject *object, guint prop_id,
 {
 	NMIP4Config *self = NM_IP4_CONFIG (object);
 	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
+	const NMDedupMultiHeadEntry *head_entry;
 	NMDedupMultiIter ipconf_iter;
 	const NMPlatformIP4Route *route;
-	GVariantBuilder array_builder, addr_builder, route_builder;
+	GVariantBuilder builder_data, builder_legacy;
 
 	switch (prop_id) {
 	case PROP_IFINDEX:
@@ -2529,24 +2666,32 @@ get_property (GObject *object, guint prop_id,
 		break;
 	case PROP_ADDRESS_DATA:
 	case PROP_ADDRESSES:
-		{
-			gs_unref_array GArray *new = NULL;
-			guint naddr, i;
+		g_return_if_fail (!!priv->address_data_variant == !!priv->addresses_variant);
 
-			g_return_if_fail (!!priv->address_data_variant == !!priv->addresses_variant);
+		if (priv->address_data_variant)
+			goto return_cached;
 
-			if (priv->address_data_variant)
-				goto return_cached;
+		g_variant_builder_init (&builder_data, G_VARIANT_TYPE ("aa{sv}"));
+		g_variant_builder_init (&builder_legacy, G_VARIANT_TYPE ("aau"));
 
-			naddr = nm_ip4_config_get_num_addresses (self);
-			new = g_array_sized_new (FALSE, FALSE, sizeof (NMPlatformIP4Address), naddr);
-			g_array_append_vals (new, priv->addresses->data, priv->addresses->len);
-			g_array_sort (new, _addresses_sort_cmp);
+		head_entry = nm_ip4_config_lookup_addresses (self);
+		if (head_entry) {
+			gs_free const NMPObject **addresses = NULL;
+			guint naddr, i;
+
+			addresses = (const NMPObject **) nm_dedup_multi_objs_to_array_head (head_entry, NULL, NULL, &naddr);
+			nm_assert (addresses && naddr);
+
+			g_qsort_with_data (addresses,
+			                   naddr,
+			                   sizeof (addresses[0]),
+			                   _addresses_sort_cmp,
+			                   NULL);
 
 			/* Build address data variant */
-			g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aa{sv}"));
 			for (i = 0; i < naddr; i++) {
-				const NMPlatformIP4Address *address = &g_array_index (new, NMPlatformIP4Address, i);
+				GVariantBuilder addr_builder;
+				const NMPlatformIP4Address *address = NMP_OBJECT_CAST_IP4_ADDRESS (addresses[i]);
 
 				g_variant_builder_init (&addr_builder, G_VARIANT_TYPE ("a{sv}"));
 				g_variant_builder_add (&addr_builder, "{sv}",
@@ -2567,37 +2712,39 @@ get_property (GObject *object, guint prop_id,
 					                       g_variant_new_string (address->label));
 				}
 
-				g_variant_builder_add (&array_builder, "a{sv}", &addr_builder);
+				g_variant_builder_add (&builder_data, "a{sv}", &addr_builder);
 			}
-			priv->address_data_variant = g_variant_ref_sink (g_variant_builder_end (&array_builder));
 
 			/* Build addresses variant */
-			g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aau"));
 			for (i = 0; i < naddr; i++) {
-				const NMPlatformIP4Address *address = &g_array_index (new, NMPlatformIP4Address, i);
+				const NMPlatformIP4Address *address = NMP_OBJECT_CAST_IP4_ADDRESS (addresses[i]);
 				guint32 dbus_addr[3];
 
 				dbus_addr[0] = address->address;
 				dbus_addr[1] = address->plen;
 				dbus_addr[2] = i == 0 ? priv->gateway : 0;
 
-				g_variant_builder_add (&array_builder, "@au",
+				g_variant_builder_add (&builder_legacy, "@au",
 				                       g_variant_new_fixed_array (G_VARIANT_TYPE_UINT32,
 				                                                  dbus_addr, 3, sizeof (guint32)));
 			}
-			priv->addresses_variant = g_variant_ref_sink (g_variant_builder_end (&array_builder));
+		}
+
+		priv->address_data_variant = g_variant_ref_sink (g_variant_builder_end (&builder_data));
+		priv->addresses_variant = g_variant_ref_sink (g_variant_builder_end (&builder_legacy));
 
 return_cached:
-			g_value_set_variant (value,
-			                     prop_id == PROP_ADDRESS_DATA ?
-			                     priv->address_data_variant :
-			                     priv->addresses_variant);
-		}
+		g_value_set_variant (value,
+		                     prop_id == PROP_ADDRESS_DATA ?
+		                     priv->address_data_variant :
+		                     priv->addresses_variant);
 		break;
 	case PROP_ROUTE_DATA:
 		{
-			g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aa{sv}"));
-			nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, self, &route) {
+			g_variant_builder_init (&builder_data, G_VARIANT_TYPE ("aa{sv}"));
+			nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, self, &route) {
+				GVariantBuilder route_builder;
+
 				g_variant_builder_init (&route_builder, G_VARIANT_TYPE ("a{sv}"));
 				g_variant_builder_add (&route_builder, "{sv}",
 				                       "dest",
@@ -2614,16 +2761,15 @@ return_cached:
 				                       "metric",
 				                       g_variant_new_uint32 (route->metric));
 
-				g_variant_builder_add (&array_builder, "a{sv}", &route_builder);
+				g_variant_builder_add (&builder_data, "a{sv}", &route_builder);
 			}
-
-			g_value_take_variant (value, g_variant_builder_end (&array_builder));
+			g_value_take_variant (value, g_variant_builder_end (&builder_data));
 		}
 		break;
 	case PROP_ROUTES:
 		{
-			g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aau"));
-			nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, self, &route) {
+			g_variant_builder_init (&builder_legacy, G_VARIANT_TYPE ("aau"));
+			nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, self, &route) {
 				guint32 dbus_route[4];
 
 				/* legacy versions of nm_ip4_route_set_prefix() in libnm-util assert that the
@@ -2636,12 +2782,12 @@ return_cached:
 				dbus_route[2] = route->gateway;
 				dbus_route[3] = route->metric;
 
-				g_variant_builder_add (&array_builder, "@au",
+				g_variant_builder_add (&builder_legacy, "@au",
 				                       g_variant_new_fixed_array (G_VARIANT_TYPE_UINT32,
 				                                                  dbus_route, 4, sizeof (guint32)));
 			}
 
-			g_value_take_variant (value, g_variant_builder_end (&array_builder));
+			g_value_take_variant (value, g_variant_builder_end (&builder_legacy));
 		}
 		break;
 	case PROP_GATEWAY:
@@ -2716,10 +2862,11 @@ nm_ip4_config_init (NMIP4Config *self)
 {
 	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 
+	nm_ip_config_dedup_multi_idx_type_init ((NMIPConfigDedupMultiIdxType *) &priv->idx_ip4_addresses,
+	                                        NMP_OBJECT_TYPE_IP4_ADDRESS);
 	nm_ip_config_dedup_multi_idx_type_init ((NMIPConfigDedupMultiIdxType *) &priv->idx_ip4_routes,
 	                                        NMP_OBJECT_TYPE_IP4_ROUTE);
 
-	priv->addresses = g_array_new (FALSE, FALSE, sizeof (NMPlatformIP4Address));
 	priv->nameservers = g_array_new (FALSE, FALSE, sizeof (guint32));
 	priv->domains = g_ptr_array_new_with_free_func (g_free);
 	priv->searches = g_ptr_array_new_with_free_func (g_free);
@@ -2745,11 +2892,11 @@ finalize (GObject *object)
 	NMIP4Config *self = NM_IP4_CONFIG (object);
 	NMIP4ConfigPrivate *priv = NM_IP4_CONFIG_GET_PRIVATE (self);
 
+	nm_dedup_multi_index_remove_idx (priv->multi_idx, &priv->idx_ip4_addresses);
 	nm_dedup_multi_index_remove_idx (priv->multi_idx, &priv->idx_ip4_routes);
 
 	nm_clear_g_variant (&priv->address_data_variant);
 	nm_clear_g_variant (&priv->addresses_variant);
-	g_array_unref (priv->addresses);
 	g_array_unref (priv->nameservers);
 	g_ptr_array_unref (priv->domains);
 	g_ptr_array_unref (priv->searches);
diff --git a/src/nm-ip4-config.h b/src/nm-ip4-config.h
index 463aa15bb4..36ee9b5e2c 100644
--- a/src/nm-ip4-config.h
+++ b/src/nm-ip4-config.h
@@ -25,6 +25,7 @@
 #include "nm-setting-ip4-config.h"
 
 #include "nm-utils/nm-dedup-multi.h"
+#include "platform/nmp-object.h"
 
 /*****************************************************************************/
 
@@ -35,19 +36,60 @@ typedef struct {
 
 void nm_ip_config_dedup_multi_idx_type_init (NMIPConfigDedupMultiIdxType *idx_type, NMPObjectType obj_type);
 
-void nm_ip4_config_iter_ip4_route_init (NMDedupMultiIter *iter, const NMIP4Config *self);
-gboolean nm_ip4_config_iter_ip4_route_next (NMDedupMultiIter *iter, const NMPlatformIP4Route **out_route);
+/*****************************************************************************/
+
+void nm_ip_config_iter_ip4_address_init (NMDedupMultiIter *iter, const NMIP4Config *self);
+void nm_ip_config_iter_ip4_route_init (NMDedupMultiIter *iter, const NMIP4Config *self);
+
+static inline gboolean
+nm_ip_config_iter_ip4_address_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP4Address **out_address)
+{
+	gboolean has_next;
+
+	has_next = nm_dedup_multi_iter_next (ipconf_iter);
+	if (has_next)
+		NM_SET_OUT (out_address, NMP_OBJECT_CAST_IP4_ADDRESS (ipconf_iter->current->obj));
+	return has_next;
+}
+
+static inline gboolean
+nm_ip_config_iter_ip4_route_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP4Route **out_route)
+{
+	gboolean has_next;
+
+	has_next = nm_dedup_multi_iter_next (ipconf_iter);
+	if (has_next)
+		NM_SET_OUT (out_route, NMP_OBJECT_CAST_IP4_ROUTE (ipconf_iter->current->obj));
+	return has_next;
+}
+
+#define nm_ip_config_iter_ip4_address_for_each(iter, self, address) \
+    for (nm_ip_config_iter_ip4_address_init ((iter), (self)); \
+         nm_ip_config_iter_ip4_address_next ((iter), (address)); \
+         )
+
+#define nm_ip_config_iter_ip4_route_for_each(iter, self, route) \
+    for (nm_ip_config_iter_ip4_route_init ((iter), (self)); \
+         nm_ip_config_iter_ip4_route_next ((iter), (route)); \
+         )
 
-#define nm_ip4_config_iter_ip4_route_for_each(iter, self, route) \
-	for (nm_ip4_config_iter_ip4_route_init ((iter), (self)); \
-	     nm_ip4_config_iter_ip4_route_next ((iter), (route)); \
-	     )
+/*****************************************************************************/
 
+gboolean nm_ip_config_obj_id_equal_ip4_address (const NMPlatformIP4Address *a,
+                                                const NMPlatformIP4Address *b);
+gboolean nm_ip_config_obj_id_equal_ip6_address (const NMPlatformIP6Address *a,
+                                                const NMPlatformIP6Address *b);
 gboolean nm_ip_config_obj_id_equal_ip4_route (const NMPlatformIP4Route *r_a,
                                               const NMPlatformIP4Route *r_b);
 gboolean nm_ip_config_obj_id_equal_ip6_route (const NMPlatformIP6Route *r_a,
                                               const NMPlatformIP6Route *r_b);
 
+gboolean _nm_ip_config_add_obj (NMDedupMultiIndex *multi_idx,
+                                NMIPConfigDedupMultiIdxType *idx_type,
+                                int ifindex,
+                                const NMPObject *obj_new,
+                                const NMPlatformObject *pl_new);
+
 /*****************************************************************************/
 
 #define NM_TYPE_IP4_CONFIG (nm_ip4_config_get_type ())
@@ -110,13 +152,16 @@ gboolean nm_ip4_config_has_gateway (const NMIP4Config *self);
 guint32 nm_ip4_config_get_gateway (const NMIP4Config *self);
 gint64 nm_ip4_config_get_route_metric (const NMIP4Config *self);
 
+const NMDedupMultiHeadEntry *nm_ip4_config_lookup_addresses (const NMIP4Config *self);
 void nm_ip4_config_reset_addresses (NMIP4Config *self);
 void nm_ip4_config_add_address (NMIP4Config *self, const NMPlatformIP4Address *address);
-void nm_ip4_config_del_address (NMIP4Config *self, guint i);
+void _nmtst_nm_ip4_config_del_address (NMIP4Config *self, guint i);
 guint nm_ip4_config_get_num_addresses (const NMIP4Config *self);
-const NMPlatformIP4Address *nm_ip4_config_get_address (const NMIP4Config *self, guint i);
+const NMPlatformIP4Address *nm_ip4_config_get_first_address (const NMIP4Config *self);
+const NMPlatformIP4Address *_nmtst_nm_ip4_config_get_address (const NMIP4Config *self, guint i);
 gboolean nm_ip4_config_address_exists (const NMIP4Config *self, const NMPlatformIP4Address *address);
 
+const NMDedupMultiHeadEntry *nm_ip4_config_lookup_routes (const NMIP4Config *self);
 void nm_ip4_config_reset_routes (NMIP4Config *self);
 void nm_ip4_config_add_route (NMIP4Config *self, const NMPlatformIP4Route *route);
 void _nmtst_nm_ip4_config_del_route (NMIP4Config *self, guint i);
diff --git a/src/nm-ip6-config.c b/src/nm-ip6-config.c
index 3745737169..fe9a4a10dd 100644
--- a/src/nm-ip6-config.c
+++ b/src/nm-ip6-config.c
@@ -49,7 +49,6 @@ typedef struct {
 	NMSettingIP6ConfigPrivacy privacy;
 	gint64 route_metric;
 	struct in6_addr gateway;
-	GArray *addresses;
 	GArray *nameservers;
 	GPtrArray *domains;
 	GPtrArray *searches;
@@ -58,6 +57,10 @@ typedef struct {
 	GVariant *addresses_variant;
 	NMDedupMultiIndex *multi_idx;
 	union {
+		NMIPConfigDedupMultiIdxType idx_ip6_addresses_;
+		NMDedupMultiIdxType idx_ip6_addresses;
+	};
+	union {
 		NMIPConfigDedupMultiIdxType idx_ip6_routes_;
 		NMDedupMultiIdxType idx_ip6_routes;
 	};
@@ -93,7 +96,8 @@ NM_GOBJECT_PROPERTIES_DEFINE (NMIP6Config,
 
 /*****************************************************************************/
 
-static void _add_route (NMIP6Config *self, const NMPObject *o_new, const NMPlatformIP6Route *new);
+static void _add_address (NMIP6Config *self, const NMPObject *obj_new, const NMPlatformIP6Address *new);
+static void _add_route (NMIP6Config *self, const NMPObject *obj_new, const NMPlatformIP6Route *new);
 
 /*****************************************************************************/
 
@@ -119,51 +123,46 @@ nm_ip6_config_set_privacy (NMIP6Config *self, NMSettingIP6ConfigPrivacy privacy)
 
 /*****************************************************************************/
 
-static const NMDedupMultiHeadEntry *
-_idx_ip6_routes (const NMIP6Config *self)
+const NMDedupMultiHeadEntry *
+nm_ip6_config_lookup_addresses (const NMIP6Config *self)
 {
 	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
 	return nm_dedup_multi_index_lookup_head (priv->multi_idx,
-	                                         &priv->idx_ip6_routes,
+	                                         &priv->idx_ip6_addresses,
 	                                         NULL);
 }
 
-static const NMPlatformIP6Route *
-_entry_iter_get_ip6_route (const CList *iter)
-{
-	const NMDedupMultiEntry *e = c_list_entry (iter, NMDedupMultiEntry, lst_entries);
-	const NMPObject *o = e->obj;
-
-	nm_assert (o);
-	nm_assert (NMP_OBJECT_GET_TYPE (o) == NMP_OBJECT_TYPE_IP6_ROUTE);
-	return &o->ip6_route;
-}
-
 void
-nm_ip6_config_iter_ip6_route_init (NMDedupMultiIter *ipconf_iter, const NMIP6Config *self)
+nm_ip_config_iter_ip6_address_init (NMDedupMultiIter *ipconf_iter, const NMIP6Config *self)
 {
 	g_return_if_fail (NM_IS_IP6_CONFIG (self));
-	nm_dedup_multi_iter_init (ipconf_iter, _idx_ip6_routes (self));
+	nm_dedup_multi_iter_init (ipconf_iter, nm_ip6_config_lookup_addresses (self));
 }
 
-gboolean
-nm_ip6_config_iter_ip6_route_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP6Route **out_route)
+/*****************************************************************************/
+
+const NMDedupMultiHeadEntry *
+nm_ip6_config_lookup_routes (const NMIP6Config *self)
 {
-	gboolean has_next;
+	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
-	has_next = nm_dedup_multi_iter_next (ipconf_iter);
-	if (has_next) {
-		nm_assert (NMP_OBJECT_GET_TYPE (ipconf_iter->current->obj) == NMP_OBJECT_TYPE_IP6_ROUTE);
-		NM_SET_OUT (out_route, &(((const NMPObject *) ipconf_iter->current->obj)->ip6_route));
-	}
-	return has_next;
+	return nm_dedup_multi_index_lookup_head (priv->multi_idx,
+	                                         &priv->idx_ip6_routes,
+	                                         NULL);
+}
+
+void
+nm_ip_config_iter_ip6_route_init (NMDedupMultiIter *ipconf_iter, const NMIP6Config *self)
+{
+	g_return_if_fail (NM_IS_IP6_CONFIG (self));
+	nm_dedup_multi_iter_init (ipconf_iter, nm_ip6_config_lookup_routes (self));
 }
 
 /*****************************************************************************/
 
 static void
-notify_addresses (NMIP6Config *self)
+_notify_addresses (NMIP6Config *self)
 {
 	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
@@ -173,6 +172,15 @@ notify_addresses (NMIP6Config *self)
 	_notify (self, PROP_ADDRESSES);
 }
 
+static void
+_notify_routes (NMIP6Config *self)
+{
+	_notify (self, PROP_ROUTE_DATA);
+	_notify (self, PROP_ROUTES);
+}
+
+/*****************************************************************************/
+
 /**
  * nm_ip6_config_capture_resolv_conf():
  * @nameservers: array of struct in6_addr
@@ -239,12 +247,6 @@ nm_ip6_config_capture_resolv_conf (GArray *nameservers,
 	return changed;
 }
 
-static gboolean
-addresses_are_duplicate (const NMPlatformIP6Address *a, const NMPlatformIP6Address *b)
-{
-	return IN6_ARE_ADDR_EQUAL (&a->address, &b->address);
-}
-
 static gint
 _addresses_sort_cmp_get_prio (const struct in6_addr *addr)
 {
@@ -263,13 +265,14 @@ _addresses_sort_cmp_get_prio (const struct in6_addr *addr)
 	return 6;
 }
 
-static gint
-_addresses_sort_cmp (gconstpointer a, gconstpointer b, gpointer user_data)
+static int
+_addresses_sort_cmp (const NMPlatformIP6Address *a1,
+                     const NMPlatformIP6Address *a2,
+                     gboolean prefer_temp)
 {
 	gint p1, p2, c;
 	gboolean perm1, perm2, tent1, tent2;
 	gboolean ipv6_privacy1, ipv6_privacy2;
-	const NMPlatformIP6Address *a1 = a, *a2 = b;
 
 	/* tentative addresses are always sorted back... */
 	/* sort tentative addresses after non-tentative. */
@@ -288,7 +291,6 @@ _addresses_sort_cmp (gconstpointer a, gconstpointer b, gpointer user_data)
 	ipv6_privacy1 = !!(a1->n_ifa_flags & (IFA_F_MANAGETEMPADDR | IFA_F_TEMPORARY));
 	ipv6_privacy2 = !!(a2->n_ifa_flags & (IFA_F_MANAGETEMPADDR | IFA_F_TEMPORARY));
 	if (ipv6_privacy1 || ipv6_privacy2) {
-		gboolean prefer_temp = ((NMSettingIP6ConfigPrivacy) GPOINTER_TO_INT (user_data)) == NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR;
 		gboolean public1 = TRUE, public2 = TRUE;
 
 		if (ipv6_privacy1) {
@@ -323,30 +325,60 @@ _addresses_sort_cmp (gconstpointer a, gconstpointer b, gpointer user_data)
 	return c != 0 ? c : memcmp (a1, a2, sizeof (*a1));
 }
 
+static int
+_addresses_sort_cmp_prop (gconstpointer a, gconstpointer b, gpointer user_data)
+{
+	return _addresses_sort_cmp (NMP_OBJECT_CAST_IP6_ADDRESS (*((const NMPObject **) a)),
+	                            NMP_OBJECT_CAST_IP6_ADDRESS (*((const NMPObject **) b)),
+	                            ((NMSettingIP6ConfigPrivacy) GPOINTER_TO_INT (user_data)) == NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR);
+}
+
+static int
+sort_captured_addresses (const CList *lst_a, const CList *lst_b, gconstpointer user_data)
+{
+	const NMPlatformIP6Address *addr_a = NMP_OBJECT_CAST_IP6_ADDRESS (c_list_entry (lst_a, NMDedupMultiEntry, lst_entries)->obj);
+	const NMPlatformIP6Address *addr_b = NMP_OBJECT_CAST_IP6_ADDRESS (c_list_entry (lst_b, NMDedupMultiEntry, lst_entries)->obj);
+
+	return _addresses_sort_cmp (addr_a, addr_b,
+	                            ((NMSettingIP6ConfigPrivacy) GPOINTER_TO_INT (user_data)) == NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR);
+}
+
 gboolean
-nm_ip6_config_addresses_sort (NMIP6Config *self)
+_nmtst_nm_ip6_config_addresses_sort (NMIP6Config *self)
 {
 	NMIP6ConfigPrivate *priv;
-	size_t data_len = 0;
-	char *data_pre = NULL;
-	gboolean changed;
+	const NMDedupMultiHeadEntry *head_entry;
 
 	g_return_val_if_fail (NM_IS_IP6_CONFIG (self), FALSE);
 
-	priv = NM_IP6_CONFIG_GET_PRIVATE (self);
-	if (priv->addresses->len > 1) {
-		data_len = priv->addresses->len * g_array_get_element_size (priv->addresses);
-		data_pre = g_new (char, data_len);
-		memcpy (data_pre, priv->addresses->data, data_len);
+	head_entry = nm_ip6_config_lookup_addresses (self);
+	if (head_entry && head_entry->len > 1) {
+		gboolean changed;
+		gs_free gconstpointer *addresses_old = NULL;
+		guint naddr, j;
+		NMDedupMultiIter iter;
+
+		priv = NM_IP6_CONFIG_GET_PRIVATE (self);
+
+		addresses_old = nm_dedup_multi_objs_to_array_head (head_entry, NULL, NULL, &naddr);
+		nm_assert (addresses_old);
+		nm_assert (naddr > 0 && naddr == head_entry->len);
 
-		g_array_sort_with_data (priv->addresses, _addresses_sort_cmp,
-		                        GINT_TO_POINTER (priv->privacy));
+		nm_dedup_multi_head_entry_sort (head_entry,
+		                                sort_captured_addresses,
+		                                GINT_TO_POINTER (priv->privacy));
 
-		changed = memcmp (data_pre, priv->addresses->data, data_len) != 0;
-		g_free (data_pre);
+		changed = FALSE;
+		j = 0;
+		nm_dedup_multi_iter_for_each (&iter, head_entry) {
+			nm_assert (j < naddr);
+			if (iter.current->obj != addresses_old[j++])
+				changed = TRUE;
+		}
+		nm_assert (j == naddr);
 
 		if (changed) {
-			notify_addresses (self);
+			_notify_addresses (self);
 			return TRUE;
 		}
 	}
@@ -361,10 +393,13 @@ nm_ip6_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 	guint32 lowest_metric = G_MAXUINT32;
 	struct in6_addr old_gateway = IN6ADDR_ANY_INIT;
 	gboolean has_gateway;
-	const NMDedupMultiHeadEntry *pl_head_entry;
+	const NMDedupMultiHeadEntry *head_entry;
 	NMDedupMultiIter iter;
 	const NMPObject *plobj = NULL;
 	gboolean notify_nameservers = FALSE;
+	gboolean has_addresses = FALSE;
+
+	nm_assert (ifindex > 0);
 
 	/* Slaves have no IP configuration */
 	if (nm_platform_link_get_master (platform, ifindex) > 0)
@@ -373,21 +408,38 @@ nm_ip6_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 	self = nm_ip6_config_new (multi_idx, ifindex);
 	priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
-	g_array_unref (priv->addresses);
-
-	priv->addresses = nm_platform_ip6_address_get_all (platform, ifindex);
+	head_entry = nm_platform_lookup_addrroute (platform,
+	                                           NMP_OBJECT_TYPE_IP6_ADDRESS,
+	                                           ifindex);
+	if (head_entry) {
+		nmp_cache_iter_for_each (&iter, head_entry, &plobj) {
+			if (!nm_dedup_multi_index_add (priv->multi_idx,
+			                               &priv->idx_ip6_addresses,
+			                               plobj,
+			                               NM_DEDUP_MULTI_IDX_MODE_APPEND,
+			                               NULL,
+			                               NULL))
+				nm_assert_not_reached ();
+			has_addresses = TRUE;
+		}
+		head_entry = nm_ip6_config_lookup_addresses (self);
+		nm_assert (head_entry);
+		nm_dedup_multi_head_entry_sort (head_entry,
+		                                sort_captured_addresses,
+		                                GINT_TO_POINTER (use_temporary));
+	}
 
-	pl_head_entry = nm_platform_lookup_route_visible (platform,
-	                                                  NMP_OBJECT_TYPE_IP6_ROUTE,
-	                                                  ifindex,
-	                                                  FALSE);
+	head_entry = nm_platform_lookup_route_visible (platform,
+	                                               NMP_OBJECT_TYPE_IP6_ROUTE,
+	                                               ifindex,
+	                                               FALSE);
 
 	/* Extract gateway from default route */
 	old_gateway = priv->gateway;
 
 	lowest_metric = G_MAXUINT32;
 	has_gateway = FALSE;
-	nmp_cache_iter_for_each (&iter, pl_head_entry, &plobj) {
+	nmp_cache_iter_for_each (&iter, head_entry, &plobj) {
 		const NMPlatformIP6Route *route = NMP_OBJECT_CAST_IP6_ROUTE (plobj);
 
 		if (   NM_PLATFORM_IP_ROUTE_IS_DEFAULT (route)
@@ -405,7 +457,7 @@ nm_ip6_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 	priv->route_metric = has_gateway ? (gint64) lowest_metric : (gint64) -1;
 
 	nm_dedup_multi_iter_rewind (&iter);
-	nmp_cache_iter_for_each (&iter, pl_head_entry, &plobj) {
+	nmp_cache_iter_for_each (&iter, head_entry, &plobj) {
 		const NMPlatformIP6Route *route = NMP_OBJECT_CAST_IP6_ROUTE (plobj);
 
 		if (route->rt_source == NM_IP_CONFIG_SOURCE_RTPROT_KERNEL)
@@ -428,20 +480,16 @@ nm_ip6_config_capture (NMDedupMultiIndex *multi_idx, NMPlatform *platform, int i
 	/* If the interface has the default route, and has IPv6 addresses, capture
 	 * nameservers from /etc/resolv.conf.
 	 */
-	if (priv->addresses->len && has_gateway && capture_resolv_conf)
+	if (has_addresses && has_gateway && capture_resolv_conf)
 		notify_nameservers = nm_ip6_config_capture_resolv_conf (priv->nameservers,
 		                                                        priv->dns_options,
 		                                                        NULL);
 
-	g_array_sort_with_data (priv->addresses, _addresses_sort_cmp, GINT_TO_POINTER (use_temporary));
-
 	/* actually, nobody should be connected to the signal, just to be sure, notify */
 	if (notify_nameservers)
 		_notify (self, PROP_NAMESERVERS);
-	_notify (self, PROP_ADDRESS_DATA);
-	_notify (self, PROP_ADDRESSES);
-	_notify (self, PROP_ROUTE_DATA);
-	_notify (self, PROP_ROUTES);
+	_notify_addresses (self);
+	_notify_routes (self);
 	if (!IN6_ARE_ADDR_EQUAL (&priv->gateway, &old_gateway))
 		_notify (self, PROP_GATEWAY);
 
@@ -455,27 +503,44 @@ nm_ip6_config_commit (const NMIP6Config *self,
                       int ifindex,
                       gboolean routes_full_sync)
 {
-	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
+	gs_unref_array GArray *addresses = NULL;
+	const NMDedupMultiHeadEntry *head_entry;
 
 	g_return_val_if_fail (ifindex > 0, FALSE);
 	g_return_val_if_fail (self != NULL, FALSE);
 
 	/* Addresses */
-	nm_platform_ip6_address_sync (platform, ifindex, priv->addresses, TRUE);
+	{
+		NMDedupMultiIter iter;
+
+		head_entry = nm_ip6_config_lookup_addresses (self);
+		addresses = g_array_sized_new (FALSE, FALSE,
+		                               sizeof (NMPlatformIP6Address),
+		                               head_entry ? head_entry->len : 0);
+		nm_dedup_multi_iter_for_each (&iter, head_entry) {
+			g_array_append_vals (addresses,
+			                     NMP_OBJECT_CAST_IP6_ADDRESS (iter.current->obj),
+			                     1);
+		}
+	}
+
+	nm_platform_ip6_address_sync (platform, ifindex, addresses, TRUE);
 
 	/* Routes */
 	{
-		const NMDedupMultiHeadEntry *head_entry;
 		gs_unref_array GArray *routes = NULL;
 		const CList *iter;
 
-		head_entry = _idx_ip6_routes (self);
+		head_entry = nm_ip6_config_lookup_routes (self);
 
 		routes = g_array_sized_new (FALSE, FALSE, sizeof (NMPlatformIP6Route), head_entry ? head_entry->len : 0);
 
 		if (head_entry) {
-			c_list_for_each (iter, &head_entry->lst_entries_head)
-				g_array_append_vals (routes, _entry_iter_get_ip6_route (iter), 1);
+			c_list_for_each (iter, &head_entry->lst_entries_head) {
+				g_array_append_vals (routes,
+				                     NMP_OBJECT_CAST_IP6_ROUTE (c_list_entry (iter, NMDedupMultiEntry, lst_entries)->obj),
+				                     1);
+			}
 		}
 
 		if (!nm_route_manager_ip6_route_sync (route_manager, ifindex, routes, TRUE, routes_full_sync))
@@ -587,7 +652,7 @@ nm_ip6_config_merge_setting (NMIP6Config *self, NMSettingIPConfig *setting, guin
 		address.preferred = NM_PLATFORM_LIFETIME_PERMANENT;
 		address.addr_source = NM_IP_CONFIG_SOURCE_USER;
 
-		nm_ip6_config_add_address (self, &address);
+		_add_address (self, NULL, &address);
 	}
 
 	/* Routes */
@@ -649,11 +714,12 @@ nm_ip6_config_create_setting (const NMIP6Config *self)
 {
 	NMSettingIPConfig *s_ip6;
 	const struct in6_addr *gateway;
-	guint naddresses, nnameservers, nsearches, noptions;
+	guint nnameservers, nsearches, noptions;
 	const char *method = NULL;
 	int i;
 	gint64 route_metric;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP6Address *address;
 	const NMPlatformIP6Route *route;
 
 	s_ip6 = NM_SETTING_IP_CONFIG (nm_setting_ip6_config_new ());
@@ -666,15 +732,13 @@ nm_ip6_config_create_setting (const NMIP6Config *self)
 	}
 
 	gateway = nm_ip6_config_get_gateway (self);
-	naddresses = nm_ip6_config_get_num_addresses (self);
 	nnameservers = nm_ip6_config_get_num_nameservers (self);
 	nsearches = nm_ip6_config_get_num_searches (self);
 	noptions = nm_ip6_config_get_num_dns_options (self);
 	route_metric = nm_ip6_config_get_route_metric (self);
 
 	/* Addresses */
-	for (i = 0; i < naddresses; i++) {
-		const NMPlatformIP6Address *address = nm_ip6_config_get_address (self, i);
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, self, &address) {
 		NMIPAddress *s_addr;
 
 		/* Ignore link-local address. */
@@ -717,7 +781,7 @@ nm_ip6_config_create_setting (const NMIP6Config *self)
 	              NULL);
 
 	/* Routes */
-	nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, self, &route) {
+	nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, self, &route) {
 		NMIPRoute *s_route;
 
 		/* Ignore link-local route. */
@@ -774,6 +838,7 @@ nm_ip6_config_merge (NMIP6Config *dst, const NMIP6Config *src, NMIPConfigMergeFl
 	const NMIP6ConfigPrivate *src_priv;
 	guint32 i;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP6Address *address = NULL;
 
 	g_return_if_fail (src != NULL);
 	g_return_if_fail (dst != NULL);
@@ -784,8 +849,8 @@ nm_ip6_config_merge (NMIP6Config *dst, const NMIP6Config *src, NMIPConfigMergeFl
 	g_object_freeze_notify (G_OBJECT (dst));
 
 	/* addresses */
-	for (i = 0; i < nm_ip6_config_get_num_addresses (src); i++)
-		nm_ip6_config_add_address (dst, nm_ip6_config_get_address (src, i));
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, src, &address)
+		_add_address (dst, NMP_OBJECT_UP_CAST (address), NULL);
 
 	/* nameservers */
 	if (!NM_FLAGS_HAS (merge_flags, NM_IP_CONFIG_MERGE_NO_DNS)) {
@@ -801,7 +866,7 @@ nm_ip6_config_merge (NMIP6Config *dst, const NMIP6Config *src, NMIPConfigMergeFl
 	if (!NM_FLAGS_HAS (merge_flags, NM_IP_CONFIG_MERGE_NO_ROUTES)) {
 		const NMPlatformIP6Route *route;
 
-		nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, src, &route)
+		nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, src, &route)
 			_add_route (dst, NMP_OBJECT_UP_CAST (route), NULL);
 	}
 
@@ -841,15 +906,13 @@ nm_ip6_config_merge (NMIP6Config *dst, const NMIP6Config *src, NMIPConfigMergeFl
 gboolean
 nm_ip6_config_destination_is_direct (const NMIP6Config *self, const struct in6_addr *network, guint8 plen)
 {
-	guint num = nm_ip6_config_get_num_addresses (self);
-	guint i;
+	const NMPlatformIP6Address *item;
+	NMDedupMultiIter iter;
 
 	nm_assert (network);
 	nm_assert (plen <= 128);
 
-	for (i = 0; i < num; i++) {
-		const NMPlatformIP6Address *item = nm_ip6_config_get_address (self, i);
-
+	nm_ip_config_iter_ip6_address_for_each (&iter, self, &item) {
 		if (   item->plen <= plen
 		    && !NM_FLAGS_HAS (item->n_ifa_flags, IFA_F_NOPREFIXROUTE)
 		    && nm_utils_ip6_address_same_prefix (&item->address, network, item->plen))
@@ -862,21 +925,6 @@ nm_ip6_config_destination_is_direct (const NMIP6Config *self, const struct in6_a
 /*****************************************************************************/
 
 static int
-_addresses_get_index (const NMIP6Config *self, const NMPlatformIP6Address *addr)
-{
-	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
-	guint i;
-
-	for (i = 0; i < priv->addresses->len; i++) {
-		const NMPlatformIP6Address *a = &g_array_index (priv->addresses, NMPlatformIP6Address, i);
-
-		if (addresses_are_duplicate (a, addr))
-			return (int) i;
-	}
-	return -1;
-}
-
-static int
 _nameservers_get_index (const NMIP6Config *self, const struct in6_addr *ns)
 {
 	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
@@ -951,9 +999,11 @@ nm_ip6_config_subtract (NMIP6Config *dst, const NMIP6Config *src)
 	NMIP6ConfigPrivate *priv_dst;
 	guint i;
 	gint idx;
+	const NMPlatformIP6Address *a;
 	const NMPlatformIP6Route *r;
 	NMDedupMultiIter ipconf_iter;
 	const struct in6_addr *dst_tmp, *src_tmp;
+	gboolean changed;
 
 	g_return_if_fail (src != NULL);
 	g_return_if_fail (dst != NULL);
@@ -963,11 +1013,15 @@ nm_ip6_config_subtract (NMIP6Config *dst, const NMIP6Config *src)
 	g_object_freeze_notify (G_OBJECT (dst));
 
 	/* addresses */
-	for (i = 0; i < nm_ip6_config_get_num_addresses (src); i++) {
-		idx = _addresses_get_index (dst, nm_ip6_config_get_address (src, i));
-		if (idx >= 0)
-			nm_ip6_config_del_address (dst, idx);
+	changed = FALSE;
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, src, &a) {
+		if (nm_dedup_multi_index_remove_obj (priv_dst->multi_idx,
+		                                     &priv_dst->idx_ip6_addresses,
+		                                     NMP_OBJECT_UP_CAST (a)))
+			changed = TRUE;
 	}
+	if (changed)
+		_notify_addresses (dst);
 
 	/* nameservers */
 	for (i = 0; i < nm_ip6_config_get_num_nameservers (src); i++) {
@@ -988,11 +1042,15 @@ nm_ip6_config_subtract (NMIP6Config *dst, const NMIP6Config *src)
 	/* ignore route_metric */
 
 	/* routes */
-	nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, src, &r) {
-		nm_dedup_multi_index_remove_obj (priv_dst->multi_idx,
-		                                 &priv_dst->idx_ip6_routes,
-		                                 NMP_OBJECT_UP_CAST (r));
+	changed = FALSE;
+	nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, src, &r) {
+		if (nm_dedup_multi_index_remove_obj (priv_dst->multi_idx,
+		                                     &priv_dst->idx_ip6_routes,
+		                                     NMP_OBJECT_UP_CAST (r)))
+			changed = TRUE;
 	}
+	if (changed)
+		_notify_routes (dst);
 
 	/* domains */
 	for (i = 0; i < nm_ip6_config_get_num_domains (src); i++) {
@@ -1030,11 +1088,11 @@ nm_ip6_config_intersect (NMIP6Config *dst, const NMIP6Config *src)
 {
 	NMIP6ConfigPrivate *priv_dst;
 	const NMIP6ConfigPrivate *priv_src;
-	guint i;
-	gint idx;
 	const struct in6_addr *dst_tmp, *src_tmp;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP6Address *a;
 	const NMPlatformIP6Route *r;
+	gboolean changed;
 
 	g_return_if_fail (src);
 	g_return_if_fail (dst);
@@ -1045,13 +1103,20 @@ nm_ip6_config_intersect (NMIP6Config *dst, const NMIP6Config *src)
 	g_object_freeze_notify (G_OBJECT (dst));
 
 	/* addresses */
-	for (i = 0; i < nm_ip6_config_get_num_addresses (dst); ) {
-		idx = _addresses_get_index (src, nm_ip6_config_get_address (dst, i));
-		if (idx < 0)
-			nm_ip6_config_del_address (dst, i);
-		else
-			i++;
+	changed = FALSE;
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, dst, &a) {
+		if (nm_dedup_multi_index_lookup_obj (priv_src->multi_idx,
+		                                     &priv_src->idx_ip6_addresses,
+		                                     NMP_OBJECT_UP_CAST (a)))
+			continue;
+
+		if (nm_dedup_multi_index_remove_entry (priv_dst->multi_idx,
+		                                       ipconf_iter.current) != 1)
+			nm_assert_not_reached ();
+		changed = TRUE;
 	}
+	if (changed)
+		_notify_addresses (dst);
 
 	/* ignore route_metric */
 	/* ignore nameservers */
@@ -1067,7 +1132,8 @@ nm_ip6_config_intersect (NMIP6Config *dst, const NMIP6Config *src)
 	}
 
 	/* routes */
-	nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, dst, &r) {
+	changed = FALSE;
+	nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, dst, &r) {
 		if (nm_dedup_multi_index_lookup_obj (priv_src->multi_idx,
 		                                     &priv_src->idx_ip6_routes,
 		                                     NMP_OBJECT_UP_CAST (r)))
@@ -1076,7 +1142,10 @@ nm_ip6_config_intersect (NMIP6Config *dst, const NMIP6Config *src)
 		if (nm_dedup_multi_index_remove_entry (priv_dst->multi_idx,
 		                                       ipconf_iter.current) != 1)
 			nm_assert_not_reached ();
+		changed = TRUE;
 	}
+	if (changed)
+		_notify_routes (dst);
 
 	/* ignore domains */
 	/* ignore dns searches */
@@ -1109,7 +1178,6 @@ nm_ip6_config_replace (NMIP6Config *dst, const NMIP6Config *src, gboolean *relev
 	guint i, num;
 	NMIP6ConfigPrivate *dst_priv;
 	const NMIP6ConfigPrivate *src_priv;
-	const NMPlatformIP6Address *dst_addr, *src_addr;
 	NMDedupMultiIter ipconf_iter_src, ipconf_iter_dst;
 
 	g_return_val_if_fail (NM_IS_IP6_CONFIG (src), FALSE);
@@ -1149,41 +1217,62 @@ nm_ip6_config_replace (NMIP6Config *dst, const NMIP6Config *src, gboolean *relev
 	}
 
 	/* addresses */
-	num = nm_ip6_config_get_num_addresses (src);
-	are_equal = num == nm_ip6_config_get_num_addresses (dst);
-	if (are_equal) {
-		for (i = 0; i < num; i++ ) {
-			if (nm_platform_ip6_address_cmp (src_addr = nm_ip6_config_get_address (src, i),
-			                                 dst_addr = nm_ip6_config_get_address (dst, i))) {
-				are_equal = FALSE;
-				if (   !addresses_are_duplicate (src_addr, dst_addr)
-				    || src_addr->plen != dst_addr->plen
-				    || !IN6_ARE_ADDR_EQUAL (nm_platform_ip6_address_get_peer (src_addr),
-				                            nm_platform_ip6_address_get_peer (dst_addr)))  {
-					has_relevant_changes = TRUE;
-					break;
-				}
+	nm_ip_config_iter_ip6_address_init (&ipconf_iter_src, src);
+	nm_ip_config_iter_ip6_address_init (&ipconf_iter_dst, dst);
+	are_equal = TRUE;
+	while (TRUE) {
+		gboolean has;
+		const NMPlatformIP6Address *r_src = NULL;
+		const NMPlatformIP6Address *r_dst = NULL;
+
+		has = nm_ip_config_iter_ip6_address_next (&ipconf_iter_src, &r_src);
+		if (has != nm_ip_config_iter_ip6_address_next (&ipconf_iter_dst, &r_dst)) {
+			are_equal = FALSE;
+			has_relevant_changes = TRUE;
+			break;
+		}
+		if (!has)
+			break;
+
+		if (nm_platform_ip6_address_cmp (r_src, r_dst) != 0) {
+			are_equal = FALSE;
+			if (   !nm_ip_config_obj_id_equal_ip6_address (r_src, r_dst)
+			    || r_src->plen != r_dst->plen
+			    || !IN6_ARE_ADDR_EQUAL (nm_platform_ip6_address_get_peer (r_src),
+			                            nm_platform_ip6_address_get_peer (r_dst))) {
+				has_relevant_changes = TRUE;
+				break;
 			}
 		}
-	} else
-		has_relevant_changes = TRUE;
+	}
 	if (!are_equal) {
-		nm_ip6_config_reset_addresses (dst);
-		for (i = 0; i < num; i++)
-			nm_ip6_config_add_address (dst, nm_ip6_config_get_address (src, i));
+		const NMPlatformIP6Address *r_src;
+
 		has_minor_changes = TRUE;
+		nm_dedup_multi_index_dirty_set_idx (dst_priv->multi_idx, &dst_priv->idx_ip6_addresses);
+		nm_dedup_multi_iter_rewind (&ipconf_iter_src);
+		while (nm_ip_config_iter_ip6_address_next (&ipconf_iter_src, &r_src)) {
+			nm_dedup_multi_index_add (dst_priv->multi_idx,
+			                          &dst_priv->idx_ip6_addresses,
+			                          NMP_OBJECT_UP_CAST (r_src),
+			                          NM_DEDUP_MULTI_IDX_MODE_APPEND_FORCE,
+			                          NULL,
+			                          NULL);
+		}
+		nm_dedup_multi_index_dirty_remove_idx (dst_priv->multi_idx, &dst_priv->idx_ip6_addresses, FALSE);
 	}
 
 	/* routes */
-	nm_ip6_config_iter_ip6_route_init (&ipconf_iter_src, src);
-	nm_ip6_config_iter_ip6_route_init (&ipconf_iter_dst, dst);
+	nm_ip_config_iter_ip6_route_init (&ipconf_iter_src, src);
+	nm_ip_config_iter_ip6_route_init (&ipconf_iter_dst, dst);
 	are_equal = TRUE;
 	while (TRUE) {
 		gboolean has;
-		const NMPlatformIP6Route *r_src, *r_dst;
+		const NMPlatformIP6Route *r_src = NULL;
+		const NMPlatformIP6Route *r_dst = NULL;
 
-		has = nm_ip6_config_iter_ip6_route_next (&ipconf_iter_src, &r_src);
-		if (has != nm_ip6_config_iter_ip6_route_next (&ipconf_iter_dst, &r_dst)) {
+		has = nm_ip_config_iter_ip6_route_next (&ipconf_iter_src, &r_src);
+		if (has != nm_ip_config_iter_ip6_route_next (&ipconf_iter_dst, &r_dst)) {
 			are_equal = FALSE;
 			has_relevant_changes = TRUE;
 			break;
@@ -1205,7 +1294,7 @@ nm_ip6_config_replace (NMIP6Config *dst, const NMIP6Config *src, gboolean *relev
 		has_minor_changes = TRUE;
 		nm_dedup_multi_index_dirty_set_idx (dst_priv->multi_idx, &dst_priv->idx_ip6_routes);
 		nm_dedup_multi_iter_rewind (&ipconf_iter_src);
-		while (nm_ip6_config_iter_ip6_route_next (&ipconf_iter_src, &r_src)) {
+		while (nm_ip_config_iter_ip6_route_next (&ipconf_iter_src, &r_src)) {
 			nm_dedup_multi_index_add (dst_priv->multi_idx,
 			                          &dst_priv->idx_ip6_routes,
 			                          NMP_OBJECT_UP_CAST (r_src),
@@ -1330,6 +1419,7 @@ nm_ip6_config_dump (const NMIP6Config *self, const char *detail)
 	guint32 i;
 	const char *str;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP6Address *address;
 	const NMPlatformIP6Route *route;
 
 	g_return_if_fail (self != NULL);
@@ -1341,8 +1431,8 @@ nm_ip6_config_dump (const NMIP6Config *self, const char *detail)
 		g_message ("   path: %s", str);
 
 	/* addresses */
-	for (i = 0; i < nm_ip6_config_get_num_addresses (self); i++)
-		g_message ("      a: %s", nm_platform_ip6_address_to_string (nm_ip6_config_get_address (self, i), NULL, 0));
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, self, &address)
+		g_message ("      a: %s", nm_platform_ip6_address_to_string (address, NULL, 0));
 
 	/* default gateway */
 	tmp = nm_ip6_config_get_gateway (self);
@@ -1356,7 +1446,7 @@ nm_ip6_config_dump (const NMIP6Config *self, const char *detail)
 	}
 
 	/* routes */
-	nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, self, &route)
+	nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, self, &route)
 		g_message ("     rt: %s", nm_platform_ip6_route_to_string (route, NULL, 0));
 
 	/* domains */
@@ -1435,10 +1525,24 @@ nm_ip6_config_reset_addresses (NMIP6Config *self)
 {
 	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
-	if (priv->addresses->len != 0) {
-		g_array_set_size (priv->addresses, 0);
-		notify_addresses (self);
-	}
+	if (nm_dedup_multi_index_remove_idx (priv->multi_idx,
+	                                     &priv->idx_ip6_addresses) > 0)
+		_notify_addresses (self);
+}
+
+static void
+_add_address (NMIP6Config *self,
+              const NMPObject *obj_new,
+              const NMPlatformIP6Address *new)
+{
+	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
+
+	if (_nm_ip_config_add_obj (priv->multi_idx,
+	                           &priv->idx_ip6_addresses_,
+	                           priv->ifindex,
+	                           obj_new,
+	                           (const NMPlatformObject *) new))
+		_notify_addresses (self);
 }
 
 /**
@@ -1454,89 +1558,91 @@ nm_ip6_config_reset_addresses (NMIP6Config *self)
 void
 nm_ip6_config_add_address (NMIP6Config *self, const NMPlatformIP6Address *new)
 {
-	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
-	NMPlatformIP6Address item_old;
-	int i;
-
-	g_return_if_fail (new != NULL);
-
-	for (i = 0; i < priv->addresses->len; i++ ) {
-		NMPlatformIP6Address *item = &g_array_index (priv->addresses, NMPlatformIP6Address, i);
-
-		if (addresses_are_duplicate (item, new)) {
-			if (nm_platform_ip6_address_cmp (item, new) == 0)
-				return;
-
-			/* remember the old values. */
-			item_old = *item;
-			/* Copy over old item to get new lifetime, timestamp, preferred */
-			*item = *new;
-
-			/* But restore highest priority source */
-			item->addr_source = MAX (item_old.addr_source, new->addr_source);
-
-			/* for addresses that we read from the kernel, we keep the timestamps as defined
-			 * by the previous source (item_old). The reason is, that the other source configured the lifetimes
-			 * with "what should be" and the kernel values are "what turned out after configuring it".
-			 *
-			 * For other sources, the longer lifetime wins. */
-			if (   (new->addr_source == NM_IP_CONFIG_SOURCE_KERNEL && new->addr_source != item_old.addr_source)
-			    || nm_platform_ip_address_cmp_expiry ((const NMPlatformIPAddress *) &item_old, (const NMPlatformIPAddress *) new) > 0) {
-				item->timestamp = item_old.timestamp;
-				item->lifetime = item_old.lifetime;
-				item->preferred = item_old.preferred;
-			}
-			if (nm_platform_ip6_address_cmp (&item_old, item) == 0)
-				return;
-			goto NOTIFY;
-		}
-	}
+	g_return_if_fail (self);
+	g_return_if_fail (new);
+	g_return_if_fail (new->plen > 0 && new->plen <= 128);
+	g_return_if_fail (NM_IP6_CONFIG_GET_PRIVATE (self)->ifindex > 0);
 
-	g_array_append_val (priv->addresses, *new);
-NOTIFY:
-notify_addresses (self);
+	_add_address (self, NULL, new);
 }
 
 void
-nm_ip6_config_del_address (NMIP6Config *self, guint i)
+_nmtst_nm_ip6_config_del_address (NMIP6Config *self, guint i)
 {
 	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
+	const NMPlatformIP6Address *a;
 
-	g_return_if_fail (i < priv->addresses->len);
+	a = _nmtst_nm_ip6_config_get_address (self, i);
+	g_return_if_fail (a);
 
-	g_array_remove_index (priv->addresses, i);
-
-	notify_addresses (self);
+	if (nm_dedup_multi_index_remove_obj (priv->multi_idx,
+	                                     &priv->idx_ip6_addresses,
+	                                     NMP_OBJECT_UP_CAST (a)) != 1)
+		g_return_if_reached ();
+	_notify_addresses (self);
 }
 
 guint
 nm_ip6_config_get_num_addresses (const NMIP6Config *self)
 {
-	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
+	const NMDedupMultiHeadEntry *head_entry;
 
-	return priv->addresses->len;
+	head_entry = nm_ip6_config_lookup_addresses (self);
+	return head_entry ? head_entry->len : 0;
 }
 
 const NMPlatformIP6Address *
-nm_ip6_config_get_address (const NMIP6Config *self, guint i)
+nm_ip6_config_get_first_address (const NMIP6Config *self)
 {
-	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
+	NMDedupMultiIter iter;
+	const NMPlatformIP6Address *a = NULL;
 
-	return &g_array_index (priv->addresses, NMPlatformIP6Address, i);
+	nm_ip_config_iter_ip6_address_for_each (&iter, self, &a)
+		return a;
+	return NULL;
 }
 
-gboolean
-nm_ip6_config_address_exists (const NMIP6Config *self,
-                              const NMPlatformIP6Address *needle)
+const NMPlatformIP6Address *
+_nmtst_nm_ip6_config_get_address (const NMIP6Config *self, guint i)
 {
-	return _addresses_get_index (self, needle) >= 0;
+	NMDedupMultiIter iter;
+	const NMPlatformIP6Address *a = NULL;
+	guint j;
+
+	j = 0;
+	nm_ip_config_iter_ip6_address_for_each (&iter, self, &a) {
+		if (i == j)
+			return a;
+		j++;
+	}
+	g_return_val_if_reached (NULL);
+}
+
+const NMPlatformIP6Address *
+nm_ip6_config_lookup_address (const NMIP6Config *self,
+                              const struct in6_addr *addr)
+{
+	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
+	NMPObject obj_stack;
+	const NMDedupMultiEntry *entry;
+
+	nmp_object_stackinit_id_ip6_address (&obj_stack,
+	                                     priv->ifindex,
+	                                     addr);
+	entry = nm_dedup_multi_index_lookup_obj (priv->multi_idx,
+	                                         &priv->idx_ip6_routes,
+	                                         &obj_stack);
+	return entry
+	       ? NMP_OBJECT_CAST_IP6_ADDRESS (entry->obj)
+	       : NULL;
 }
 
 const NMPlatformIP6Address *
 nm_ip6_config_get_address_first_nontentative (const NMIP6Config *self, gboolean linklocal)
 {
 	const NMIP6ConfigPrivate *priv;
-	guint i;
+	const NMPlatformIP6Address *addr;
+	NMDedupMultiIter iter;
 
 	g_return_val_if_fail (NM_IS_IP6_CONFIG (self), NULL);
 
@@ -1544,9 +1650,7 @@ nm_ip6_config_get_address_first_nontentative (const NMIP6Config *self, gboolean
 
 	linklocal = !!linklocal;
 
-	for (i = 0; i < priv->addresses->len; i++) {
-		const NMPlatformIP6Address *addr = &g_array_index (priv->addresses, NMPlatformIP6Address, i);
-
+	nm_ip_config_iter_ip6_address_for_each (&iter, self, &addr) {
 		if (   ((!!IN6_IS_ADDR_LINKLOCAL (&addr->address)) == linklocal)
 		    && !(addr->n_ifa_flags & IFA_F_TENTATIVE))
 			return addr;
@@ -1571,23 +1675,16 @@ gboolean
 nm_ip6_config_has_any_dad_pending (const NMIP6Config *self,
                                    const NMIP6Config *candidates)
 {
+	NMDedupMultiIter ipconf_iter;
 	const NMPlatformIP6Address *addr, *addr_c;
-	guint i, j, num, num_c;
-
-	num = nm_ip6_config_get_num_addresses (self);
 
-	for (i = 0; i < num; i++) {
-		addr = nm_ip6_config_get_address (self, i);
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, self, &addr) {
 		if (   NM_FLAGS_HAS (addr->n_ifa_flags, IFA_F_TENTATIVE)
 		    && !NM_FLAGS_HAS (addr->n_ifa_flags, IFA_F_DADFAILED)
 		    && !NM_FLAGS_HAS (addr->n_ifa_flags, IFA_F_OPTIMISTIC)) {
-
-			num_c = nm_ip6_config_get_num_addresses (candidates);
-
-			for (j = 0; j < num_c; j++) {
-				addr_c = nm_ip6_config_get_address (candidates, j);
-				if (   addresses_are_duplicate (addr, addr_c)
-				    && addr->plen == addr_c->plen)
+			addr_c = nm_ip6_config_lookup_address (candidates, &addr->address);
+			if (addr_c) {
+				if (addr->plen == addr_c->plen)
 					return TRUE;
 			}
 		}
@@ -1604,81 +1701,21 @@ nm_ip6_config_reset_routes (NMIP6Config *self)
 	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
 	if (nm_dedup_multi_index_remove_idx (priv->multi_idx,
-	                                     &priv->idx_ip6_routes) > 0) {
-		_notify (self, PROP_ROUTE_DATA);
-		_notify (self, PROP_ROUTES);
-	}
+	                                     &priv->idx_ip6_routes) > 0)
+		_notify_routes (self);
 }
 
 static void
-_add_route (NMIP6Config *self, const NMPObject *o_new, const NMPlatformIP6Route *new)
+_add_route (NMIP6Config *self, const NMPObject *obj_new, const NMPlatformIP6Route *new)
 {
-	NMIP6ConfigPrivate *priv;
-	NMPObject o_new_storage;
-	nm_auto_nmpobj const NMPObject *obj_old = NULL;
-
-	nm_assert (NM_IS_IP6_CONFIG (self));
-
-	priv = NM_IP6_CONFIG_GET_PRIVATE (self);
-
-	nm_assert (priv->ifindex > 0);
-
-	/* we go through extra lengths to accept a full o_new object. That one,
-	 * can be reused by increasing the ref-count. */
-	if (!o_new) {
-		nm_assert (new);
-		nm_assert (new->plen > 0 && new->plen <= 128);
-		nmp_object_stackinit (&o_new_storage, NMP_OBJECT_TYPE_IP6_ROUTE,
-		                      (const NMPlatformObject *) new);
-		o_new_storage.ip6_route.ifindex = priv->ifindex;
-		o_new = &o_new_storage;
-	} else {
-		nm_assert (!new);
-		nm_assert (NMP_OBJECT_GET_TYPE (o_new) == NMP_OBJECT_TYPE_IP6_ROUTE);
-		nm_assert (o_new->ip6_route.plen > 0 && o_new->ip6_route.plen <= 128);
-		if (o_new->ip6_route.ifindex != priv->ifindex) {
-			nmp_object_stackinit (&o_new_storage, NMP_OBJECT_TYPE_IP6_ROUTE, &o_new->object);
-			o_new_storage.ip6_route.ifindex = priv->ifindex;
-			o_new = &o_new_storage;
-		}
-	}
-
-	if (!nm_dedup_multi_index_add (priv->multi_idx,
-	                               &priv->idx_ip6_routes,
-	                               o_new,
-	                               NM_DEDUP_MULTI_IDX_MODE_APPEND,
-	                               NULL,
-	                               &obj_old))
-		return;
-
-	if (obj_old) {
-		NMIPConfigSource old_source;
-
-		old_source = obj_old->ip_route.rt_source;
-		/* we want to keep the maximum rt_source. But since we expect
-		 * that usually we already add the maxiumum right away, we first try to
-		 * add the new route (replacing the old one). Only if we later
-		 * find out that rt_source is now lower, we fix it.
-		 */
-		if (o_new->ip_route.rt_source < old_source) {
-			if (o_new != &o_new_storage) {
-				nmp_object_stackinit (&o_new_storage, NMP_OBJECT_TYPE_IP6_ROUTE,
-				                      &o_new->object);
-				o_new = &o_new_storage;
-			}
-			o_new_storage.ip_route.rt_source = old_source;
-			if (!nm_dedup_multi_index_add (priv->multi_idx,
-			                               &priv->idx_ip6_routes,
-			                               o_new,
-			                               NM_DEDUP_MULTI_IDX_MODE_APPEND,
-			                               NULL,
-			                               NULL))
-				nm_assert_not_reached ();
-		}
-	}
+	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
-	_notify (self, PROP_ROUTE_DATA);
-	_notify (self, PROP_ROUTES);
+	if (_nm_ip_config_add_obj (priv->multi_idx,
+	                           &priv->idx_ip6_routes_,
+	                           priv->ifindex,
+	                           obj_new,
+	                           (const NMPlatformObject *) new))
+		_notify_routes (self);
 }
 
 /**
@@ -1715,8 +1752,7 @@ _nmtst_ip6_config_del_route (NMIP6Config *self, guint i)
 	                                     &priv->idx_ip6_routes,
 	                                     NMP_OBJECT_UP_CAST (r)) != 1)
 		g_return_if_reached ();
-	_notify (self, PROP_ROUTE_DATA);
-	_notify (self, PROP_ROUTES);
+	_notify_routes (self);
 }
 
 guint
@@ -1724,7 +1760,7 @@ nm_ip6_config_get_num_routes (const NMIP6Config *self)
 {
 	const NMDedupMultiHeadEntry *head_entry;
 
-	head_entry = _idx_ip6_routes (self);
+	head_entry = nm_ip6_config_lookup_routes (self);
 	nm_assert ((head_entry ? head_entry->len : 0) == c_list_length (&head_entry->lst_entries_head));
 	return head_entry ? head_entry->len : 0;
 }
@@ -1732,18 +1768,15 @@ nm_ip6_config_get_num_routes (const NMIP6Config *self)
 const NMPlatformIP6Route *
 _nmtst_ip6_config_get_route (const NMIP6Config *self, guint i)
 {
-	const NMDedupMultiHeadEntry *head_entry;
-	CList *iter;
+	NMDedupMultiIter iter;
+	const NMPlatformIP6Route *r = NULL;
 	guint j;
 
-	head_entry = _idx_ip6_routes (self);
-	if (head_entry) {
-		j = 0;
-		c_list_for_each (iter, &head_entry->lst_entries_head) {
-			if (i == j)
-				return _entry_iter_get_ip6_route (iter);
-			j++;
-		}
+	j = 0;
+	nm_ip_config_iter_ip6_route_for_each (&iter, self, &r) {
+		if (i == j)
+			return r;
+		j++;
 	}
 	g_return_val_if_reached (NULL);
 }
@@ -1757,7 +1790,7 @@ nm_ip6_config_get_direct_route_for_host (const NMIP6Config *self, const struct i
 
 	g_return_val_if_fail (host && !IN6_IS_ADDR_UNSPECIFIED (host), NULL);
 
-	nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, self, &item) {
+	nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, self, &item) {
 		if (!IN6_IS_ADDR_UNSPECIFIED (&item->gateway))
 			continue;
 
@@ -1779,16 +1812,14 @@ nm_ip6_config_get_direct_route_for_host (const NMIP6Config *self, const struct i
 const NMPlatformIP6Address *
 nm_ip6_config_get_subnet_for_host (const NMIP6Config *self, const struct in6_addr *host)
 {
-	const NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
-	guint i;
-	NMPlatformIP6Address *subnet = NULL;
+	NMDedupMultiIter iter;
+	const NMPlatformIP6Address *item;
+	const NMPlatformIP6Address *subnet = NULL;
 	struct in6_addr subnet2, host2;
 
 	g_return_val_if_fail (host && !IN6_IS_ADDR_UNSPECIFIED (host), NULL);
 
-	for (i = 0; i < priv->addresses->len; i++) {
-		NMPlatformIP6Address *item = &g_array_index (priv->addresses, NMPlatformIP6Address, i);
-
+	nm_ip_config_iter_ip6_address_for_each (&iter, self, &item) {
 		if (subnet && subnet->plen >= item->plen)
 			continue;
 
@@ -2107,6 +2138,7 @@ nm_ip6_config_hash (const NMIP6Config *self, GChecksum *sum, gboolean dns_only)
 	guint32 i;
 	const char *s;
 	NMDedupMultiIter ipconf_iter;
+	const NMPlatformIP6Address *address;
 	const NMPlatformIP6Route *route;
 
 	g_return_if_fail (self);
@@ -2115,14 +2147,12 @@ nm_ip6_config_hash (const NMIP6Config *self, GChecksum *sum, gboolean dns_only)
 	if (dns_only == FALSE) {
 		hash_in6addr (sum, nm_ip6_config_get_gateway (self));
 
-		for (i = 0; i < nm_ip6_config_get_num_addresses (self); i++) {
-			const NMPlatformIP6Address *address = nm_ip6_config_get_address (self, i);
-
+		nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, self, &address) {
 			hash_in6addr (sum, &address->address);
 			hash_u32 (sum, address->plen);
 		}
 
-		nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, self, &route) {
+		nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, self, &route) {
 			hash_in6addr (sum, &route->network);
 			hash_u32 (sum, route->plen);
 			hash_in6addr (sum, &route->gateway);
@@ -2217,9 +2247,10 @@ get_property (GObject *object, guint prop_id,
 {
 	NMIP6Config *self = NM_IP6_CONFIG (object);
 	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
+	const NMDedupMultiHeadEntry *head_entry;
 	NMDedupMultiIter ipconf_iter;
 	const NMPlatformIP6Route *route;
-	GVariantBuilder array_builder, addr_builder, route_builder;
+	GVariantBuilder builder_data, builder_legacy;
 
 	switch (prop_id) {
 	case PROP_IFINDEX:
@@ -2227,26 +2258,31 @@ get_property (GObject *object, guint prop_id,
 		break;
 	case PROP_ADDRESS_DATA:
 	case PROP_ADDRESSES:
-		{
-			gs_unref_array GArray *new = NULL;
-			const struct in6_addr *gateway;
-			guint naddr, i;
+		g_return_if_fail (!!priv->address_data_variant == !!priv->addresses_variant);
 
-			g_return_if_fail (!!priv->address_data_variant == !!priv->addresses_variant);
+		if (priv->address_data_variant)
+			goto return_cached;
 
-			if (priv->address_data_variant)
-				goto return_cached;
+		g_variant_builder_init (&builder_data, G_VARIANT_TYPE ("aa{sv}"));
+		g_variant_builder_init (&builder_legacy, G_VARIANT_TYPE ("a(ayuay)"));
 
-			naddr = nm_ip6_config_get_num_addresses (self);
-			gateway = nm_ip6_config_get_gateway (self);
-			new = g_array_sized_new (FALSE, FALSE, sizeof (NMPlatformIP6Address), naddr);
-			g_array_append_vals (new, priv->addresses->data, naddr);
-			g_array_sort_with_data (new, _addresses_sort_cmp,
-			                        GINT_TO_POINTER (priv->privacy));
+		head_entry = nm_ip6_config_lookup_addresses (self);
+		if (head_entry) {
+			gs_free const NMPObject **addresses = NULL;
+			guint naddr, i;
+
+			addresses = (const NMPObject **) nm_dedup_multi_objs_to_array_head (head_entry, NULL, NULL, &naddr);
+			nm_assert (addresses && naddr);
+
+			g_qsort_with_data (addresses,
+			                   naddr,
+			                   sizeof (addresses[0]),
+			                   _addresses_sort_cmp_prop,
+			                   GINT_TO_POINTER (priv->privacy));
 
-			g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aa{sv}"));
 			for (i = 0; i < naddr; i++) {
-				const NMPlatformIP6Address *address = &g_array_index (new, NMPlatformIP6Address, i);
+				GVariantBuilder addr_builder;
+				const NMPlatformIP6Address *address = NMP_OBJECT_CAST_IP6_ADDRESS (addresses[i]);
 
 				g_variant_builder_init (&addr_builder, G_VARIANT_TYPE ("a{sv}"));
 				g_variant_builder_add (&addr_builder, "{sv}",
@@ -2262,35 +2298,38 @@ get_property (GObject *object, guint prop_id,
 					                       g_variant_new_string (nm_utils_inet6_ntop (&address->peer_address, NULL)));
 				}
 
-				g_variant_builder_add (&array_builder, "a{sv}", &addr_builder);
+				g_variant_builder_add (&builder_data, "a{sv}", &addr_builder);
 			}
-			priv->address_data_variant = g_variant_ref_sink (g_variant_builder_end (&array_builder));
 
-			g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("a(ayuay)"));
 			for (i = 0; i < naddr; i++) {
-				const NMPlatformIP6Address *address = &g_array_index (new, NMPlatformIP6Address, i);
+				const NMPlatformIP6Address *address = NMP_OBJECT_CAST_IP6_ADDRESS (addresses[i]);
 
-				g_variant_builder_add (&array_builder, "(@ayu@ay)",
+				g_variant_builder_add (&builder_legacy, "(@ayu@ay)",
 				                       g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
 				                                                  &address->address, 16, 1),
 				                       address->plen,
 				                       g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
-				                                                  (i == 0 && gateway ? gateway : &in6addr_any),
+				                                                  i == 0
+				                                                    ? (nm_ip6_config_get_gateway (self) ?: &in6addr_any)
+				                                                    : &in6addr_any,
 				                                                  16, 1));
 			}
+		}
 
-			priv->addresses_variant = g_variant_ref_sink (g_variant_builder_end (&array_builder));
+		priv->address_data_variant = g_variant_ref_sink (g_variant_builder_end (&builder_data));
+		priv->addresses_variant = g_variant_ref_sink (g_variant_builder_end (&builder_legacy));
 return_cached:
-			g_value_set_variant (value,
-			                     prop_id == PROP_ADDRESS_DATA ?
-			                     priv->address_data_variant :
-			                     priv->addresses_variant);
-		}
+		g_value_set_variant (value,
+		                     prop_id == PROP_ADDRESS_DATA ?
+		                     priv->address_data_variant :
+		                     priv->addresses_variant);
 		break;
 	case PROP_ROUTE_DATA:
 		{
-			g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aa{sv}"));
-			nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, self, &route) {
+			g_variant_builder_init (&builder_data, G_VARIANT_TYPE ("aa{sv}"));
+			nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, self, &route) {
+				GVariantBuilder route_builder;
+
 				g_variant_builder_init (&route_builder, G_VARIANT_TYPE ("a{sv}"));
 				g_variant_builder_add (&route_builder, "{sv}",
 				                       "dest",
@@ -2308,22 +2347,22 @@ return_cached:
 				                       "metric",
 				                       g_variant_new_uint32 (route->metric));
 
-				g_variant_builder_add (&array_builder, "a{sv}", &route_builder);
+				g_variant_builder_add (&builder_data, "a{sv}", &route_builder);
 			}
 
-			g_value_take_variant (value, g_variant_builder_end (&array_builder));
+			g_value_take_variant (value, g_variant_builder_end (&builder_data));
 		}
 		break;
 	case PROP_ROUTES:
 		{
-			g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("a(ayuayu)"));
-			nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, self, &route) {
+			g_variant_builder_init (&builder_legacy, G_VARIANT_TYPE ("a(ayuayu)"));
+			nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, self, &route) {
 				/* legacy versions of nm_ip6_route_set_prefix() in libnm-util assert that the
 				 * plen is positive. Skip the default routes not to break older clients. */
 				if (NM_PLATFORM_IP_ROUTE_IS_DEFAULT (route))
 					continue;
 
-				g_variant_builder_add (&array_builder, "(@ayu@ayu)",
+				g_variant_builder_add (&builder_legacy, "(@ayu@ayu)",
 				                       g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
 				                                                  &route->network, 16, 1),
 				                       (guint32) route->plen,
@@ -2332,7 +2371,7 @@ return_cached:
 				                       (guint32) route->metric);
 			}
 
-			g_value_take_variant (value, g_variant_builder_end (&array_builder));
+			g_value_take_variant (value, g_variant_builder_end (&builder_legacy));
 		}
 		break;
 	case PROP_GATEWAY:
@@ -2396,10 +2435,11 @@ nm_ip6_config_init (NMIP6Config *self)
 {
 	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
+	nm_ip_config_dedup_multi_idx_type_init ((NMIPConfigDedupMultiIdxType *) &priv->idx_ip6_addresses,
+	                                        NMP_OBJECT_TYPE_IP6_ADDRESS);
 	nm_ip_config_dedup_multi_idx_type_init ((NMIPConfigDedupMultiIdxType *) &priv->idx_ip6_routes,
 	                                        NMP_OBJECT_TYPE_IP6_ROUTE);
 
-	priv->addresses = g_array_new (FALSE, TRUE, sizeof (NMPlatformIP6Address));
 	priv->nameservers = g_array_new (FALSE, TRUE, sizeof (struct in6_addr));
 	priv->domains = g_ptr_array_new_with_free_func (g_free);
 	priv->searches = g_ptr_array_new_with_free_func (g_free);
@@ -2436,9 +2476,9 @@ finalize (GObject *object)
 	NMIP6Config *self = NM_IP6_CONFIG (object);
 	NMIP6ConfigPrivate *priv = NM_IP6_CONFIG_GET_PRIVATE (self);
 
+	nm_dedup_multi_index_remove_idx (priv->multi_idx, &priv->idx_ip6_addresses);
 	nm_dedup_multi_index_remove_idx (priv->multi_idx, &priv->idx_ip6_routes);
 
-	g_array_unref (priv->addresses);
 	g_array_unref (priv->nameservers);
 	g_ptr_array_unref (priv->domains);
 	g_ptr_array_unref (priv->searches);
diff --git a/src/nm-ip6-config.h b/src/nm-ip6-config.h
index e63b468484..3b14178df0 100644
--- a/src/nm-ip6-config.h
+++ b/src/nm-ip6-config.h
@@ -27,15 +27,43 @@
 #include "nm-setting-ip6-config.h"
 
 #include "nm-utils/nm-dedup-multi.h"
+#include "platform/nmp-object.h"
 
 /*****************************************************************************/
 
-void nm_ip6_config_iter_ip6_route_init (NMDedupMultiIter *iter, const NMIP6Config *self);
-gboolean nm_ip6_config_iter_ip6_route_next (NMDedupMultiIter *iter, const NMPlatformIP6Route **out_route);
+void nm_ip_config_iter_ip6_address_init (NMDedupMultiIter *iter, const NMIP6Config *self);
+void nm_ip_config_iter_ip6_route_init (NMDedupMultiIter *iter, const NMIP6Config *self);
+
+static inline gboolean
+nm_ip_config_iter_ip6_address_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP6Address **out_address)
+{
+	gboolean has_next;
+
+	has_next = nm_dedup_multi_iter_next (ipconf_iter);
+	if (has_next)
+		NM_SET_OUT (out_address, NMP_OBJECT_CAST_IP6_ADDRESS (ipconf_iter->current->obj));
+	return has_next;
+}
+
+static inline gboolean
+nm_ip_config_iter_ip6_route_next (NMDedupMultiIter *ipconf_iter, const NMPlatformIP6Route **out_route)
+{
+	gboolean has_next;
+
+	has_next = nm_dedup_multi_iter_next (ipconf_iter);
+	if (has_next)
+		NM_SET_OUT (out_route, NMP_OBJECT_CAST_IP6_ROUTE (ipconf_iter->current->obj));
+	return has_next;
+}
+
+#define nm_ip_config_iter_ip6_address_for_each(iter, self, address) \
+    for (nm_ip_config_iter_ip6_address_init ((iter), (self)); \
+         nm_ip_config_iter_ip6_address_next ((iter), (address)); \
+         )
 
-#define nm_ip6_config_iter_ip6_route_for_each(iter, self, route) \
-    for (nm_ip6_config_iter_ip6_route_init ((iter), (self)); \
-         nm_ip6_config_iter_ip6_route_next ((iter), (route)); \
+#define nm_ip_config_iter_ip6_route_for_each(iter, self, route) \
+    for (nm_ip_config_iter_ip6_route_init ((iter), (self)); \
+         nm_ip_config_iter_ip6_route_next ((iter), (route)); \
          )
 
 /*****************************************************************************/
@@ -102,17 +130,22 @@ void nm_ip6_config_set_gateway (NMIP6Config *self, const struct in6_addr *);
 const struct in6_addr *nm_ip6_config_get_gateway (const NMIP6Config *self);
 gint64 nm_ip6_config_get_route_metric (const NMIP6Config *self);
 
+const NMDedupMultiHeadEntry *nm_ip6_config_lookup_addresses (const NMIP6Config *self);
 void nm_ip6_config_reset_addresses (NMIP6Config *self);
 void nm_ip6_config_add_address (NMIP6Config *self, const NMPlatformIP6Address *address);
-void nm_ip6_config_del_address (NMIP6Config *self, guint i);
+void _nmtst_nm_ip6_config_del_address (NMIP6Config *self, guint i);
 guint nm_ip6_config_get_num_addresses (const NMIP6Config *self);
-const NMPlatformIP6Address *nm_ip6_config_get_address (const NMIP6Config *self, guint i);
+const NMPlatformIP6Address *nm_ip6_config_get_first_address (const NMIP6Config *self);
+const NMPlatformIP6Address *_nmtst_nm_ip6_config_get_address (const NMIP6Config *self, guint i);
 const NMPlatformIP6Address *nm_ip6_config_get_address_first_nontentative (const NMIP6Config *self, gboolean linklocal);
 gboolean nm_ip6_config_address_exists (const NMIP6Config *self, const NMPlatformIP6Address *address);
-gboolean nm_ip6_config_addresses_sort (NMIP6Config *self);
+const NMPlatformIP6Address *nm_ip6_config_lookup_address (const NMIP6Config *self,
+                                                          const struct in6_addr *addr);
+gboolean _nmtst_nm_ip6_config_addresses_sort (NMIP6Config *self);
 gboolean nm_ip6_config_has_any_dad_pending (const NMIP6Config *self,
                                             const NMIP6Config *candidates);
 
+const NMDedupMultiHeadEntry *nm_ip6_config_lookup_routes (const NMIP6Config *self);
 void nm_ip6_config_reset_routes (NMIP6Config *self);
 void nm_ip6_config_add_route (NMIP6Config *self, const NMPlatformIP6Route *route);
 void _nmtst_ip6_config_del_route (NMIP6Config *self, guint i);
diff --git a/src/nm-pacrunner-manager.c b/src/nm-pacrunner-manager.c
index d9095cce5b..2558ca0f30 100644
--- a/src/nm-pacrunner-manager.c
+++ b/src/nm-pacrunner-manager.c
@@ -170,6 +170,7 @@ get_ip4_domains (GPtrArray *domains, NMIP4Config *ip4)
 {
 	NMDedupMultiIter ipconf_iter;
 	char *cidr;
+	const NMPlatformIP4Address *address;
 	const NMPlatformIP4Route *routes;
 	guint i;
 
@@ -182,16 +183,15 @@ get_ip4_domains (GPtrArray *domains, NMIP4Config *ip4)
 		g_ptr_array_add (domains, g_strdup (nm_ip4_config_get_domain (ip4, i)));
 
 	/* Add addresses and routes in CIDR form */
-	for (i = 0; i < nm_ip4_config_get_num_addresses (ip4); i++) {
-		const NMPlatformIP4Address *address = nm_ip4_config_get_address (ip4, i);
 
+	nm_ip_config_iter_ip4_address_for_each (&ipconf_iter, ip4, &address) {
 		cidr = g_strdup_printf ("%s/%u",
 		                        nm_utils_inet4_ntop (address->address, NULL),
 		                        address->plen);
 		g_ptr_array_add (domains, cidr);
 	}
 
-	nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &routes) {
+	nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, ip4, &routes) {
 		cidr = g_strdup_printf ("%s/%u",
 		                        nm_utils_inet4_ntop (routes->network, NULL),
 		                        routes->plen);
@@ -204,6 +204,7 @@ get_ip6_domains (GPtrArray *domains, NMIP6Config *ip6)
 {
 	NMDedupMultiIter ipconf_iter;
 	char *cidr;
+	const NMPlatformIP6Address *address;
 	const NMPlatformIP6Route *routes;
 	guint i;
 
@@ -216,16 +217,14 @@ get_ip6_domains (GPtrArray *domains, NMIP6Config *ip6)
 		g_ptr_array_add (domains, g_strdup (nm_ip6_config_get_domain (ip6, i)));
 
 	/* Add addresses and routes in CIDR form */
-	for (i = 0; i < nm_ip6_config_get_num_addresses (ip6); i++) {
-		const NMPlatformIP6Address *address = nm_ip6_config_get_address (ip6, i);
-
+	nm_ip_config_iter_ip6_address_for_each (&ipconf_iter, ip6, &address) {
 		cidr = g_strdup_printf ("%s/%u",
 		                        nm_utils_inet6_ntop (&address->address, NULL),
 		                        address->plen);
 		g_ptr_array_add (domains, cidr);
 	}
 
-	nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &routes) {
+	nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, ip6, &routes) {
 		cidr = g_strdup_printf ("%s/%u",
 		                        nm_utils_inet6_ntop (&routes->network, NULL),
 		                        routes->plen);
diff --git a/src/nm-policy.c b/src/nm-policy.c
index 2d17bf3af0..1a97b02731 100644
--- a/src/nm-policy.c
+++ b/src/nm-policy.c
@@ -605,6 +605,8 @@ update_system_hostname (NMPolicy *self, NMDevice *best4, NMDevice *best6, const
 	NMIP4Config *ip4_config;
 	NMIP6Config *ip6_config;
 	gboolean external_hostname = FALSE;
+	const NMPlatformIP4Address *addr4;
+	const NMPlatformIP6Address *addr6;
 
 	g_return_if_fail (self != NULL);
 
@@ -746,17 +748,13 @@ update_system_hostname (NMPolicy *self, NMDevice *best4, NMDevice *best6, const
 	ip4_config = best4 ? nm_device_get_ip4_config (best4) : NULL;
 	ip6_config = best6 ? nm_device_get_ip6_config (best6) : NULL;
 
-	if (ip4_config && nm_ip4_config_get_num_addresses (ip4_config) > 0) {
-		const NMPlatformIP4Address *addr4;
-
-		addr4 = nm_ip4_config_get_address (ip4_config, 0);
+	if (   ip4_config
+	    && (addr4 = nm_ip4_config_get_first_address (ip4_config))) {
 		g_clear_object (&priv->lookup.addr);
 		priv->lookup.addr = g_inet_address_new_from_bytes ((guint8 *) &addr4->address,
 		                                                   G_SOCKET_FAMILY_IPV4);
-	} else if (ip6_config && nm_ip6_config_get_num_addresses (ip6_config) > 0) {
-		const NMPlatformIP6Address *addr6;
-
-		addr6 = nm_ip6_config_get_address (ip6_config, 0);
+	} else if (   ip6_config
+	           && (addr6 = nm_ip6_config_get_first_address (ip6_config))) {
 		g_clear_object (&priv->lookup.addr);
 		priv->lookup.addr = g_inet_address_new_from_bytes ((guint8 *) &addr6->address,
 		                                                   G_SOCKET_FAMILY_IPV6);
diff --git a/src/nm-types.h b/src/nm-types.h
index 36a624de8b..2cc5769467 100644
--- a/src/nm-types.h
+++ b/src/nm-types.h
@@ -110,6 +110,7 @@ NM_IS_IP_CONFIG_SOURCE_RTPROT (NMIPConfigSource source)
 
 /* platform */
 typedef struct _NMPlatform           NMPlatform;
+typedef struct _NMPlatformObject     NMPlatformObject;
 typedef struct _NMPlatformIP4Address NMPlatformIP4Address;
 typedef struct _NMPlatformIP4Route   NMPlatformIP4Route;
 typedef struct _NMPlatformIP6Address NMPlatformIP6Address;
diff --git a/src/platform/nm-platform.h b/src/platform/nm-platform.h
index 6e7a8b0658..f8297c0318 100644
--- a/src/platform/nm-platform.h
+++ b/src/platform/nm-platform.h
@@ -173,9 +173,9 @@ typedef enum {
 	NM_PLATFORM_SIGNAL_REMOVED,
 } NMPlatformSignalChangeType;
 
-typedef struct {
+struct _NMPlatformObject {
 	__NMPlatformObject_COMMON;
-} NMPlatformObject;
+};
 
 
 #define __NMPlatformIPAddress_COMMON \
diff --git a/src/platform/nmp-object.h b/src/platform/nmp-object.h
index 9cdad2e808..b63265ee11 100644
--- a/src/platform/nmp-object.h
+++ b/src/platform/nmp-object.h
@@ -345,6 +345,22 @@ NMP_OBJECT_GET_TYPE (const NMPObject *obj)
 		_obj ? &_NM_CONSTCAST (NMPObject, _obj)->link : NULL; \
 	})
 
+#define NMP_OBJECT_CAST_IP_ADDRESS(obj) \
+	({ \
+		typeof (obj) _obj = (obj); \
+		\
+		nm_assert (!_obj || NM_IN_SET (NMP_OBJECT_GET_TYPE (_obj), NMP_OBJECT_TYPE_IP4_ADDRESS, NMP_OBJECT_TYPE_IP6_ADDRESS)); \
+		_obj ? &_NM_CONSTCAST (NMPObject, _obj)->ip_address : NULL; \
+	})
+
+#define NMP_OBJECT_CAST_IPX_ADDRESS(obj) \
+	({ \
+		typeof (obj) _obj = (obj); \
+		\
+		nm_assert (!_obj || NM_IN_SET (NMP_OBJECT_GET_TYPE (_obj), NMP_OBJECT_TYPE_IP4_ADDRESS, NMP_OBJECT_TYPE_IP6_ADDRESS)); \
+		_obj ? &_NM_CONSTCAST (NMPObject, _obj)->ipx_address : NULL; \
+	})
+
 #define NMP_OBJECT_CAST_IP4_ADDRESS(obj) \
 	({ \
 		typeof (obj) _obj = (obj); \
@@ -419,6 +435,15 @@ NMPObject *nmp_object_new (NMPObjectType obj_type, const NMPlatformObject *plob)
 NMPObject *nmp_object_new_link (int ifindex);
 
 const NMPObject *nmp_object_stackinit (NMPObject *obj, NMPObjectType obj_type, const NMPlatformObject *plobj);
+
+static inline NMPObject *
+nmp_object_stackinit_obj (NMPObject *obj, const NMPObject *src)
+{
+	return obj == src
+	         ? obj
+	         : (NMPObject *) nmp_object_stackinit (obj, NMP_OBJECT_GET_TYPE (src), &src->object);
+}
+
 const NMPObject *nmp_object_stackinit_id  (NMPObject *obj, const NMPObject *src);
 const NMPObject *nmp_object_stackinit_id_link (NMPObject *obj, int ifindex);
 const NMPObject *nmp_object_stackinit_id_ip4_address (NMPObject *obj, int ifindex, guint32 address, guint8 plen, guint32 peer_address);
diff --git a/src/tests/test-ip4-config.c b/src/tests/test-ip4-config.c
index e865f5f26a..80cb1e5c70 100644
--- a/src/tests/test-ip4-config.c
+++ b/src/tests/test-ip4-config.c
@@ -112,7 +112,7 @@ test_subtract (void)
 
 	/* ensure what's left is what we expect */
 	g_assert_cmpuint (nm_ip4_config_get_num_addresses (dst), ==, 1);
-	test_addr = nm_ip4_config_get_address (dst, 0);
+	test_addr = _nmtst_nm_ip4_config_get_address (dst, 0);
 	g_assert (test_addr != NULL);
 	g_assert_cmpuint (test_addr->address, ==, nmtst_inet4_from_string (expected_addr));
 	g_assert_cmpuint (test_addr->peer_address, ==, test_addr->address);
@@ -196,27 +196,27 @@ test_add_address_with_source (void)
 	addr.addr_source = NM_IP_CONFIG_SOURCE_USER;
 	nm_ip4_config_add_address (a, &addr);
 
-	test_addr = nm_ip4_config_get_address (a, 0);
+	test_addr = _nmtst_nm_ip4_config_get_address (a, 0);
 	g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
 
 	addr.addr_source = NM_IP_CONFIG_SOURCE_VPN;
 	nm_ip4_config_add_address (a, &addr);
 
-	test_addr = nm_ip4_config_get_address (a, 0);
+	test_addr = _nmtst_nm_ip4_config_get_address (a, 0);
 	g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
 
 	/* Test that a lower priority address source is overwritten */
-	nm_ip4_config_del_address (a, 0);
+	_nmtst_nm_ip4_config_del_address (a, 0);
 	addr.addr_source = NM_IP_CONFIG_SOURCE_KERNEL;
 	nm_ip4_config_add_address (a, &addr);
 
-	test_addr = nm_ip4_config_get_address (a, 0);
+	test_addr = _nmtst_nm_ip4_config_get_address (a, 0);
 	g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_KERNEL);
 
 	addr.addr_source = NM_IP_CONFIG_SOURCE_USER;
 	nm_ip4_config_add_address (a, &addr);
 
-	test_addr = nm_ip4_config_get_address (a, 0);
+	test_addr = _nmtst_nm_ip4_config_get_address (a, 0);
 	g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
 
 	g_object_unref (a);
diff --git a/src/tests/test-ip6-config.c b/src/tests/test-ip6-config.c
index 0887e9da98..5d2283d9da 100644
--- a/src/tests/test-ip6-config.c
+++ b/src/tests/test-ip6-config.c
@@ -88,7 +88,7 @@ test_subtract (void)
 
 	/* ensure what's left is what we expect */
 	g_assert_cmpuint (nm_ip6_config_get_num_addresses (dst), ==, 1);
-	test_addr = nm_ip6_config_get_address (dst, 0);
+	test_addr = _nmtst_nm_ip6_config_get_address (dst, 0);
 	g_assert (test_addr != NULL);
 	tmp = *nmtst_inet6_from_string (expected_addr);
 	g_assert (memcmp (&test_addr->address, &tmp, sizeof (tmp)) == 0);
@@ -167,27 +167,27 @@ test_add_address_with_source (void)
 	addr.addr_source = NM_IP_CONFIG_SOURCE_USER;
 	nm_ip6_config_add_address (a, &addr);
 
-	test_addr = nm_ip6_config_get_address (a, 0);
+	test_addr = _nmtst_nm_ip6_config_get_address (a, 0);
 	g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
 
 	addr.addr_source = NM_IP_CONFIG_SOURCE_VPN;
 	nm_ip6_config_add_address (a, &addr);
 
-	test_addr = nm_ip6_config_get_address (a, 0);
+	test_addr = _nmtst_nm_ip6_config_get_address (a, 0);
 	g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
 
 	/* Test that a lower priority address source is overwritten */
-	nm_ip6_config_del_address (a, 0);
+	_nmtst_nm_ip6_config_del_address (a, 0);
 	addr.addr_source = NM_IP_CONFIG_SOURCE_KERNEL;
 	nm_ip6_config_add_address (a, &addr);
 
-	test_addr = nm_ip6_config_get_address (a, 0);
+	test_addr = _nmtst_nm_ip6_config_get_address (a, 0);
 	g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_KERNEL);
 
 	addr.addr_source = NM_IP_CONFIG_SOURCE_USER;
 	nm_ip6_config_add_address (a, &addr);
 
-	test_addr = nm_ip6_config_get_address (a, 0);
+	test_addr = _nmtst_nm_ip6_config_get_address (a, 0);
 	g_assert_cmpint (test_addr->addr_source, ==, NM_IP_CONFIG_SOURCE_USER);
 
 	g_object_unref (a);
@@ -256,18 +256,18 @@ test_nm_ip6_config_addresses_sort_check (NMIP6Config *config, NMSettingIP6Config
 			int j = g_rand_int_range (nmtst_get_rand (), i, addr_count);
 
 			NMTST_SWAP (idx[i], idx[j]);
-			nm_ip6_config_add_address (copy, nm_ip6_config_get_address (config, idx[i]));
+			nm_ip6_config_add_address (copy, _nmtst_nm_ip6_config_get_address (config, idx[i]));
 		}
 
 		/* reorder them again */
-		nm_ip6_config_addresses_sort (copy);
+		_nmtst_nm_ip6_config_addresses_sort (copy);
 
 		/* check equality using nm_ip6_config_equal() */
 		if (!nm_ip6_config_equal (copy, config)) {
 			g_message ("%s", "SORTING yields unexpected output:");
 			for (i = 0; i < addr_count; i++) {
-				g_message ("   >> [%d] = %s", i, nm_platform_ip6_address_to_string (nm_ip6_config_get_address (config, i), NULL, 0));
-				g_message ("   << [%d] = %s", i, nm_platform_ip6_address_to_string (nm_ip6_config_get_address (copy, i), NULL, 0));
+				g_message ("   >> [%d] = %s", i, nm_platform_ip6_address_to_string (_nmtst_nm_ip6_config_get_address (config, i), NULL, 0));
+				g_message ("   << [%d] = %s", i, nm_platform_ip6_address_to_string (_nmtst_nm_ip6_config_get_address (copy, i), NULL, 0));
 			}
 			g_assert_not_reached ();
 		}
diff --git a/src/vpn/nm-vpn-connection.c b/src/vpn/nm-vpn-connection.c
index ab6103d497..dac4467ce4 100644
--- a/src/vpn/nm-vpn-connection.c
+++ b/src/vpn/nm-vpn-connection.c
@@ -959,7 +959,8 @@ print_vpn_config (NMVpnConnection *self)
 
 		_LOGI ("Data: IPv4 configuration:");
 
-		address4 = nm_ip4_config_get_address (priv->ip4_config, 0);
+		address4 = nm_ip4_config_get_first_address (priv->ip4_config);
+		nm_assert (address4);
 
 		if (priv->ip4_internal_gw)
 			_LOGI ("Data:   Internal Gateway: %s", nm_utils_inet4_ntop (priv->ip4_internal_gw, NULL));
@@ -968,7 +969,7 @@ print_vpn_config (NMVpnConnection *self)
 		_LOGI ("Data:   Internal Point-to-Point Address: %s", nm_utils_inet4_ntop (address4->peer_address, NULL));
 		_LOGI ("Data:   Maximum Segment Size (MSS): %d", nm_ip4_config_get_mss (priv->ip4_config));
 
-		nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, priv->ip4_config, &route) {
+		nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, priv->ip4_config, &route) {
 			_LOGI ("Data:   Static Route: %s/%d   Next Hop: %s",
 			       nm_utils_inet4_ntop (route->network, NULL),
 			       route->plen,
@@ -996,7 +997,8 @@ print_vpn_config (NMVpnConnection *self)
 
 		_LOGI ("Data: IPv6 configuration:");
 
-		address6 = nm_ip6_config_get_address (priv->ip6_config, 0);
+		address6 = nm_ip6_config_get_first_address (priv->ip6_config);
+		nm_assert (address6);
 
 		if (priv->ip6_internal_gw)
 			_LOGI ("Data:   Internal Gateway: %s", nm_utils_inet6_ntop (priv->ip6_internal_gw, NULL));
@@ -1005,7 +1007,7 @@ print_vpn_config (NMVpnConnection *self)
 		_LOGI ("Data:   Internal Point-to-Point Address: %s", nm_utils_inet6_ntop (&address6->peer_address, NULL));
 		_LOGI ("Data:   Maximum Segment Size (MSS): %d", nm_ip6_config_get_mss (priv->ip6_config));
 
-		nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, priv->ip6_config, &route) {
+		nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, priv->ip6_config, &route) {
 			_LOGI ("Data:   Static Route: %s/%d   Next Hop: %s",
 			       nm_utils_inet6_ntop (&route->network, NULL),
 			       route->plen,
@@ -1506,7 +1508,7 @@ nm_vpn_connection_ip4_config_get (NMVpnConnection *self, GVariant *dict)
 			NMDedupMultiIter ipconf_iter;
 			const NMPlatformIP4Route *route;
 
-			nm_ip4_config_iter_ip4_route_for_each (&ipconf_iter, priv->ip4_config, &route)
+			nm_ip_config_iter_ip4_route_for_each (&ipconf_iter, priv->ip4_config, &route)
 				nm_ip4_config_add_route (config, route);
 		}
 	} else if (g_variant_lookup (dict, NM_VPN_PLUGIN_IP4_CONFIG_ROUTES, "aau", &iter)) {
@@ -1670,7 +1672,7 @@ nm_vpn_connection_ip6_config_get (NMVpnConnection *self, GVariant *dict)
 			NMDedupMultiIter ipconf_iter;
 			const NMPlatformIP6Route *route;
 
-			nm_ip6_config_iter_ip6_route_for_each (&ipconf_iter, priv->ip6_config, &route)
+			nm_ip_config_iter_ip6_route_for_each (&ipconf_iter, priv->ip6_config, &route)
 				nm_ip6_config_add_route (config, route);
 		}
 	} else if (g_variant_lookup (dict, NM_VPN_PLUGIN_IP6_CONFIG_ROUTES, "a(ayuayu)", &iter)) {