New upstream version 1.27.90 upstream/1.27.90

1 files changed, 1347 insertions, 1161 deletions

diff --git a/src/ndisc/nm-ndisc.c b/src/ndisc/nm-ndisc.c
index 5e556084..f8805c02 100644
--- a/src/ndisc/nm-ndisc.c
+++ b/src/ndisc/nm-ndisc.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * Copyright (C) 2013 Red Hat, Inc.
  */
@@ -16,96 +16,206 @@
 #include "nm-utils.h"
 #include "platform/nm-platform.h"
 #include "platform/nmp-netns.h"
+#include "nm-l3-config-data.h"
 
-#define _NMLOG_PREFIX_NAME                "ndisc"
+#define _NMLOG_PREFIX_NAME "ndisc"
 
 /*****************************************************************************/
 
 struct _NMNDiscPrivate {
-	/* this *must* be the first field. */
-	NMNDiscDataInternal rdata;
-
-	union {
-		gint32 solicitations_left;
-		gint32 announcements_left;
-	};
-	union {
-		guint send_rs_id;
-		guint send_ra_id;
-	};
-	union {
-		gint32 last_rs;
-		gint32 last_ra;
-	};
-	guint ra_timeout_id;  /* first RA timeout */
-	guint timeout_id;   /* prefix/dns/etc lifetime timeout */
-	char *last_error;
-	NMUtilsIPv6IfaceId iid;
-
-	/* immutable values: */
-	int ifindex;
-	char *ifname;
-	char *network_id;
-	NMSettingIP6ConfigAddrGenMode addr_gen_mode;
-	NMUtilsStableType stable_type;
-	gint32 ra_timeout;
-	gint32 max_addresses;
-	gint32 router_solicitations;
-	gint32 router_solicitation_interval;
-	NMNDiscNodeType node_type;
-
-	NMPlatform *platform;
-	NMPNetns *netns;
+    /* this *must* be the first field. */
+    NMNDiscDataInternal rdata;
+
+    char *   last_error;
+    GSource *ra_timeout_source;
+
+    union {
+        gint32 solicitations_left;
+        gint32 announcements_left;
+    };
+    union {
+        guint send_rs_id;
+        guint send_ra_id;
+    };
+    union {
+        gint32 last_rs;
+        gint32 last_ra;
+    };
+    guint              timeout_id; /* prefix/dns/etc lifetime timeout */
+    NMUtilsIPv6IfaceId iid;
+
+    /* immutable values: */
+    int                           ifindex;
+    char *                        ifname;
+    char *                        network_id;
+    NMSettingIP6ConfigAddrGenMode addr_gen_mode;
+    NMUtilsStableType             stable_type;
+    guint32                       ra_timeout;
+    gint32                        max_addresses;
+    gint32                        router_solicitations;
+    gint32                        router_solicitation_interval;
+    NMNDiscNodeType               node_type;
+
+    NMPlatform *platform;
+    NMPNetns *  netns;
 };
 
 typedef struct _NMNDiscPrivate NMNDiscPrivate;
 
-NM_GOBJECT_PROPERTIES_DEFINE_BASE (
-	PROP_PLATFORM,
-	PROP_IFINDEX,
-	PROP_IFNAME,
-	PROP_STABLE_TYPE,
-	PROP_NETWORK_ID,
-	PROP_ADDR_GEN_MODE,
-	PROP_MAX_ADDRESSES,
-	PROP_RA_TIMEOUT,
-	PROP_ROUTER_SOLICITATIONS,
-	PROP_ROUTER_SOLICITATION_INTERVAL,
-	PROP_NODE_TYPE,
-);
-
-enum {
-	CONFIG_RECEIVED,
-	RA_TIMEOUT_SIGNAL,
-	LAST_SIGNAL
-};
+NM_GOBJECT_PROPERTIES_DEFINE_BASE(PROP_PLATFORM,
+                                  PROP_IFINDEX,
+                                  PROP_IFNAME,
+                                  PROP_STABLE_TYPE,
+                                  PROP_NETWORK_ID,
+                                  PROP_ADDR_GEN_MODE,
+                                  PROP_MAX_ADDRESSES,
+                                  PROP_RA_TIMEOUT,
+                                  PROP_ROUTER_SOLICITATIONS,
+                                  PROP_ROUTER_SOLICITATION_INTERVAL,
+                                  PROP_NODE_TYPE, );
+
+enum { CONFIG_RECEIVED, RA_TIMEOUT_SIGNAL, LAST_SIGNAL };
 
-static guint signals[LAST_SIGNAL] = { 0 };
+static guint signals[LAST_SIGNAL] = {0};
 
-G_DEFINE_TYPE (NMNDisc, nm_ndisc, G_TYPE_OBJECT)
+G_DEFINE_TYPE(NMNDisc, nm_ndisc, G_TYPE_OBJECT)
 
 #define NM_NDISC_GET_PRIVATE(self) _NM_GET_PRIVATE_PTR(self, NMNDisc, NM_IS_NDISC)
 
 /*****************************************************************************/
 
-static void _config_changed_log (NMNDisc *ndisc, NMNDiscConfigMap changed);
+static void _config_changed_log(NMNDisc *ndisc, NMNDiscConfigMap changed);
+
+/*****************************************************************************/
+
+NML3ConfigData *
+nm_ndisc_data_to_l3cd(NMDedupMultiIndex *       multi_idx,
+                      int                       ifindex,
+                      const NMNDiscData *       rdata,
+                      NMSettingIP6ConfigPrivacy ip6_privacy,
+                      guint32                   route_table,
+                      guint32                   route_metric,
+                      gboolean                  kernel_support_rta_pref,
+                      gboolean                  kernel_support_extended_ifa_flags)
+{
+    nm_auto_unref_l3cd_init NML3ConfigData *l3cd = NULL;
+    guint32                                 ifa_flags;
+    guint8                                  plen;
+    guint                                   i;
+
+    l3cd = nm_l3_config_data_new(multi_idx, ifindex);
+
+    nm_l3_config_data_set_source(l3cd, NM_IP_CONFIG_SOURCE_NDISC);
+
+    nm_l3_config_data_set_ip6_privacy(l3cd, ip6_privacy);
+
+    /* Check, whether kernel is recent enough to help user space handling RA.
+     * If it's not supported, we have no ipv6-privacy and must add autoconf
+     * addresses as /128. The reason for the /128 is to prevent the kernel
+     * from adding a prefix route for this address. */
+    ifa_flags = 0;
+    if (kernel_support_extended_ifa_flags) {
+        ifa_flags |= IFA_F_NOPREFIXROUTE;
+        if (NM_IN_SET(ip6_privacy,
+                      NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_TEMP_ADDR,
+                      NM_SETTING_IP6_CONFIG_PRIVACY_PREFER_PUBLIC_ADDR))
+            ifa_flags |= IFA_F_MANAGETEMPADDR;
+        plen = 64;
+    } else
+        plen = 128;
+
+    for (i = 0; i < rdata->addresses_n; i++) {
+        const NMNDiscAddress *ndisc_addr = &rdata->addresses[i];
+        NMPlatformIP6Address  a;
+
+        a = (NMPlatformIP6Address){
+            .ifindex     = ifindex,
+            .address     = ndisc_addr->address,
+            .plen        = plen,
+            .timestamp   = ndisc_addr->timestamp,
+            .lifetime    = ndisc_addr->lifetime,
+            .preferred   = MIN(ndisc_addr->lifetime, ndisc_addr->preferred),
+            .addr_source = NM_IP_CONFIG_SOURCE_NDISC,
+            .n_ifa_flags = ifa_flags,
+        };
+
+        nm_l3_config_data_add_address_6(l3cd, &a);
+    }
+
+    for (i = 0; i < rdata->routes_n; i++) {
+        const NMNDiscRoute *ndisc_route = &rdata->routes[i];
+        NMPlatformIP6Route  r;
+
+        r = (NMPlatformIP6Route){
+            .ifindex       = ifindex,
+            .network       = ndisc_route->network,
+            .plen          = ndisc_route->plen,
+            .gateway       = ndisc_route->gateway,
+            .rt_source     = NM_IP_CONFIG_SOURCE_NDISC,
+            .table_coerced = nm_platform_route_table_coerce(route_table),
+            .metric        = route_metric,
+            .rt_pref       = ndisc_route->preference,
+        };
+        nm_assert((NMIcmpv6RouterPref) r.rt_pref == ndisc_route->preference);
+
+        nm_l3_config_data_add_route_6(l3cd, &r);
+    }
+
+    if (rdata->gateways_n > 0) {
+        const NMIcmpv6RouterPref first_pref = rdata->gateways[0].preference;
+        NMPlatformIP6Route       r          = {
+            .rt_source     = NM_IP_CONFIG_SOURCE_NDISC,
+            .ifindex       = ifindex,
+            .table_coerced = nm_platform_route_table_coerce(route_table),
+            .metric        = route_metric,
+        };
+
+        for (i = 0; i < rdata->gateways_n; i++) {
+            r.gateway = rdata->gateways[i].address;
+            r.rt_pref = rdata->gateways[i].preference;
+            nm_assert((NMIcmpv6RouterPref) r.rt_pref == rdata->gateways[i].preference);
+            nm_l3_config_data_add_route_6(l3cd, &r);
+
+            if (first_pref != rdata->gateways[i].preference && !kernel_support_rta_pref) {
+                /* We are unable to configure a router preference. Hence, we skip all gateways
+                 * with a different preference from the first gateway. Note, that the gateways
+                 * are sorted in order of highest to lowest preference. */
+                break;
+            }
+        }
+    }
+
+    for (i = 0; i < rdata->dns_servers_n; i++)
+        nm_l3_config_data_add_nameserver(l3cd, AF_INET6, &rdata->dns_servers[i].address);
+
+    for (i = 0; i < rdata->dns_domains_n; i++)
+        nm_l3_config_data_add_search(l3cd, AF_INET6, rdata->dns_domains[i].domain);
+
+    nm_l3_config_data_set_ndisc_hop_limit(l3cd, rdata->hop_limit);
+    nm_l3_config_data_set_ndisc_reachable_time_msec(l3cd, rdata->reachable_time_ms);
+    nm_l3_config_data_set_ndisc_retrans_timer_msec(l3cd, rdata->retrans_timer_ms);
+
+    nm_l3_config_data_set_ip6_mtu(l3cd, rdata->mtu);
+
+    return g_steal_pointer(&l3cd);
+}
 
 /*****************************************************************************/
 
 static guint8
-_preference_to_priority (NMIcmpv6RouterPref pref)
+_preference_to_priority(NMIcmpv6RouterPref pref)
 {
-	switch (pref) {
-	case NM_ICMPV6_ROUTER_PREF_LOW:
-		return 1;
-	case NM_ICMPV6_ROUTER_PREF_MEDIUM:
-		return 2;
-	case NM_ICMPV6_ROUTER_PREF_HIGH:
-		return 3;
-	case NM_ICMPV6_ROUTER_PREF_INVALID:
-		break;
-	}
-	return 0;
+    switch (pref) {
+    case NM_ICMPV6_ROUTER_PREF_LOW:
+        return 1;
+    case NM_ICMPV6_ROUTER_PREF_MEDIUM:
+        return 2;
+    case NM_ICMPV6_ROUTER_PREF_HIGH:
+        return 3;
+    case NM_ICMPV6_ROUTER_PREF_INVALID:
+        break;
+    }
+    return 0;
 }
 
 /*****************************************************************************/
@@ -114,240 +224,243 @@ _preference_to_priority (NMIcmpv6RouterPref pref)
 #define _EXPIRY_INFINITY G_MAXINT64
 
 static gint64
-get_expiry_time (guint32 timestamp, guint32 lifetime)
+get_expiry_time(guint32 timestamp, guint32 lifetime)
 {
-	nm_assert (timestamp > 0);
-	nm_assert (timestamp <= G_MAXINT32);
+    nm_assert(timestamp > 0);
+    nm_assert(timestamp <= G_MAXINT32);
 
-	if (lifetime == NM_NDISC_INFINITY)
-		return _EXPIRY_INFINITY;
-	return ((gint64) timestamp) + ((gint64) lifetime);
+    if (lifetime == NM_NDISC_INFINITY)
+        return _EXPIRY_INFINITY;
+    return ((gint64) timestamp) + ((gint64) lifetime);
 }
 
-#define get_expiry(item) \
-	({ \
-		typeof (item) _item = (item); \
-		nm_assert (_item); \
-		get_expiry_time (_item->timestamp, _item->lifetime); \
-	})
-
-#define get_expiry_half(item) \
-	({ \
-		typeof (item) _item = (item); \
-		nm_assert (_item); \
-		(_item->lifetime == NM_NDISC_INFINITY) \
-		  ? _EXPIRY_INFINITY \
-		  : get_expiry_time (_item->timestamp, _item->lifetime / 2); \
-	})
-
-#define get_expiry_preferred(item) \
-	({ \
-		typeof (item) _item = (item); \
-		nm_assert (_item); \
-		get_expiry_time (_item->timestamp, _item->preferred); \
-	})
+#define get_expiry(item)                                    \
+    ({                                                      \
+        typeof(item) _item = (item);                        \
+        nm_assert(_item);                                   \
+        get_expiry_time(_item->timestamp, _item->lifetime); \
+    })
+
+#define get_expiry_half(item)                                         \
+    ({                                                                \
+        typeof(item) _item = (item);                                  \
+        nm_assert(_item);                                             \
+        (_item->lifetime == NM_NDISC_INFINITY)                        \
+            ? _EXPIRY_INFINITY                                        \
+            : get_expiry_time(_item->timestamp, _item->lifetime / 2); \
+    })
+
+#define get_expiry_preferred(item)                           \
+    ({                                                       \
+        typeof(item) _item = (item);                         \
+        nm_assert(_item);                                    \
+        get_expiry_time(_item->timestamp, _item->preferred); \
+    })
 
 static gboolean
-expiry_next (gint32 now_s, gint64 expiry_timestamp, gint32 *nextevent)
+expiry_next(gint32 now_s, gint64 expiry_timestamp, gint32 *nextevent)
 {
-	gint32 e;
-
-	if (expiry_timestamp == _EXPIRY_INFINITY)
-		return TRUE;
-	e = MIN (expiry_timestamp, ((gint64) (G_MAXINT32 - 1)));
-	if (now_s >= e)
-		return FALSE;
-	if (nextevent) {
-		if (*nextevent > e)
-			*nextevent = e;
-	}
-	return TRUE;
+    gint32 e;
+
+    if (expiry_timestamp == _EXPIRY_INFINITY)
+        return TRUE;
+    e = MIN(expiry_timestamp, ((gint64)(G_MAXINT32 - 1)));
+    if (now_s >= e)
+        return FALSE;
+    if (nextevent) {
+        if (*nextevent > e)
+            *nextevent = e;
+    }
+    return TRUE;
 }
 
 static const char *
-_get_exp (char *buf, gsize buf_size, gint64 now_ns, gint64 expiry_time)
+_get_exp(char *buf, gsize buf_size, gint64 now_ns, gint64 expiry_time)
 {
-	int l;
-
-	if (expiry_time == _EXPIRY_INFINITY)
-		return "permanent";
-	l = g_snprintf (buf, buf_size,
-	                "%.4f",
-	                ((double) ((expiry_time * NM_UTILS_NSEC_PER_SEC) - now_ns)) / ((double) NM_UTILS_NSEC_PER_SEC));
-	nm_assert (l < buf_size);
-	return buf;
+    int l;
+
+    if (expiry_time == _EXPIRY_INFINITY)
+        return "permanent";
+    l = g_snprintf(buf,
+                   buf_size,
+                   "%.4f",
+                   ((double) ((expiry_time * NM_UTILS_NSEC_PER_SEC) - now_ns))
+                       / ((double) NM_UTILS_NSEC_PER_SEC));
+    nm_assert(l < buf_size);
+    return buf;
 }
 
-#define get_exp(buf, now_ns, item) \
-	_get_exp ((buf), G_N_ELEMENTS (buf), (now_ns), (get_expiry (item)))
+#define get_exp(buf, now_ns, item) _get_exp((buf), G_N_ELEMENTS(buf), (now_ns), (get_expiry(item)))
 
 /*****************************************************************************/
 
 NMPNetns *
-nm_ndisc_netns_get (NMNDisc *self)
+nm_ndisc_netns_get(NMNDisc *self)
 {
-	g_return_val_if_fail (NM_IS_NDISC (self), NULL);
+    g_return_val_if_fail(NM_IS_NDISC(self), NULL);
 
-	return NM_NDISC_GET_PRIVATE (self)->netns;
+    return NM_NDISC_GET_PRIVATE(self)->netns;
 }
 
 gboolean
-nm_ndisc_netns_push (NMNDisc *self, NMPNetns **netns)
+nm_ndisc_netns_push(NMNDisc *self, NMPNetns **netns)
 {
-	NMNDiscPrivate *priv;
+    NMNDiscPrivate *priv;
 
-	g_return_val_if_fail (NM_IS_NDISC (self), FALSE);
+    g_return_val_if_fail(NM_IS_NDISC(self), FALSE);
 
-	priv = NM_NDISC_GET_PRIVATE (self);
-	if (   priv->netns
-	    && !nmp_netns_push (priv->netns)) {
-		NM_SET_OUT (netns, NULL);
-		return FALSE;
-	}
+    priv = NM_NDISC_GET_PRIVATE(self);
+    if (priv->netns && !nmp_netns_push(priv->netns)) {
+        NM_SET_OUT(netns, NULL);
+        return FALSE;
+    }
 
-	NM_SET_OUT (netns, priv->netns);
-	return TRUE;
+    NM_SET_OUT(netns, priv->netns);
+    return TRUE;
 }
 
 /*****************************************************************************/
 
 int
-nm_ndisc_get_ifindex (NMNDisc *self)
+nm_ndisc_get_ifindex(NMNDisc *self)
 {
-	g_return_val_if_fail (NM_IS_NDISC (self), 0);
+    g_return_val_if_fail(NM_IS_NDISC(self), 0);
 
-	return NM_NDISC_GET_PRIVATE (self)->ifindex;
+    return NM_NDISC_GET_PRIVATE(self)->ifindex;
 }
 
 const char *
-nm_ndisc_get_ifname (NMNDisc *self)
+nm_ndisc_get_ifname(NMNDisc *self)
 {
-	g_return_val_if_fail (NM_IS_NDISC (self), NULL);
+    g_return_val_if_fail(NM_IS_NDISC(self), NULL);
 
-	return NM_NDISC_GET_PRIVATE (self)->ifname;
+    return NM_NDISC_GET_PRIVATE(self)->ifname;
 }
 
 NMNDiscNodeType
-nm_ndisc_get_node_type (NMNDisc *self)
+nm_ndisc_get_node_type(NMNDisc *self)
 {
-	g_return_val_if_fail (NM_IS_NDISC (self), NM_NDISC_NODE_TYPE_INVALID);
+    g_return_val_if_fail(NM_IS_NDISC(self), NM_NDISC_NODE_TYPE_INVALID);
 
-	return NM_NDISC_GET_PRIVATE (self)->node_type;
+    return NM_NDISC_GET_PRIVATE(self)->node_type;
 }
 
 /*****************************************************************************/
 
 static void
-_ASSERT_data_gateways (const NMNDiscDataInternal *data)
+_ASSERT_data_gateways(const NMNDiscDataInternal *data)
 {
 #if NM_MORE_ASSERTS > 10
-	guint i, j;
-	const NMNDiscGateway *item_prev = NULL;
+    guint                 i, j;
+    const NMNDiscGateway *item_prev = NULL;
 
-	if (!data->gateways->len)
-		return;
+    if (!data->gateways->len)
+        return;
 
-	for (i = 0; i < data->gateways->len; i++) {
-		const NMNDiscGateway *item = &g_array_index (data->gateways, NMNDiscGateway, i);
+    for (i = 0; i < data->gateways->len; i++) {
+        const NMNDiscGateway *item = &g_array_index(data->gateways, NMNDiscGateway, i);
 
-		nm_assert (!IN6_IS_ADDR_UNSPECIFIED (&item->address));
-		nm_assert (item->timestamp > 0 && item->timestamp <= G_MAXINT32);
-		for (j = 0; j < i; j++) {
-			const NMNDiscGateway *item2 = &g_array_index (data->gateways, NMNDiscGateway, j);
+        nm_assert(!IN6_IS_ADDR_UNSPECIFIED(&item->address));
+        nm_assert(item->timestamp > 0 && item->timestamp <= G_MAXINT32);
+        for (j = 0; j < i; j++) {
+            const NMNDiscGateway *item2 = &g_array_index(data->gateways, NMNDiscGateway, j);
 
-			nm_assert (!IN6_ARE_ADDR_EQUAL (&item->address, &item2->address));
-		}
+            nm_assert(!IN6_ARE_ADDR_EQUAL(&item->address, &item2->address));
+        }
 
-		nm_assert (item->lifetime > 0);
-		if (i > 0)
-			nm_assert (_preference_to_priority (item_prev->preference) >= _preference_to_priority (item->preference));
+        nm_assert(item->lifetime > 0);
+        if (i > 0)
+            nm_assert(_preference_to_priority(item_prev->preference)
+                      >= _preference_to_priority(item->preference));
 
-		item_prev = item;
-	}
+        item_prev = item;
+    }
 #endif
 }
 
 /*****************************************************************************/
 
 static const NMNDiscData *
-_data_complete (NMNDiscDataInternal *data)
+_data_complete(NMNDiscDataInternal *data)
 {
-	_ASSERT_data_gateways (data);
-
-#define _SET(data, field) \
-	G_STMT_START { \
-		if ((data->public.field##_n = data->field->len) > 0) \
-			data->public.field = (gpointer) data->field->data; \
-		else \
-			data->public.field = NULL; \
-	} G_STMT_END
-	_SET (data, gateways);
-	_SET (data, addresses);
-	_SET (data, routes);
-	_SET (data, dns_servers);
-	_SET (data, dns_domains);
+    _ASSERT_data_gateways(data);
+
+#define _SET(data, field)                                      \
+    G_STMT_START                                               \
+    {                                                          \
+        if ((data->public.field##_n = data->field->len) > 0)   \
+            data->public.field = (gpointer) data->field->data; \
+        else                                                   \
+            data->public.field = NULL;                         \
+    }                                                          \
+    G_STMT_END
+    _SET(data, gateways);
+    _SET(data, addresses);
+    _SET(data, routes);
+    _SET(data, dns_servers);
+    _SET(data, dns_domains);
 #undef _SET
-	return &data->public;
+    return &data->public;
 }
 
 void
-nm_ndisc_emit_config_change (NMNDisc *self, NMNDiscConfigMap changed)
+nm_ndisc_emit_config_change(NMNDisc *self, NMNDiscConfigMap changed)
 {
-	_config_changed_log (self, changed);
-	g_signal_emit (self, signals[CONFIG_RECEIVED], 0,
-	               _data_complete (&NM_NDISC_GET_PRIVATE (self)->rdata),
-	               (guint) changed);
+    _config_changed_log(self, changed);
+    g_signal_emit(self,
+                  signals[CONFIG_RECEIVED],
+                  0,
+                  _data_complete(&NM_NDISC_GET_PRIVATE(self)->rdata),
+                  (guint) changed);
 }
 
 /*****************************************************************************/
 
 gboolean
-nm_ndisc_add_gateway (NMNDisc *ndisc, const NMNDiscGateway *new)
+nm_ndisc_add_gateway(NMNDisc *ndisc, const NMNDiscGateway *new)
 {
-	NMNDiscDataInternal *rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata;
-	guint i;
-	guint insert_idx = G_MAXUINT;
-
-	for (i = 0; i < rdata->gateways->len; ) {
-		NMNDiscGateway *item = &g_array_index (rdata->gateways, NMNDiscGateway, i);
-
-		if (IN6_ARE_ADDR_EQUAL (&item->address, &new->address)) {
-			if (new->lifetime == 0) {
-				g_array_remove_index (rdata->gateways, i);
-				_ASSERT_data_gateways (rdata);
-				return TRUE;
-			}
-
-			if (item->preference != new->preference) {
-				g_array_remove_index (rdata->gateways, i);
-				continue;
-			}
-
-			if (get_expiry (item) == get_expiry (new))
-				return FALSE;
-
-			*item = *new;
-			_ASSERT_data_gateways (rdata);
-			return TRUE;
-		}
-
-		/* Put before less preferable gateways. */
-		if (   _preference_to_priority (item->preference) < _preference_to_priority (new->preference)
-		    && insert_idx == G_MAXUINT)
-			insert_idx = i;
-
-		i++;
-	}
-
-	if (new->lifetime) {
-		g_array_insert_val (rdata->gateways,
-		                    insert_idx == G_MAXUINT
-		                      ? rdata->gateways->len
-		                      : insert_idx,
-		                    *new);
-	}
-	_ASSERT_data_gateways (rdata);
-	return !!new->lifetime;
+    NMNDiscDataInternal *rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata;
+    guint                i;
+    guint                insert_idx = G_MAXUINT;
+
+    for (i = 0; i < rdata->gateways->len;) {
+        NMNDiscGateway *item = &g_array_index(rdata->gateways, NMNDiscGateway, i);
+
+        if (IN6_ARE_ADDR_EQUAL(&item->address, &new->address)) {
+            if (new->lifetime == 0) {
+                g_array_remove_index(rdata->gateways, i);
+                _ASSERT_data_gateways(rdata);
+                return TRUE;
+            }
+
+            if (item->preference != new->preference) {
+                g_array_remove_index(rdata->gateways, i);
+                continue;
+            }
+
+            if (get_expiry(item) == get_expiry(new))
+                return FALSE;
+
+            *item = *new;
+            _ASSERT_data_gateways(rdata);
+            return TRUE;
+        }
+
+        /* Put before less preferable gateways. */
+        if (_preference_to_priority(item->preference) < _preference_to_priority(new->preference)
+            && insert_idx == G_MAXUINT)
+            insert_idx = i;
+
+        i++;
+    }
+
+    if (new->lifetime) {
+        g_array_insert_val(rdata->gateways,
+                           insert_idx == G_MAXUINT ? rdata->gateways->len : insert_idx,
+                           *new);
+    }
+    _ASSERT_data_gateways(rdata);
+    return !!new->lifetime;
 }
 
 /**
@@ -365,485 +478,485 @@ nm_ndisc_add_gateway (NMNDisc *ndisc, const NMNDiscGateway *new)
  * Returns: %TRUE if the address could be completed, %FALSE otherwise.
  **/
 static gboolean
-complete_address (NMNDisc *ndisc, NMNDiscAddress *addr)
+complete_address(NMNDisc *ndisc, NMNDiscAddress *addr)
 {
-	NMNDiscPrivate *priv;
-	GError *error = NULL;
-
-	g_return_val_if_fail (NM_IS_NDISC (ndisc), FALSE);
-
-	priv = NM_NDISC_GET_PRIVATE (ndisc);
-	if (priv->addr_gen_mode == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY) {
-		if (!nm_utils_ipv6_addr_set_stable_privacy (priv->stable_type,
-		                                            &addr->address,
-		                                            priv->ifname,
-		                                            priv->network_id,
-		                                            addr->dad_counter++,
-		                                            &error)) {
-			_LOGW ("complete-address: failed to generate an stable-privacy address: %s",
-			       error->message);
-			g_clear_error (&error);
-			return FALSE;
-		}
-		_LOGD ("complete-address: using an stable-privacy address");
-		return TRUE;
-	}
-
-	if (!priv->iid.id) {
-		_LOGW ("complete-address: can't generate an EUI-64 address: no interface identifier");
-		return FALSE;
-	}
-
-	if (addr->address.s6_addr32[2] == 0x0 && addr->address.s6_addr32[3] == 0x0) {
-		_LOGD ("complete-address: adding an EUI-64 address");
-		nm_utils_ipv6_addr_set_interface_identifier (&addr->address, priv->iid);
-		return TRUE;
-	}
-
-	_LOGW ("complete-address: can't generate a new EUI-64 address");
-	return FALSE;
+    NMNDiscPrivate *priv;
+    GError *        error = NULL;
+
+    g_return_val_if_fail(NM_IS_NDISC(ndisc), FALSE);
+
+    priv = NM_NDISC_GET_PRIVATE(ndisc);
+    if (priv->addr_gen_mode == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY) {
+        if (!nm_utils_ipv6_addr_set_stable_privacy(priv->stable_type,
+                                                   &addr->address,
+                                                   priv->ifname,
+                                                   priv->network_id,
+                                                   addr->dad_counter++,
+                                                   &error)) {
+            _LOGW("complete-address: failed to generate an stable-privacy address: %s",
+                  error->message);
+            g_clear_error(&error);
+            return FALSE;
+        }
+        _LOGD("complete-address: using an stable-privacy address");
+        return TRUE;
+    }
+
+    if (!priv->iid.id) {
+        _LOGW("complete-address: can't generate an EUI-64 address: no interface identifier");
+        return FALSE;
+    }
+
+    if (addr->address.s6_addr32[2] == 0x0 && addr->address.s6_addr32[3] == 0x0) {
+        _LOGD("complete-address: adding an EUI-64 address");
+        nm_utils_ipv6_addr_set_interface_identifier(&addr->address, priv->iid);
+        return TRUE;
+    }
+
+    _LOGW("complete-address: can't generate a new EUI-64 address");
+    return FALSE;
 }
 
 static gboolean
-nm_ndisc_add_address (NMNDisc *ndisc,
-                      const NMNDiscAddress *new,
-                      gint32 now_s,
-                      gboolean from_ra)
+nm_ndisc_add_address(NMNDisc *ndisc, const NMNDiscAddress *new, gint32 now_s, gboolean from_ra)
 {
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
-	NMNDiscDataInternal *rdata = &priv->rdata;
-	NMNDiscAddress new2;
-	NMNDiscAddress *existing = NULL;
-	guint i;
-
-	nm_assert (new);
-	nm_assert (new->timestamp > 0 && new->timestamp < G_MAXINT32);
-	nm_assert (!IN6_IS_ADDR_UNSPECIFIED (&new->address));
-	nm_assert (!IN6_IS_ADDR_LINKLOCAL (&new->address));
-	nm_assert (new->preferred <= new->lifetime);
-	nm_assert (!from_ra || now_s > 0);
-
-	for (i = 0; i < rdata->addresses->len; i++) {
-		NMNDiscAddress *item = &g_array_index (rdata->addresses, NMNDiscAddress, i);
-
-		if (from_ra) {
-			/* RFC4862 5.5.3.d, we find an existing address with the same prefix.
-			 * (note that all prefixes at this point have implicitly length /64). */
-			if (memcmp (&item->address, &new->address, 8) == 0) {
-				existing = item;
-				break;
-			}
-		} else {
-			if (IN6_ARE_ADDR_EQUAL (&item->address, &new->address)) {
-				existing = item;
-				break;
-			}
-		}
-	}
-
-	if (existing) {
-		if (from_ra) {
-			const gint32 NM_NDISC_PREFIX_LFT_MIN = 7200; /* seconds, RFC4862 5.5.3.e */
-			gint64 old_expiry_lifetime, old_expiry_preferred;
-
-			old_expiry_lifetime = get_expiry (existing);
-			old_expiry_preferred = get_expiry_preferred (existing);
-
-			if (new->lifetime == NM_NDISC_INFINITY)
-				existing->lifetime = NM_NDISC_INFINITY;
-			else {
-				gint64 new_lifetime, remaining_lifetime;
-
-				/* see RFC4862 5.5.3.e */
-				if (existing->lifetime == NM_NDISC_INFINITY)
-					remaining_lifetime = G_MAXINT64;
-				else
-					remaining_lifetime = ((gint64) existing->timestamp) + ((gint64) existing->lifetime) - ((gint64) now_s);
-				new_lifetime = ((gint64) new->timestamp) + ((gint64) new->lifetime) - ((gint64) now_s);
-
-				if (   new_lifetime > (gint64) NM_NDISC_PREFIX_LFT_MIN
-				    || new_lifetime > remaining_lifetime) {
-					existing->timestamp = now_s;
-					existing->lifetime = CLAMP (new_lifetime, (gint64) 0, (gint64) (G_MAXUINT32 - 1));
-				} else if (remaining_lifetime <= (gint64) NM_NDISC_PREFIX_LFT_MIN) {
-					/* keep the current lifetime. */
-				} else {
-					existing->timestamp = now_s;
-					existing->lifetime = NM_NDISC_PREFIX_LFT_MIN;
-				}
-			}
-
-			if (new->preferred == NM_NDISC_INFINITY) {
-				nm_assert (existing->lifetime == NM_NDISC_INFINITY);
-				existing->preferred = new->preferred;
-			} else {
-				existing->preferred = NM_CLAMP (((gint64) new->timestamp) + ((gint64) new->preferred) - ((gint64) existing->timestamp),
-				                                0, G_MAXUINT32 - 1);
-				if (existing->lifetime != NM_NDISC_INFINITY)
-					existing->preferred = MIN (existing->preferred, existing->lifetime);
-			}
-
-			return    old_expiry_lifetime != get_expiry (existing)
-			       || old_expiry_preferred != get_expiry_preferred (existing);
-		}
-
-		if (new->lifetime == 0) {
-			g_array_remove_index (rdata->addresses, i);
-			return TRUE;
-		}
-
-		if (   get_expiry (existing) == get_expiry (new)
-		    && get_expiry_preferred (existing) == get_expiry_preferred (new))
-			return FALSE;
-
-		existing->timestamp = new->timestamp;
-		existing->lifetime = new->lifetime;
-		existing->preferred = new->preferred;
-		return TRUE;
-	}
-
-	/* we create at most max_addresses autoconf addresses. This is different from
-	 * what the kernel does, because it considers *all* addresses (including
-	 * static and other temporary addresses).
-	 **/
-	if (   priv->max_addresses
-	    && rdata->addresses->len >= priv->max_addresses)
-		return FALSE;
-
-	if (new->lifetime == 0)
-		return FALSE;
-
-	if (from_ra) {
-		new2 = *new;
-		new2.dad_counter = 0;
-		if (!complete_address (ndisc, &new2))
-			return FALSE;
-		new = &new2;
-	}
-
-	g_array_append_val (rdata->addresses, *new);
-	return TRUE;
+    NMNDiscPrivate *     priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    NMNDiscDataInternal *rdata = &priv->rdata;
+    NMNDiscAddress       new2;
+    NMNDiscAddress *     existing = NULL;
+    guint                i;
+
+    nm_assert(new);
+    nm_assert(new->timestamp > 0 && new->timestamp < G_MAXINT32);
+    nm_assert(!IN6_IS_ADDR_UNSPECIFIED(&new->address));
+    nm_assert(!IN6_IS_ADDR_LINKLOCAL(&new->address));
+    nm_assert(new->preferred <= new->lifetime);
+    nm_assert(!from_ra || now_s > 0);
+
+    for (i = 0; i < rdata->addresses->len; i++) {
+        NMNDiscAddress *item = &g_array_index(rdata->addresses, NMNDiscAddress, i);
+
+        if (from_ra) {
+            /* RFC4862 5.5.3.d, we find an existing address with the same prefix.
+             * (note that all prefixes at this point have implicitly length /64). */
+            if (memcmp(&item->address, &new->address, 8) == 0) {
+                existing = item;
+                break;
+            }
+        } else {
+            if (IN6_ARE_ADDR_EQUAL(&item->address, &new->address)) {
+                existing = item;
+                break;
+            }
+        }
+    }
+
+    if (existing) {
+        if (from_ra) {
+            const gint32 NM_NDISC_PREFIX_LFT_MIN = 7200; /* seconds, RFC4862 5.5.3.e */
+            gint64       old_expiry_lifetime, old_expiry_preferred;
+
+            old_expiry_lifetime  = get_expiry(existing);
+            old_expiry_preferred = get_expiry_preferred(existing);
+
+            if (new->lifetime == NM_NDISC_INFINITY)
+                existing->lifetime = NM_NDISC_INFINITY;
+            else {
+                gint64 new_lifetime, remaining_lifetime;
+
+                /* see RFC4862 5.5.3.e */
+                if (existing->lifetime == NM_NDISC_INFINITY)
+                    remaining_lifetime = G_MAXINT64;
+                else
+                    remaining_lifetime = ((gint64) existing->timestamp)
+                                         + ((gint64) existing->lifetime) - ((gint64) now_s);
+                new_lifetime =
+                    ((gint64) new->timestamp) + ((gint64) new->lifetime) - ((gint64) now_s);
+
+                if (new_lifetime > (gint64) NM_NDISC_PREFIX_LFT_MIN
+                    || new_lifetime > remaining_lifetime) {
+                    existing->timestamp = now_s;
+                    existing->lifetime = CLAMP(new_lifetime, (gint64) 0, (gint64)(G_MAXUINT32 - 1));
+                } else if (remaining_lifetime <= (gint64) NM_NDISC_PREFIX_LFT_MIN) {
+                    /* keep the current lifetime. */
+                } else {
+                    existing->timestamp = now_s;
+                    existing->lifetime  = NM_NDISC_PREFIX_LFT_MIN;
+                }
+            }
+
+            if (new->preferred == NM_NDISC_INFINITY) {
+                nm_assert(existing->lifetime == NM_NDISC_INFINITY);
+                existing->preferred = new->preferred;
+            } else {
+                existing->preferred = NM_CLAMP(((gint64) new->timestamp) + ((gint64) new->preferred)
+                                                   - ((gint64) existing->timestamp),
+                                               0,
+                                               G_MAXUINT32 - 1);
+                if (existing->lifetime != NM_NDISC_INFINITY)
+                    existing->preferred = MIN(existing->preferred, existing->lifetime);
+            }
+
+            return old_expiry_lifetime != get_expiry(existing)
+                   || old_expiry_preferred != get_expiry_preferred(existing);
+        }
+
+        if (new->lifetime == 0) {
+            g_array_remove_index(rdata->addresses, i);
+            return TRUE;
+        }
+
+        if (get_expiry(existing) == get_expiry(new)
+            && get_expiry_preferred(existing) == get_expiry_preferred(new))
+            return FALSE;
+
+        existing->timestamp = new->timestamp;
+        existing->lifetime  = new->lifetime;
+        existing->preferred = new->preferred;
+        return TRUE;
+    }
+
+    /* we create at most max_addresses autoconf addresses. This is different from
+     * what the kernel does, because it considers *all* addresses (including
+     * static and other temporary addresses).
+     **/
+    if (priv->max_addresses && rdata->addresses->len >= priv->max_addresses)
+        return FALSE;
+
+    if (new->lifetime == 0)
+        return FALSE;
+
+    if (from_ra) {
+        new2             = *new;
+        new2.dad_counter = 0;
+        if (!complete_address(ndisc, &new2))
+            return FALSE;
+        new = &new2;
+    }
+
+    g_array_append_val(rdata->addresses, *new);
+    return TRUE;
 }
 
 gboolean
-nm_ndisc_complete_and_add_address (NMNDisc *ndisc,
-                                   const NMNDiscAddress *new,
-                                   gint32 now_s)
+nm_ndisc_complete_and_add_address(NMNDisc *ndisc, const NMNDiscAddress *new, gint32 now_s)
 {
-	return nm_ndisc_add_address (ndisc, new, now_s, TRUE);
+    return nm_ndisc_add_address(ndisc, new, now_s, TRUE);
 }
 
 gboolean
-nm_ndisc_add_route (NMNDisc *ndisc, const NMNDiscRoute *new)
+nm_ndisc_add_route(NMNDisc *ndisc, const NMNDiscRoute *new)
 {
-	NMNDiscPrivate *priv;
-	NMNDiscDataInternal *rdata;
-	guint i;
-	guint insert_idx = G_MAXUINT;
-
-	if (new->plen == 0 || new->plen > 128) {
-		/* Only expect non-default routes.  The router has no idea what the
-		 * local configuration or user preferences are, so sending routes
-		 * with a prefix length of 0 must be ignored by NMNDisc.
-		 *
-		 * Also, upper layers also don't expect that NMNDisc exposes routes
-		 * with a plen or zero or larger then 128.
-		 */
-		g_return_val_if_reached (FALSE);
-	}
-
-	priv = NM_NDISC_GET_PRIVATE (ndisc);
-	rdata = &priv->rdata;
-
-	for (i = 0; i < rdata->routes->len; ) {
-		NMNDiscRoute *item = &g_array_index (rdata->routes, NMNDiscRoute, i);
-
-		if (   IN6_ARE_ADDR_EQUAL (&item->network, &new->network)
-		    && item->plen == new->plen) {
-			if (new->lifetime == 0) {
-				g_array_remove_index (rdata->routes, i);
-				return TRUE;
-			}
-
-			if (item->preference != new->preference) {
-				g_array_remove_index (rdata->routes, i);
-				continue;
-			}
-
-			if (   get_expiry (item) == get_expiry (new)
-			    && IN6_ARE_ADDR_EQUAL (&item->gateway, &new->gateway))
-				return FALSE;
-
-			*item = *new;
-			return TRUE;
-		}
-
-		/* Put before less preferable routes. */
-		if (   _preference_to_priority (item->preference) < _preference_to_priority (new->preference)
-		    && insert_idx == G_MAXUINT)
-			insert_idx = i;
-
-		i++;
-	}
-
-	if (new->lifetime) {
-		g_array_insert_val (rdata->routes,
-		                    insert_idx == G_MAXUINT
-		                      ? 0u
-		                      : insert_idx,
-		                    *new);
-	}
-	return !!new->lifetime;
+    NMNDiscPrivate *     priv;
+    NMNDiscDataInternal *rdata;
+    guint                i;
+    guint                insert_idx = G_MAXUINT;
+
+    if (new->plen == 0 || new->plen > 128) {
+        /* Only expect non-default routes.  The router has no idea what the
+         * local configuration or user preferences are, so sending routes
+         * with a prefix length of 0 must be ignored by NMNDisc.
+         *
+         * Also, upper layers also don't expect that NMNDisc exposes routes
+         * with a plen or zero or larger then 128.
+         */
+        g_return_val_if_reached(FALSE);
+    }
+
+    priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    rdata = &priv->rdata;
+
+    for (i = 0; i < rdata->routes->len;) {
+        NMNDiscRoute *item = &g_array_index(rdata->routes, NMNDiscRoute, i);
+
+        if (IN6_ARE_ADDR_EQUAL(&item->network, &new->network) && item->plen == new->plen) {
+            if (new->lifetime == 0) {
+                g_array_remove_index(rdata->routes, i);
+                return TRUE;
+            }
+
+            if (item->preference != new->preference) {
+                g_array_remove_index(rdata->routes, i);
+                continue;
+            }
+
+            if (get_expiry(item) == get_expiry(new)
+                && IN6_ARE_ADDR_EQUAL(&item->gateway, &new->gateway))
+                return FALSE;
+
+            *item = *new;
+            return TRUE;
+        }
+
+        /* Put before less preferable routes. */
+        if (_preference_to_priority(item->preference) < _preference_to_priority(new->preference)
+            && insert_idx == G_MAXUINT)
+            insert_idx = i;
+
+        i++;
+    }
+
+    if (new->lifetime) {
+        g_array_insert_val(rdata->routes, insert_idx == G_MAXUINT ? 0u : insert_idx, *new);
+    }
+    return !!new->lifetime;
 }
 
 gboolean
-nm_ndisc_add_dns_server (NMNDisc *ndisc, const NMNDiscDNSServer *new)
+nm_ndisc_add_dns_server(NMNDisc *ndisc, const NMNDiscDNSServer *new)
 {
-	NMNDiscPrivate *priv;
-	NMNDiscDataInternal *rdata;
-	guint i;
+    NMNDiscPrivate *     priv;
+    NMNDiscDataInternal *rdata;
+    guint                i;
 
-	priv = NM_NDISC_GET_PRIVATE (ndisc);
-	rdata = &priv->rdata;
+    priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    rdata = &priv->rdata;
 
-	for (i = 0; i < rdata->dns_servers->len; i++) {
-		NMNDiscDNSServer *item = &g_array_index (rdata->dns_servers, NMNDiscDNSServer, i);
+    for (i = 0; i < rdata->dns_servers->len; i++) {
+        NMNDiscDNSServer *item = &g_array_index(rdata->dns_servers, NMNDiscDNSServer, i);
 
-		if (IN6_ARE_ADDR_EQUAL (&item->address, &new->address)) {
-			if (new->lifetime == 0) {
-				g_array_remove_index (rdata->dns_servers, i);
-				return TRUE;
-			}
+        if (IN6_ARE_ADDR_EQUAL(&item->address, &new->address)) {
+            if (new->lifetime == 0) {
+                g_array_remove_index(rdata->dns_servers, i);
+                return TRUE;
+            }
 
-			if (get_expiry (item) == get_expiry (new))
-				return FALSE;
+            if (get_expiry(item) == get_expiry(new))
+                return FALSE;
 
-			*item = *new;
-			return TRUE;
-		}
-	}
+            *item = *new;
+            return TRUE;
+        }
+    }
 
-	if (new->lifetime)
-		g_array_append_val (rdata->dns_servers, *new);
-	return !!new->lifetime;
+    if (new->lifetime)
+        g_array_append_val(rdata->dns_servers, *new);
+    return !!new->lifetime;
 }
 
 /* Copies new->domain if 'new' is added to the dns_domains list */
 gboolean
-nm_ndisc_add_dns_domain (NMNDisc *ndisc, const NMNDiscDNSDomain *new)
+nm_ndisc_add_dns_domain(NMNDisc *ndisc, const NMNDiscDNSDomain *new)
 {
-	NMNDiscPrivate *priv;
-	NMNDiscDataInternal *rdata;
-	NMNDiscDNSDomain *item;
-	guint i;
-
-	priv = NM_NDISC_GET_PRIVATE (ndisc);
-	rdata = &priv->rdata;
-
-	for (i = 0; i < rdata->dns_domains->len; i++) {
-		item = &g_array_index (rdata->dns_domains, NMNDiscDNSDomain, i);
-
-		if (!g_strcmp0 (item->domain, new->domain)) {
-			if (new->lifetime == 0) {
-				g_array_remove_index (rdata->dns_domains, i);
-				return TRUE;
-			}
-
-			if (get_expiry (item) == get_expiry (new))
-				return FALSE;
-
-			item->timestamp = new->timestamp;
-			item->lifetime = new->lifetime;
-			return TRUE;
-		}
-	}
-
-	if (new->lifetime) {
-		g_array_append_val (rdata->dns_domains, *new);
-		item = &g_array_index (rdata->dns_domains,
-		                       NMNDiscDNSDomain,
-		                       rdata->dns_domains->len - 1);
-		item->domain = g_strdup (new->domain);
-	}
-	return !!new->lifetime;
+    NMNDiscPrivate *     priv;
+    NMNDiscDataInternal *rdata;
+    NMNDiscDNSDomain *   item;
+    guint                i;
+
+    priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    rdata = &priv->rdata;
+
+    for (i = 0; i < rdata->dns_domains->len; i++) {
+        item = &g_array_index(rdata->dns_domains, NMNDiscDNSDomain, i);
+
+        if (!g_strcmp0(item->domain, new->domain)) {
+            if (new->lifetime == 0) {
+                g_array_remove_index(rdata->dns_domains, i);
+                return TRUE;
+            }
+
+            if (get_expiry(item) == get_expiry(new))
+                return FALSE;
+
+            item->timestamp = new->timestamp;
+            item->lifetime  = new->lifetime;
+            return TRUE;
+        }
+    }
+
+    if (new->lifetime) {
+        g_array_append_val(rdata->dns_domains, *new);
+        item = &g_array_index(rdata->dns_domains, NMNDiscDNSDomain, rdata->dns_domains->len - 1);
+        item->domain = g_strdup(new->domain);
+    }
+    return !!new->lifetime;
 }
 
 /*****************************************************************************/
 
-#define _MAYBE_WARN(...) G_STMT_START { \
-		gboolean _different_message; \
-		\
-		_different_message = g_strcmp0 (priv->last_error, error->message) != 0; \
-		_NMLOG (_different_message ? LOGL_WARN : LOGL_DEBUG, __VA_ARGS__); \
-		if (_different_message) { \
-			nm_clear_g_free (&priv->last_error); \
-			priv->last_error = g_strdup (error->message); \
-		} \
-	} G_STMT_END
+#define _MAYBE_WARN(...)                                                       \
+    G_STMT_START                                                               \
+    {                                                                          \
+        gboolean _different_message;                                           \
+                                                                               \
+        _different_message = g_strcmp0(priv->last_error, error->message) != 0; \
+        _NMLOG(_different_message ? LOGL_WARN : LOGL_DEBUG, __VA_ARGS__);      \
+        if (_different_message) {                                              \
+            nm_clear_g_free(&priv->last_error);                                \
+            priv->last_error = g_strdup(error->message);                       \
+        }                                                                      \
+    }                                                                          \
+    G_STMT_END
 
 static gboolean
-send_rs_timeout (NMNDisc *ndisc)
+send_rs_timeout(NMNDisc *ndisc)
 {
-	nm_auto_pop_netns NMPNetns *netns = NULL;
-	NMNDiscClass *klass = NM_NDISC_GET_CLASS (ndisc);
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
-	GError *error = NULL;
-
-	priv->send_rs_id = 0;
-
-	if (!nm_ndisc_netns_push (ndisc, &netns))
-		return G_SOURCE_REMOVE;
-
-	if (klass->send_rs (ndisc, &error)) {
-		_LOGD ("router solicitation sent");
-		priv->solicitations_left--;
-		nm_clear_g_free (&priv->last_error);
-	} else {
-		_MAYBE_WARN ("failure sending router solicitation: %s", error->message);
-		g_clear_error (&error);
-	}
-
-	priv->last_rs = nm_utils_get_monotonic_timestamp_sec ();
-	if (priv->solicitations_left > 0) {
-		_LOGD ("scheduling router solicitation retry in %d seconds.",
-		       (int) priv->router_solicitation_interval);
-		priv->send_rs_id = g_timeout_add_seconds (priv->router_solicitation_interval,
-		                                          (GSourceFunc) send_rs_timeout, ndisc);
-	} else {
-		_LOGD ("did not receive a router advertisement after %d solicitations.",
-		       (int) priv->router_solicitations);
-	}
-
-	return G_SOURCE_REMOVE;
+    nm_auto_pop_netns NMPNetns *netns = NULL;
+    NMNDiscClass *              klass = NM_NDISC_GET_CLASS(ndisc);
+    NMNDiscPrivate *            priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    GError *                    error = NULL;
+
+    priv->send_rs_id = 0;
+
+    if (!nm_ndisc_netns_push(ndisc, &netns))
+        return G_SOURCE_REMOVE;
+
+    if (klass->send_rs(ndisc, &error)) {
+        _LOGD("router solicitation sent");
+        priv->solicitations_left--;
+        nm_clear_g_free(&priv->last_error);
+    } else {
+        _MAYBE_WARN("failure sending router solicitation: %s", error->message);
+        g_clear_error(&error);
+    }
+
+    priv->last_rs = nm_utils_get_monotonic_timestamp_sec();
+    if (priv->solicitations_left > 0) {
+        _LOGD("scheduling router solicitation retry in %d seconds.",
+              (int) priv->router_solicitation_interval);
+        priv->send_rs_id = g_timeout_add_seconds(priv->router_solicitation_interval,
+                                                 (GSourceFunc) send_rs_timeout,
+                                                 ndisc);
+    } else {
+        _LOGD("did not receive a router advertisement after %d solicitations.",
+              (int) priv->router_solicitations);
+    }
+
+    return G_SOURCE_REMOVE;
 }
 
 static void
-solicit_routers (NMNDisc *ndisc)
+solicit_routers(NMNDisc *ndisc)
 {
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
-	gint32 now, next;
-	gint64 t;
+    NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc);
+    gint32          now, next;
+    gint64          t;
 
-	if (priv->send_rs_id)
-		return;
+    if (priv->send_rs_id)
+        return;
 
-	now = nm_utils_get_monotonic_timestamp_sec ();
-	priv->solicitations_left = priv->router_solicitations;
+    now                      = nm_utils_get_monotonic_timestamp_sec();
+    priv->solicitations_left = priv->router_solicitations;
 
-	t = (((gint64) priv->last_rs) + priv->router_solicitation_interval) - now;
-	next = CLAMP (t, 0, G_MAXINT32);
-	_LOGD ("scheduling explicit router solicitation request in %" G_GINT32_FORMAT " seconds.",
-	       next);
-	priv->send_rs_id = g_timeout_add_seconds ((guint32) next, (GSourceFunc) send_rs_timeout, ndisc);
+    t    = (((gint64) priv->last_rs) + priv->router_solicitation_interval) - now;
+    next = CLAMP(t, 0, G_MAXINT32);
+    _LOGD("scheduling explicit router solicitation request in %" G_GINT32_FORMAT " seconds.", next);
+    priv->send_rs_id = g_timeout_add_seconds((guint32) next, (GSourceFunc) send_rs_timeout, ndisc);
 }
 
 static gboolean
-announce_router (NMNDisc *ndisc)
+announce_router(NMNDisc *ndisc)
 {
-	nm_auto_pop_netns NMPNetns *netns = NULL;
-	NMNDiscClass *klass = NM_NDISC_GET_CLASS (ndisc);
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
-	GError *error = NULL;
-
-	if (!nm_ndisc_netns_push (ndisc, &netns))
-		return G_SOURCE_REMOVE;
-
-	priv->last_ra = nm_utils_get_monotonic_timestamp_sec ();
-	if (klass->send_ra (ndisc, &error)) {
-		_LOGD ("router advertisement sent");
-		nm_clear_g_free (&priv->last_error);
-	} else {
-		_MAYBE_WARN ("failure sending router advertisement: %s", error->message);
-		g_clear_error (&error);
-	}
-
-	if (--priv->announcements_left) {
-		_LOGD ("will resend an initial router advertisement");
-
-		/* Schedule next initial announcement retransmit. */
-		priv->send_ra_id = g_timeout_add_seconds (g_random_int_range (NM_NDISC_ROUTER_ADVERT_DELAY,
-		                                                              NM_NDISC_ROUTER_ADVERT_INITIAL_INTERVAL),
-		                                          (GSourceFunc) announce_router, ndisc);
-	} else {
-		_LOGD ("will send an unsolicited router advertisement");
-
-		/* Schedule next unsolicited announcement. */
-		priv->announcements_left = 1;
-		priv->send_ra_id = g_timeout_add_seconds (NM_NDISC_ROUTER_ADVERT_MAX_INTERVAL,
-		                                          (GSourceFunc) announce_router,
-		                                          ndisc);
-	}
-
-	return G_SOURCE_REMOVE;
+    nm_auto_pop_netns NMPNetns *netns = NULL;
+    NMNDiscClass *              klass = NM_NDISC_GET_CLASS(ndisc);
+    NMNDiscPrivate *            priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    GError *                    error = NULL;
+
+    if (!nm_ndisc_netns_push(ndisc, &netns))
+        return G_SOURCE_REMOVE;
+
+    priv->last_ra = nm_utils_get_monotonic_timestamp_sec();
+    if (klass->send_ra(ndisc, &error)) {
+        _LOGD("router advertisement sent");
+        nm_clear_g_free(&priv->last_error);
+    } else {
+        _MAYBE_WARN("failure sending router advertisement: %s", error->message);
+        g_clear_error(&error);
+    }
+
+    if (--priv->announcements_left) {
+        _LOGD("will resend an initial router advertisement");
+
+        /* Schedule next initial announcement retransmit. */
+        priv->send_ra_id =
+            g_timeout_add_seconds(g_random_int_range(NM_NDISC_ROUTER_ADVERT_DELAY,
+                                                     NM_NDISC_ROUTER_ADVERT_INITIAL_INTERVAL),
+                                  (GSourceFunc) announce_router,
+                                  ndisc);
+    } else {
+        _LOGD("will send an unsolicited router advertisement");
+
+        /* Schedule next unsolicited announcement. */
+        priv->announcements_left = 1;
+        priv->send_ra_id         = g_timeout_add_seconds(NM_NDISC_ROUTER_ADVERT_MAX_INTERVAL,
+                                                 (GSourceFunc) announce_router,
+                                                 ndisc);
+    }
+
+    return G_SOURCE_REMOVE;
 }
 
 static void
-announce_router_initial (NMNDisc *ndisc)
+announce_router_initial(NMNDisc *ndisc)
 {
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
-
-	_LOGD ("will send an initial router advertisement");
-
-	/* Retry three more times. */
-	priv->announcements_left = NM_NDISC_ROUTER_ADVERTISEMENTS_DEFAULT;
-
-	/* Unschedule an unsolicited resend if we are allowed to send now. */
-	if (G_LIKELY (nm_utils_get_monotonic_timestamp_sec () - priv->last_ra > NM_NDISC_ROUTER_ADVERT_DELAY))
-		nm_clear_g_source (&priv->send_ra_id);
-
-	/* Schedule the initial send rather early. Clamp the delay by minimal
-	 * delay and not the initial advert internal so that we start fast. */
-	if (G_LIKELY (!priv->send_ra_id)) {
-		priv->send_ra_id = g_timeout_add_seconds (g_random_int_range (0, NM_NDISC_ROUTER_ADVERT_DELAY),
-		                                          (GSourceFunc) announce_router, ndisc);
-	}
+    NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc);
+
+    _LOGD("will send an initial router advertisement");
+
+    /* Retry three more times. */
+    priv->announcements_left = NM_NDISC_ROUTER_ADVERTISEMENTS_DEFAULT;
+
+    /* Unschedule an unsolicited resend if we are allowed to send now. */
+    if (G_LIKELY(nm_utils_get_monotonic_timestamp_sec() - priv->last_ra
+                 > NM_NDISC_ROUTER_ADVERT_DELAY))
+        nm_clear_g_source(&priv->send_ra_id);
+
+    /* Schedule the initial send rather early. Clamp the delay by minimal
+     * delay and not the initial advert internal so that we start fast. */
+    if (G_LIKELY(!priv->send_ra_id)) {
+        priv->send_ra_id =
+            g_timeout_add_seconds(g_random_int_range(0, NM_NDISC_ROUTER_ADVERT_DELAY),
+                                  (GSourceFunc) announce_router,
+                                  ndisc);
+    }
 }
 
 static void
-announce_router_solicited (NMNDisc *ndisc)
+announce_router_solicited(NMNDisc *ndisc)
 {
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
+    NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc);
 
-	_LOGD ("will send an solicited router advertisement");
+    _LOGD("will send an solicited router advertisement");
 
-	/* Unschedule an unsolicited resend if we are allowed to send now. */
-	if (nm_utils_get_monotonic_timestamp_sec () - priv->last_ra > NM_NDISC_ROUTER_ADVERT_DELAY)
-		nm_clear_g_source (&priv->send_ra_id);
+    /* Unschedule an unsolicited resend if we are allowed to send now. */
+    if (nm_utils_get_monotonic_timestamp_sec() - priv->last_ra > NM_NDISC_ROUTER_ADVERT_DELAY)
+        nm_clear_g_source(&priv->send_ra_id);
 
-	if (!priv->send_ra_id) {
-		priv->send_ra_id = g_timeout_add (g_random_int_range (0, NM_NDISC_ROUTER_ADVERT_DELAY_MS),
-		                                  (GSourceFunc) announce_router, ndisc);
-	}
+    if (!priv->send_ra_id) {
+        priv->send_ra_id = g_timeout_add(g_random_int_range(0, NM_NDISC_ROUTER_ADVERT_DELAY_MS),
+                                         (GSourceFunc) announce_router,
+                                         ndisc);
+    }
 }
 
 /*****************************************************************************/
 
 void
-nm_ndisc_set_config (NMNDisc *ndisc,
-                     const GArray *addresses,
-                     const GArray *dns_servers,
-                     const GArray *dns_domains)
+nm_ndisc_set_config(NMNDisc *     ndisc,
+                    const GArray *addresses,
+                    const GArray *dns_servers,
+                    const GArray *dns_domains)
 {
-	gboolean changed = FALSE;
-	guint i;
-
-	for (i = 0; i < addresses->len; i++) {
-		if (nm_ndisc_add_address (ndisc, &g_array_index (addresses, NMNDiscAddress, i), 0, FALSE))
-			changed = TRUE;
-	}
-
-	for (i = 0; i < dns_servers->len; i++) {
-		if (nm_ndisc_add_dns_server (ndisc, &g_array_index (dns_servers, NMNDiscDNSServer, i)))
-			changed = TRUE;
-	}
-
-	for (i = 0; i < dns_domains->len; i++) {
-		if (nm_ndisc_add_dns_domain (ndisc, &g_array_index (dns_domains, NMNDiscDNSDomain, i)))
-			changed = TRUE;
-	}
-
-	if (changed)
-		announce_router_initial (ndisc);
+    gboolean changed = FALSE;
+    guint    i;
+
+    for (i = 0; i < addresses->len; i++) {
+        if (nm_ndisc_add_address(ndisc, &g_array_index(addresses, NMNDiscAddress, i), 0, FALSE))
+            changed = TRUE;
+    }
+
+    for (i = 0; i < dns_servers->len; i++) {
+        if (nm_ndisc_add_dns_server(ndisc, &g_array_index(dns_servers, NMNDiscDNSServer, i)))
+            changed = TRUE;
+    }
+
+    for (i = 0; i < dns_domains->len; i++) {
+        if (nm_ndisc_add_dns_domain(ndisc, &g_array_index(dns_domains, NMNDiscDNSDomain, i)))
+            changed = TRUE;
+    }
+
+    if (changed)
+        announce_router_initial(ndisc);
 }
 
 /**
@@ -866,645 +979,718 @@ nm_ndisc_set_config (NMNDisc *ndisc,
  * Returns: %TRUE if addresses need to be regenerated, %FALSE otherwise.
  **/
 gboolean
-nm_ndisc_set_iid (NMNDisc *ndisc, const NMUtilsIPv6IfaceId iid)
+nm_ndisc_set_iid(NMNDisc *ndisc, const NMUtilsIPv6IfaceId iid)
 {
-	NMNDiscPrivate *priv;
-	NMNDiscDataInternal *rdata;
+    NMNDiscPrivate *     priv;
+    NMNDiscDataInternal *rdata;
 
-	g_return_val_if_fail (NM_IS_NDISC (ndisc), FALSE);
+    g_return_val_if_fail(NM_IS_NDISC(ndisc), FALSE);
 
-	priv = NM_NDISC_GET_PRIVATE (ndisc);
-	rdata = &priv->rdata;
+    priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    rdata = &priv->rdata;
 
-	if (priv->iid.id != iid.id) {
-		priv->iid = iid;
+    if (priv->iid.id != iid.id) {
+        priv->iid = iid;
 
-		if (priv->addr_gen_mode == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY)
-			return FALSE;
+        if (priv->addr_gen_mode == NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY)
+            return FALSE;
 
-		if (rdata->addresses->len) {
-			_LOGD ("IPv6 interface identifier changed, flushing addresses");
-			g_array_remove_range (rdata->addresses, 0, rdata->addresses->len);
-			nm_ndisc_emit_config_change (ndisc, NM_NDISC_CONFIG_ADDRESSES);
-			solicit_routers (ndisc);
-		}
-		return TRUE;
-	}
+        if (rdata->addresses->len) {
+            _LOGD("IPv6 interface identifier changed, flushing addresses");
+            g_array_remove_range(rdata->addresses, 0, rdata->addresses->len);
+            nm_ndisc_emit_config_change(ndisc, NM_NDISC_CONFIG_ADDRESSES);
+            solicit_routers(ndisc);
+        }
+        return TRUE;
+    }
 
-	return FALSE;
+    return FALSE;
 }
 
 static gboolean
-ndisc_ra_timeout_cb (gpointer user_data)
+ndisc_ra_timeout_cb(gpointer user_data)
 {
-	NMNDisc *ndisc = NM_NDISC (user_data);
+    NMNDisc *ndisc = NM_NDISC(user_data);
+
+    nm_clear_g_source_inst(&NM_NDISC_GET_PRIVATE(ndisc)->ra_timeout_source);
+    g_signal_emit(ndisc, signals[RA_TIMEOUT_SIGNAL], 0);
+    return G_SOURCE_REMOVE;
+}
 
-	NM_NDISC_GET_PRIVATE (ndisc)->ra_timeout_id = 0;
-	g_signal_emit (ndisc, signals[RA_TIMEOUT_SIGNAL], 0);
-	return G_SOURCE_REMOVE;
+void
+nm_ndisc_start(NMNDisc *ndisc)
+{
+    nm_auto_pop_netns NMPNetns *netns = NULL;
+    NMNDiscPrivate *            priv;
+
+    g_return_if_fail(NM_IS_NDISC(ndisc));
+
+    priv = NM_NDISC_GET_PRIVATE(ndisc);
+
+    nm_assert(NM_NDISC_GET_CLASS(ndisc)->start);
+    nm_assert(!priv->ra_timeout_source);
+
+    _LOGD("starting neighbor discovery for ifindex %d%s",
+          priv->ifindex,
+          priv->node_type == NM_NDISC_NODE_TYPE_HOST ? " (solicit)" : " (announce)");
+
+    if (!nm_ndisc_netns_push(ndisc, &netns))
+        return;
+
+    NM_NDISC_GET_CLASS(ndisc)->start(ndisc);
+
+    if (priv->node_type == NM_NDISC_NODE_TYPE_HOST) {
+        G_STATIC_ASSERT_EXPR(NM_RA_TIMEOUT_DEFAULT == 0);
+        G_STATIC_ASSERT_EXPR(NM_RA_TIMEOUT_INFINITY == G_MAXINT32);
+        nm_assert(priv->ra_timeout > 0u);
+        nm_assert(priv->ra_timeout <= NM_RA_TIMEOUT_INFINITY);
+
+        if (priv->ra_timeout < NM_RA_TIMEOUT_INFINITY) {
+            guint timeout_msec;
+
+            _LOGD("scheduling RA timeout in %u seconds", priv->ra_timeout);
+            if (priv->ra_timeout < G_MAXUINT / 1000u)
+                timeout_msec = priv->ra_timeout * 1000u;
+            else
+                timeout_msec = G_MAXUINT;
+            priv->ra_timeout_source = nm_g_timeout_source_new(timeout_msec,
+                                                              G_PRIORITY_DEFAULT,
+                                                              ndisc_ra_timeout_cb,
+                                                              ndisc,
+                                                              NULL);
+            g_source_attach(priv->ra_timeout_source, NULL);
+        }
+
+        solicit_routers(ndisc);
+        return;
+    }
+
+    nm_assert(priv->ra_timeout == 0u);
+    nm_assert(priv->node_type == NM_NDISC_NODE_TYPE_ROUTER);
+    announce_router_initial(ndisc);
 }
 
 void
-nm_ndisc_start (NMNDisc *ndisc)
+nm_ndisc_stop(NMNDisc *ndisc)
 {
-	nm_auto_pop_netns NMPNetns *netns = NULL;
-	NMNDiscPrivate *priv;
-
-	g_return_if_fail (NM_IS_NDISC (ndisc));
-
-	priv = NM_NDISC_GET_PRIVATE (ndisc);
-
-	nm_assert (NM_NDISC_GET_CLASS (ndisc)->start);
-	nm_assert (!priv->ra_timeout_id);
-
-	_LOGD ("starting neighbor discovery for ifindex %d%s",
-	       priv->ifindex,
-	         priv->node_type == NM_NDISC_NODE_TYPE_HOST
-	       ? " (solicit)"
-	       : " (announce)");
-
-	if (!nm_ndisc_netns_push (ndisc, &netns))
-		return;
-
-	NM_NDISC_GET_CLASS (ndisc)->start (ndisc);
-
-	if (priv->node_type == NM_NDISC_NODE_TYPE_HOST) {
-		gint32 ra_timeout = priv->ra_timeout;
-
-		G_STATIC_ASSERT_EXPR (NM_RA_TIMEOUT_DEFAULT == 0);
-		G_STATIC_ASSERT_EXPR (NM_RA_TIMEOUT_INFINITY == G_MAXINT32);
-		if (ra_timeout != NM_RA_TIMEOUT_INFINITY) {
-			if (ra_timeout == NM_RA_TIMEOUT_DEFAULT) {
-				ra_timeout = NM_MAX ((((gint64) priv->router_solicitations) * priv->router_solicitation_interval) + 1,
-				                     30);
-			}
-			nm_assert (ra_timeout > 0 && ra_timeout < NM_RA_TIMEOUT_INFINITY);
-			_LOGD ("scheduling RA timeout in %d seconds", ra_timeout);
-			priv->ra_timeout_id = g_timeout_add_seconds (ra_timeout, ndisc_ra_timeout_cb, ndisc);
-		}
-		solicit_routers (ndisc);
-		return;
-	}
-
-	nm_assert (priv->node_type == NM_NDISC_NODE_TYPE_ROUTER);
-	announce_router_initial (ndisc);
+    nm_auto_pop_netns NMPNetns *netns = NULL;
+    NMNDiscDataInternal *       rdata;
+    NMNDiscPrivate *            priv;
+
+    g_return_if_fail(NM_IS_NDISC(ndisc));
+
+    priv = NM_NDISC_GET_PRIVATE(ndisc);
+
+    nm_assert(NM_NDISC_GET_CLASS(ndisc)->stop);
+
+    _LOGD("stopping neighbor discovery for ifindex %d", priv->ifindex);
+
+    if (!nm_ndisc_netns_push(ndisc, &netns))
+        return;
+
+    NM_NDISC_GET_CLASS(ndisc)->stop(ndisc);
+
+    rdata = &priv->rdata;
+
+    g_array_set_size(rdata->gateways, 0);
+    g_array_set_size(rdata->addresses, 0);
+    g_array_set_size(rdata->routes, 0);
+    g_array_set_size(rdata->dns_servers, 0);
+    g_array_set_size(rdata->dns_domains, 0);
+    priv->rdata.public.hop_limit = 64;
+
+    /* Start at very low number so that last_rs - router_solicitation_interval
+     * is much lower than nm_utils_get_monotonic_timestamp_sec() at startup.
+     */
+    priv->last_rs = G_MININT32;
+    nm_clear_g_source_inst(&priv->ra_timeout_source);
+    nm_clear_g_source(&priv->send_rs_id);
+    nm_clear_g_source(&priv->send_ra_id);
+    nm_clear_g_free(&priv->last_error);
+    nm_clear_g_source(&priv->timeout_id);
+
+    priv->solicitations_left = 0;
+    priv->announcements_left = 0;
+
+    priv->last_rs = G_MININT32;
+    priv->last_ra = G_MININT32;
 }
 
 NMNDiscConfigMap
-nm_ndisc_dad_failed (NMNDisc *ndisc, const struct in6_addr *address, gboolean emit_changed_signal)
+nm_ndisc_dad_failed(NMNDisc *ndisc, const struct in6_addr *address, gboolean emit_changed_signal)
 {
-	NMNDiscDataInternal *rdata;
-	guint i;
-	gboolean changed = FALSE;
+    NMNDiscDataInternal *rdata;
+    guint                i;
+    gboolean             changed = FALSE;
 
-	rdata = &NM_NDISC_GET_PRIVATE (ndisc)->rdata;
+    rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata;
 
-	for (i = 0; i < rdata->addresses->len; ) {
-		NMNDiscAddress *item = &g_array_index (rdata->addresses, NMNDiscAddress, i);
+    for (i = 0; i < rdata->addresses->len;) {
+        NMNDiscAddress *item = &g_array_index(rdata->addresses, NMNDiscAddress, i);
 
-		if (IN6_ARE_ADDR_EQUAL (&item->address, address)) {
-			char sbuf[NM_UTILS_INET_ADDRSTRLEN];
+        if (IN6_ARE_ADDR_EQUAL(&item->address, address)) {
+            char sbuf[NM_UTILS_INET_ADDRSTRLEN];
 
-			_LOGD ("DAD failed for discovered address %s", _nm_utils_inet6_ntop (address, sbuf));
-			changed = TRUE;
-			if (!complete_address (ndisc, item)) {
-				g_array_remove_index (rdata->addresses, i);
-				continue;
-			}
-		}
-		i++;
-	}
+            _LOGD("DAD failed for discovered address %s", _nm_utils_inet6_ntop(address, sbuf));
+            changed = TRUE;
+            if (!complete_address(ndisc, item)) {
+                g_array_remove_index(rdata->addresses, i);
+                continue;
+            }
+        }
+        i++;
+    }
 
-	if (emit_changed_signal && changed)
-		nm_ndisc_emit_config_change (ndisc, NM_NDISC_CONFIG_ADDRESSES);
+    if (emit_changed_signal && changed)
+        nm_ndisc_emit_config_change(ndisc, NM_NDISC_CONFIG_ADDRESSES);
 
-	return changed ? NM_NDISC_CONFIG_ADDRESSES : NM_NDISC_CONFIG_NONE;
+    return changed ? NM_NDISC_CONFIG_ADDRESSES : NM_NDISC_CONFIG_NONE;
 }
 
 #define CONFIG_MAP_MAX_STR 7
 
 static void
-config_map_to_string (NMNDiscConfigMap map, char *p)
+config_map_to_string(NMNDiscConfigMap map, char *p)
 {
-	if (map & NM_NDISC_CONFIG_DHCP_LEVEL)
-		*p++ = 'd';
-	if (map & NM_NDISC_CONFIG_GATEWAYS)
-		*p++ = 'G';
-	if (map & NM_NDISC_CONFIG_ADDRESSES)
-		*p++ = 'A';
-	if (map & NM_NDISC_CONFIG_ROUTES)
-		*p++ = 'R';
-	if (map & NM_NDISC_CONFIG_DNS_SERVERS)
-		*p++ = 'S';
-	if (map & NM_NDISC_CONFIG_DNS_DOMAINS)
-		*p++ = 'D';
-	*p = '\0';
+    if (map & NM_NDISC_CONFIG_DHCP_LEVEL)
+        *p++ = 'd';
+    if (map & NM_NDISC_CONFIG_GATEWAYS)
+        *p++ = 'G';
+    if (map & NM_NDISC_CONFIG_ADDRESSES)
+        *p++ = 'A';
+    if (map & NM_NDISC_CONFIG_ROUTES)
+        *p++ = 'R';
+    if (map & NM_NDISC_CONFIG_DNS_SERVERS)
+        *p++ = 'S';
+    if (map & NM_NDISC_CONFIG_DNS_DOMAINS)
+        *p++ = 'D';
+    *p = '\0';
 }
 
 static const char *
-dhcp_level_to_string (NMNDiscDHCPLevel dhcp_level)
+dhcp_level_to_string(NMNDiscDHCPLevel dhcp_level)
 {
-	switch (dhcp_level) {
-	case NM_NDISC_DHCP_LEVEL_NONE:
-		return "none";
-	case NM_NDISC_DHCP_LEVEL_OTHERCONF:
-		return "otherconf";
-	case NM_NDISC_DHCP_LEVEL_MANAGED:
-		return "managed";
-	default:
-		return "INVALID";
-	}
+    switch (dhcp_level) {
+    case NM_NDISC_DHCP_LEVEL_NONE:
+        return "none";
+    case NM_NDISC_DHCP_LEVEL_OTHERCONF:
+        return "otherconf";
+    case NM_NDISC_DHCP_LEVEL_MANAGED:
+        return "managed";
+    default:
+        return "INVALID";
+    }
 }
 
 static void
-_config_changed_log (NMNDisc *ndisc, NMNDiscConfigMap changed)
+_config_changed_log(NMNDisc *ndisc, NMNDiscConfigMap changed)
 {
-	NMNDiscPrivate *priv;
-	NMNDiscDataInternal *rdata;
-	guint i;
-	char changedstr[CONFIG_MAP_MAX_STR];
-	char addrstr[INET6_ADDRSTRLEN];
-	char str_pref[35];
-	char str_exp[100];
-	gint64 now_ns;
-
-	if (!_LOGD_ENABLED ())
-		return;
-
-	now_ns = nm_utils_get_monotonic_timestamp_nsec ();
-
-	priv = NM_NDISC_GET_PRIVATE (ndisc);
-	rdata = &priv->rdata;
-
-	config_map_to_string (changed, changedstr);
-	_LOGD ("neighbor discovery configuration changed [%s]:", changedstr);
-	_LOGD ("  dhcp-level %s", dhcp_level_to_string (priv->rdata.public.dhcp_level));
-
-	if (rdata->public.hop_limit)
-		_LOGD ("  hop limit      : %d", rdata->public.hop_limit);
-	if (rdata->public.reachable_time_ms)
-		_LOGD ("  reachable time : %u", (guint) rdata->public.reachable_time_ms);
-	if (rdata->public.retrans_timer_ms)
-		_LOGD ("  retrans timer  : %u", (guint) rdata->public.retrans_timer_ms);
-
-	for (i = 0; i < rdata->gateways->len; i++) {
-		NMNDiscGateway *gateway = &g_array_index (rdata->gateways, NMNDiscGateway, i);
-
-		inet_ntop (AF_INET6, &gateway->address, addrstr, sizeof (addrstr));
-		_LOGD ("  gateway %s pref %s exp %s", addrstr,
-		       nm_icmpv6_router_pref_to_string (gateway->preference, str_pref, sizeof (str_pref)),
-		       get_exp (str_exp, now_ns, gateway));
-	}
-	for (i = 0; i < rdata->addresses->len; i++) {
-		const NMNDiscAddress *address = &g_array_index (rdata->addresses, NMNDiscAddress, i);
-
-		inet_ntop (AF_INET6, &address->address, addrstr, sizeof (addrstr));
-		_LOGD ("  address %s exp %s", addrstr,
-		       get_exp (str_exp, now_ns, address));
-	}
-	for (i = 0; i < rdata->routes->len; i++) {
-		NMNDiscRoute *route = &g_array_index (rdata->routes, NMNDiscRoute, i);
-		char sbuf[NM_UTILS_INET_ADDRSTRLEN];
-
-		inet_ntop (AF_INET6, &route->network, addrstr, sizeof (addrstr));
-		_LOGD ("  route %s/%u via %s pref %s exp %s", addrstr, (guint) route->plen,
-		       _nm_utils_inet6_ntop (&route->gateway, sbuf),
-		       nm_icmpv6_router_pref_to_string (route->preference, str_pref, sizeof (str_pref)),
-		       get_exp (str_exp, now_ns, route));
-	}
-	for (i = 0; i < rdata->dns_servers->len; i++) {
-		NMNDiscDNSServer *dns_server = &g_array_index (rdata->dns_servers, NMNDiscDNSServer, i);
-
-		inet_ntop (AF_INET6, &dns_server->address, addrstr, sizeof (addrstr));
-		_LOGD ("  dns_server %s exp %s", addrstr,
-		       get_exp (str_exp, now_ns, dns_server));
-	}
-	for (i = 0; i < rdata->dns_domains->len; i++) {
-		NMNDiscDNSDomain *dns_domain = &g_array_index (rdata->dns_domains, NMNDiscDNSDomain, i);
-
-		_LOGD ("  dns_domain %s exp %s", dns_domain->domain,
-		       get_exp (str_exp, now_ns, dns_domain));
-	}
+    NMNDiscPrivate *     priv;
+    NMNDiscDataInternal *rdata;
+    guint                i;
+    char                 changedstr[CONFIG_MAP_MAX_STR];
+    char                 addrstr[INET6_ADDRSTRLEN];
+    char                 str_pref[35];
+    char                 str_exp[100];
+    gint64               now_ns;
+
+    if (!_LOGD_ENABLED())
+        return;
+
+    now_ns = nm_utils_get_monotonic_timestamp_nsec();
+
+    priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    rdata = &priv->rdata;
+
+    config_map_to_string(changed, changedstr);
+    _LOGD("neighbor discovery configuration changed [%s]:", changedstr);
+    _LOGD("  dhcp-level %s", dhcp_level_to_string(priv->rdata.public.dhcp_level));
+
+    if (rdata->public.hop_limit)
+        _LOGD("  hop limit      : %d", rdata->public.hop_limit);
+    if (rdata->public.reachable_time_ms)
+        _LOGD("  reachable time : %u", (guint) rdata->public.reachable_time_ms);
+    if (rdata->public.retrans_timer_ms)
+        _LOGD("  retrans timer  : %u", (guint) rdata->public.retrans_timer_ms);
+
+    for (i = 0; i < rdata->gateways->len; i++) {
+        NMNDiscGateway *gateway = &g_array_index(rdata->gateways, NMNDiscGateway, i);
+
+        inet_ntop(AF_INET6, &gateway->address, addrstr, sizeof(addrstr));
+        _LOGD("  gateway %s pref %s exp %s",
+              addrstr,
+              nm_icmpv6_router_pref_to_string(gateway->preference, str_pref, sizeof(str_pref)),
+              get_exp(str_exp, now_ns, gateway));
+    }
+    for (i = 0; i < rdata->addresses->len; i++) {
+        const NMNDiscAddress *address = &g_array_index(rdata->addresses, NMNDiscAddress, i);
+
+        inet_ntop(AF_INET6, &address->address, addrstr, sizeof(addrstr));
+        _LOGD("  address %s exp %s", addrstr, get_exp(str_exp, now_ns, address));
+    }
+    for (i = 0; i < rdata->routes->len; i++) {
+        NMNDiscRoute *route = &g_array_index(rdata->routes, NMNDiscRoute, i);
+        char          sbuf[NM_UTILS_INET_ADDRSTRLEN];
+
+        inet_ntop(AF_INET6, &route->network, addrstr, sizeof(addrstr));
+        _LOGD("  route %s/%u via %s pref %s exp %s",
+              addrstr,
+              (guint) route->plen,
+              _nm_utils_inet6_ntop(&route->gateway, sbuf),
+              nm_icmpv6_router_pref_to_string(route->preference, str_pref, sizeof(str_pref)),
+              get_exp(str_exp, now_ns, route));
+    }
+    for (i = 0; i < rdata->dns_servers->len; i++) {
+        NMNDiscDNSServer *dns_server = &g_array_index(rdata->dns_servers, NMNDiscDNSServer, i);
+
+        inet_ntop(AF_INET6, &dns_server->address, addrstr, sizeof(addrstr));
+        _LOGD("  dns_server %s exp %s", addrstr, get_exp(str_exp, now_ns, dns_server));
+    }
+    for (i = 0; i < rdata->dns_domains->len; i++) {
+        NMNDiscDNSDomain *dns_domain = &g_array_index(rdata->dns_domains, NMNDiscDNSDomain, i);
+
+        _LOGD("  dns_domain %s exp %s", dns_domain->domain, get_exp(str_exp, now_ns, dns_domain));
+    }
 }
 
 static void
-clean_gateways (NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
+clean_gateways(NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
 {
-	NMNDiscDataInternal *rdata;
-	guint i;
+    NMNDiscDataInternal *rdata;
+    guint                i;
 
-	rdata = &NM_NDISC_GET_PRIVATE (ndisc)->rdata;
+    rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata;
 
-	for (i = 0; i < rdata->gateways->len; ) {
-		NMNDiscGateway *item = &g_array_index (rdata->gateways, NMNDiscGateway, i);
+    for (i = 0; i < rdata->gateways->len;) {
+        NMNDiscGateway *item = &g_array_index(rdata->gateways, NMNDiscGateway, i);
 
-		if (!expiry_next (now, get_expiry (item), nextevent)) {
-			g_array_remove_index (rdata->gateways, i);
-			*changed |= NM_NDISC_CONFIG_GATEWAYS;
-			continue;
-		}
+        if (!expiry_next(now, get_expiry(item), nextevent)) {
+            g_array_remove_index(rdata->gateways, i);
+            *changed |= NM_NDISC_CONFIG_GATEWAYS;
+            continue;
+        }
 
-		i++;
-	}
+        i++;
+    }
 
-	_ASSERT_data_gateways (rdata);
+    _ASSERT_data_gateways(rdata);
 }
 
 static void
-clean_addresses (NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
+clean_addresses(NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
 {
-	NMNDiscDataInternal *rdata;
-	guint i;
+    NMNDiscDataInternal *rdata;
+    guint                i;
 
-	rdata = &NM_NDISC_GET_PRIVATE (ndisc)->rdata;
+    rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata;
 
-	for (i = 0; i < rdata->addresses->len; ) {
-		const NMNDiscAddress *item = &g_array_index (rdata->addresses, NMNDiscAddress, i);
+    for (i = 0; i < rdata->addresses->len;) {
+        const NMNDiscAddress *item = &g_array_index(rdata->addresses, NMNDiscAddress, i);
 
-		if (!expiry_next (now, get_expiry (item), nextevent)) {
-			g_array_remove_index (rdata->addresses, i);
-			*changed |= NM_NDISC_CONFIG_ADDRESSES;
-			continue;
-		}
+        if (!expiry_next(now, get_expiry(item), nextevent)) {
+            g_array_remove_index(rdata->addresses, i);
+            *changed |= NM_NDISC_CONFIG_ADDRESSES;
+            continue;
+        }
 
-		i++;
-	}
+        i++;
+    }
 }
 
 static void
-clean_routes (NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
+clean_routes(NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
 {
-	NMNDiscDataInternal *rdata;
-	guint i;
+    NMNDiscDataInternal *rdata;
+    guint                i;
 
-	rdata = &NM_NDISC_GET_PRIVATE (ndisc)->rdata;
+    rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata;
 
-	for (i = 0; i < rdata->routes->len; ) {
-		NMNDiscRoute *item = &g_array_index (rdata->routes, NMNDiscRoute, i);
+    for (i = 0; i < rdata->routes->len;) {
+        NMNDiscRoute *item = &g_array_index(rdata->routes, NMNDiscRoute, i);
 
-		if (!expiry_next (now, get_expiry (item), nextevent)) {
-			g_array_remove_index (rdata->routes, i);
-			*changed |= NM_NDISC_CONFIG_ROUTES;
-			continue;
-		}
+        if (!expiry_next(now, get_expiry(item), nextevent)) {
+            g_array_remove_index(rdata->routes, i);
+            *changed |= NM_NDISC_CONFIG_ROUTES;
+            continue;
+        }
 
-		i++;
-	}
+        i++;
+    }
 }
 
 static void
-clean_dns_servers (NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
+clean_dns_servers(NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
 {
-	NMNDiscDataInternal *rdata;
-	guint i;
-
-	rdata = &NM_NDISC_GET_PRIVATE (ndisc)->rdata;
-
-	for (i = 0; i < rdata->dns_servers->len; ) {
-		NMNDiscDNSServer *item = &g_array_index (rdata->dns_servers, NMNDiscDNSServer, i);
-		gint64 refresh;
-
-		refresh = get_expiry_half (item);
-		if (refresh != _EXPIRY_INFINITY) {
-			if (!expiry_next (now, get_expiry (item), NULL)) {
-				g_array_remove_index (rdata->dns_servers, i);
-				*changed |= NM_NDISC_CONFIG_DNS_SERVERS;
-				continue;
-			}
-
-			if (now >= refresh)
-				solicit_routers (ndisc);
-			else if (*nextevent > refresh)
-				*nextevent = refresh;
-		}
-		i++;
-	}
+    NMNDiscDataInternal *rdata;
+    guint                i;
+
+    rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata;
+
+    for (i = 0; i < rdata->dns_servers->len;) {
+        NMNDiscDNSServer *item = &g_array_index(rdata->dns_servers, NMNDiscDNSServer, i);
+        gint64            refresh;
+
+        refresh = get_expiry_half(item);
+        if (refresh != _EXPIRY_INFINITY) {
+            if (!expiry_next(now, get_expiry(item), NULL)) {
+                g_array_remove_index(rdata->dns_servers, i);
+                *changed |= NM_NDISC_CONFIG_DNS_SERVERS;
+                continue;
+            }
+
+            if (now >= refresh)
+                solicit_routers(ndisc);
+            else if (*nextevent > refresh)
+                *nextevent = refresh;
+        }
+        i++;
+    }
 }
 
 static void
-clean_dns_domains (NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
+clean_dns_domains(NMNDisc *ndisc, gint32 now, NMNDiscConfigMap *changed, gint32 *nextevent)
 {
-	NMNDiscDataInternal *rdata;
-	guint i;
-
-	rdata = &NM_NDISC_GET_PRIVATE (ndisc)->rdata;
-
-	for (i = 0; i < rdata->dns_domains->len; ) {
-		NMNDiscDNSDomain *item = &g_array_index (rdata->dns_domains, NMNDiscDNSDomain, i);
-		gint64 refresh;
-
-		refresh = get_expiry_half (item);
-		if (refresh != _EXPIRY_INFINITY) {
-			if (!expiry_next (now, get_expiry (item), NULL)) {
-				g_array_remove_index (rdata->dns_domains, i);
-				*changed |= NM_NDISC_CONFIG_DNS_DOMAINS;
-				continue;
-			}
-
-			if (now >= refresh)
-				solicit_routers (ndisc);
-			else if (*nextevent > refresh)
-				*nextevent = refresh;
-		}
-		i++;
-	}
+    NMNDiscDataInternal *rdata;
+    guint                i;
+
+    rdata = &NM_NDISC_GET_PRIVATE(ndisc)->rdata;
+
+    for (i = 0; i < rdata->dns_domains->len;) {
+        NMNDiscDNSDomain *item = &g_array_index(rdata->dns_domains, NMNDiscDNSDomain, i);
+        gint64            refresh;
+
+        refresh = get_expiry_half(item);
+        if (refresh != _EXPIRY_INFINITY) {
+            if (!expiry_next(now, get_expiry(item), NULL)) {
+                g_array_remove_index(rdata->dns_domains, i);
+                *changed |= NM_NDISC_CONFIG_DNS_DOMAINS;
+                continue;
+            }
+
+            if (now >= refresh)
+                solicit_routers(ndisc);
+            else if (*nextevent > refresh)
+                *nextevent = refresh;
+        }
+        i++;
+    }
 }
 
-static gboolean timeout_cb (gpointer user_data);
+static gboolean timeout_cb(gpointer user_data);
 
 static void
-check_timestamps (NMNDisc *ndisc, gint32 now, NMNDiscConfigMap changed)
+check_timestamps(NMNDisc *ndisc, gint32 now, NMNDiscConfigMap changed)
 {
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
-	/* Use a magic date in the distant future (~68 years) */
-	gint32 nextevent = G_MAXINT32;
-
-	nm_clear_g_source (&priv->timeout_id);
-
-	clean_gateways (ndisc, now, &changed, &nextevent);
-	clean_addresses (ndisc, now, &changed, &nextevent);
-	clean_routes (ndisc, now, &changed, &nextevent);
-	clean_dns_servers (ndisc, now, &changed, &nextevent);
-	clean_dns_domains (ndisc, now, &changed, &nextevent);
-
-	if (nextevent != G_MAXINT32) {
-		if (nextevent <= now)
-			g_return_if_reached ();
-		_LOGD ("scheduling next now/lifetime check: %d seconds",
-		       (int) (nextevent - now));
-		priv->timeout_id = g_timeout_add_seconds (nextevent - now, timeout_cb, ndisc);
-	}
-
-	if (changed)
-		nm_ndisc_emit_config_change (ndisc, changed);
+    NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc);
+    /* Use a magic date in the distant future (~68 years) */
+    gint32 nextevent = G_MAXINT32;
+
+    nm_clear_g_source(&priv->timeout_id);
+
+    clean_gateways(ndisc, now, &changed, &nextevent);
+    clean_addresses(ndisc, now, &changed, &nextevent);
+    clean_routes(ndisc, now, &changed, &nextevent);
+    clean_dns_servers(ndisc, now, &changed, &nextevent);
+    clean_dns_domains(ndisc, now, &changed, &nextevent);
+
+    if (nextevent != G_MAXINT32) {
+        if (nextevent <= now)
+            g_return_if_reached();
+        _LOGD("scheduling next now/lifetime check: %d seconds", (int) (nextevent - now));
+        priv->timeout_id = g_timeout_add_seconds(nextevent - now, timeout_cb, ndisc);
+    }
+
+    if (changed)
+        nm_ndisc_emit_config_change(ndisc, changed);
 }
 
 static gboolean
-timeout_cb (gpointer user_data)
+timeout_cb(gpointer user_data)
 {
-	NMNDisc *self = user_data;
+    NMNDisc *self = user_data;
 
-	NM_NDISC_GET_PRIVATE (self)->timeout_id = 0;
-	check_timestamps (self, nm_utils_get_monotonic_timestamp_sec (), 0);
-	return G_SOURCE_REMOVE;
+    NM_NDISC_GET_PRIVATE(self)->timeout_id = 0;
+    check_timestamps(self, nm_utils_get_monotonic_timestamp_sec(), 0);
+    return G_SOURCE_REMOVE;
 }
 
 void
-nm_ndisc_ra_received (NMNDisc *ndisc, gint32 now, NMNDiscConfigMap changed)
+nm_ndisc_ra_received(NMNDisc *ndisc, gint32 now, NMNDiscConfigMap changed)
 {
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
+    NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc);
 
-	nm_clear_g_source (&priv->ra_timeout_id);
-	nm_clear_g_source (&priv->send_rs_id);
-	nm_clear_g_free (&priv->last_error);
-	check_timestamps (ndisc, now, changed);
+    nm_clear_g_source_inst(&priv->ra_timeout_source);
+    nm_clear_g_source(&priv->send_rs_id);
+    nm_clear_g_free(&priv->last_error);
+    check_timestamps(ndisc, now, changed);
 }
 
 void
-nm_ndisc_rs_received (NMNDisc *ndisc)
+nm_ndisc_rs_received(NMNDisc *ndisc)
 {
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
+    NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(ndisc);
 
-	nm_clear_g_free (&priv->last_error);
-	announce_router_solicited (ndisc);
+    nm_clear_g_free(&priv->last_error);
+    announce_router_solicited(ndisc);
 }
 
 /*****************************************************************************/
 
 static void
-dns_domain_free (gpointer data)
+dns_domain_free(gpointer data)
 {
-	g_free (((NMNDiscDNSDomain *)(data))->domain);
+    g_free(((NMNDiscDNSDomain *) (data))->domain);
 }
 
 static void
-set_property (GObject *object, guint prop_id,
-              const GValue *value, GParamSpec *pspec)
+set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
-	NMNDisc *self = NM_NDISC (object);
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (self);
-
-	switch (prop_id) {
-	case PROP_PLATFORM:
-		/* construct-only */
-		priv->platform = g_value_get_object (value) ?: NM_PLATFORM_GET;
-		if (!priv->platform)
-			g_return_if_reached ();
-
-		g_object_ref (priv->platform);
-
-		priv->netns = nm_platform_netns_get (priv->platform);
-		if (priv->netns)
-			g_object_ref (priv->netns);
-
-		g_return_if_fail (!priv->netns || priv->netns == nmp_netns_get_current ());
-		break;
-	case PROP_IFINDEX:
-		/* construct-only */
-		priv->ifindex = g_value_get_int (value);
-		g_return_if_fail (priv->ifindex > 0);
-		break;
-	case PROP_IFNAME:
-		/* construct-only */
-		priv->ifname = g_value_dup_string (value);
-		g_return_if_fail (priv->ifname && priv->ifname[0]);
-		break;
-	case PROP_STABLE_TYPE:
-		/* construct-only */
-		priv->stable_type = g_value_get_int (value);
-		break;
-	case PROP_NETWORK_ID:
-		/* construct-only */
-		priv->network_id = g_value_dup_string (value);
-		g_return_if_fail (priv->network_id);
-		break;
-	case PROP_ADDR_GEN_MODE:
-		/* construct-only */
-		priv->addr_gen_mode = g_value_get_int (value);
-		break;
-	case PROP_MAX_ADDRESSES:
-		/* construct-only */
-		priv->max_addresses = g_value_get_int (value);
-		break;
-	case PROP_RA_TIMEOUT:
-		/* construct-only */
-		priv->ra_timeout = g_value_get_int (value);
-		break;
-	case PROP_ROUTER_SOLICITATIONS:
-		/* construct-only */
-		priv->router_solicitations = g_value_get_int (value);
-		break;
-	case PROP_ROUTER_SOLICITATION_INTERVAL:
-		/* construct-only */
-		priv->router_solicitation_interval = g_value_get_int (value);
-		break;
-	case PROP_NODE_TYPE:
-		/* construct-only */
-		priv->node_type = g_value_get_int (value);
-		nm_assert (NM_IN_SET (priv->node_type, NM_NDISC_NODE_TYPE_HOST,
-		                                       NM_NDISC_NODE_TYPE_ROUTER));
-		break;
-	default:
-		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
-		break;
-	}
+    NMNDisc *       self = NM_NDISC(object);
+    NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE(self);
+
+    switch (prop_id) {
+    case PROP_PLATFORM:
+        /* construct-only */
+        priv->platform = g_value_get_object(value) ?: NM_PLATFORM_GET;
+        if (!priv->platform)
+            g_return_if_reached();
+
+        g_object_ref(priv->platform);
+
+        priv->netns = nm_platform_netns_get(priv->platform);
+        if (priv->netns)
+            g_object_ref(priv->netns);
+
+        g_return_if_fail(!priv->netns || priv->netns == nmp_netns_get_current());
+        break;
+    case PROP_IFINDEX:
+        /* construct-only */
+        priv->ifindex = g_value_get_int(value);
+        g_return_if_fail(priv->ifindex > 0);
+        break;
+    case PROP_IFNAME:
+        /* construct-only */
+        priv->ifname = g_value_dup_string(value);
+        g_return_if_fail(priv->ifname && priv->ifname[0]);
+        break;
+    case PROP_STABLE_TYPE:
+        /* construct-only */
+        priv->stable_type = g_value_get_int(value);
+        break;
+    case PROP_NETWORK_ID:
+        /* construct-only */
+        priv->network_id = g_value_dup_string(value);
+        g_return_if_fail(priv->network_id);
+        break;
+    case PROP_ADDR_GEN_MODE:
+        /* construct-only */
+        priv->addr_gen_mode = g_value_get_int(value);
+        break;
+    case PROP_MAX_ADDRESSES:
+        /* construct-only */
+        priv->max_addresses = g_value_get_int(value);
+        break;
+    case PROP_RA_TIMEOUT:
+        /* construct-only */
+        priv->ra_timeout = g_value_get_uint(value);
+        nm_assert(priv->ra_timeout <= NM_RA_TIMEOUT_INFINITY);
+        break;
+    case PROP_ROUTER_SOLICITATIONS:
+        /* construct-only */
+        priv->router_solicitations = g_value_get_int(value);
+        break;
+    case PROP_ROUTER_SOLICITATION_INTERVAL:
+        /* construct-only */
+        priv->router_solicitation_interval = g_value_get_int(value);
+        break;
+    case PROP_NODE_TYPE:
+        /* construct-only */
+        priv->node_type = g_value_get_int(value);
+        nm_assert(NM_IN_SET(priv->node_type, NM_NDISC_NODE_TYPE_HOST, NM_NDISC_NODE_TYPE_ROUTER));
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        break;
+    }
 }
 
 static void
-nm_ndisc_init (NMNDisc *ndisc)
+nm_ndisc_init(NMNDisc *ndisc)
 {
-	NMNDiscPrivate *priv;
-	NMNDiscDataInternal *rdata;
-
-	priv = G_TYPE_INSTANCE_GET_PRIVATE (ndisc, NM_TYPE_NDISC, NMNDiscPrivate);
-	ndisc->_priv = priv;
-
-	rdata = &priv->rdata;
-
-	rdata->gateways = g_array_new (FALSE, FALSE, sizeof (NMNDiscGateway));
-	rdata->addresses = g_array_new (FALSE, FALSE, sizeof (NMNDiscAddress));
-	rdata->routes = g_array_new (FALSE, FALSE, sizeof (NMNDiscRoute));
-	rdata->dns_servers = g_array_new (FALSE, FALSE, sizeof (NMNDiscDNSServer));
-	rdata->dns_domains = g_array_new (FALSE, FALSE, sizeof (NMNDiscDNSDomain));
-	g_array_set_clear_func (rdata->dns_domains, dns_domain_free);
-	priv->rdata.public.hop_limit = 64;
-
-	/* Start at very low number so that last_rs - router_solicitation_interval
-	 * is much lower than nm_utils_get_monotonic_timestamp_sec() at startup.
-	 */
-	priv->last_rs = G_MININT32;
+    NMNDiscPrivate *     priv;
+    NMNDiscDataInternal *rdata;
+
+    priv         = G_TYPE_INSTANCE_GET_PRIVATE(ndisc, NM_TYPE_NDISC, NMNDiscPrivate);
+    ndisc->_priv = priv;
+
+    rdata = &priv->rdata;
+
+    rdata->gateways    = g_array_new(FALSE, FALSE, sizeof(NMNDiscGateway));
+    rdata->addresses   = g_array_new(FALSE, FALSE, sizeof(NMNDiscAddress));
+    rdata->routes      = g_array_new(FALSE, FALSE, sizeof(NMNDiscRoute));
+    rdata->dns_servers = g_array_new(FALSE, FALSE, sizeof(NMNDiscDNSServer));
+    rdata->dns_domains = g_array_new(FALSE, FALSE, sizeof(NMNDiscDNSDomain));
+    g_array_set_clear_func(rdata->dns_domains, dns_domain_free);
+    priv->rdata.public.hop_limit = 64;
+
+    /* Start at very low number so that last_rs - router_solicitation_interval
+     * is much lower than nm_utils_get_monotonic_timestamp_sec() at startup.
+     */
+    priv->last_rs = G_MININT32;
 }
 
 static void
-dispose (GObject *object)
+dispose(GObject *object)
 {
-	NMNDisc *ndisc = NM_NDISC (object);
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
+    NMNDisc *       ndisc = NM_NDISC(object);
+    NMNDiscPrivate *priv  = NM_NDISC_GET_PRIVATE(ndisc);
 
-	nm_clear_g_source (&priv->ra_timeout_id);
-	nm_clear_g_source (&priv->send_rs_id);
-	nm_clear_g_source (&priv->send_ra_id);
-	nm_clear_g_free (&priv->last_error);
+    nm_clear_g_source_inst(&priv->ra_timeout_source);
+    nm_clear_g_source(&priv->send_rs_id);
+    nm_clear_g_source(&priv->send_ra_id);
+    nm_clear_g_free(&priv->last_error);
 
-	nm_clear_g_source (&priv->timeout_id);
+    nm_clear_g_source(&priv->timeout_id);
 
-	G_OBJECT_CLASS (nm_ndisc_parent_class)->dispose (object);
+    G_OBJECT_CLASS(nm_ndisc_parent_class)->dispose(object);
 }
 
 static void
-finalize (GObject *object)
+finalize(GObject *object)
 {
-	NMNDisc *ndisc = NM_NDISC (object);
-	NMNDiscPrivate *priv = NM_NDISC_GET_PRIVATE (ndisc);
-	NMNDiscDataInternal *rdata = &priv->rdata;
+    NMNDisc *            ndisc = NM_NDISC(object);
+    NMNDiscPrivate *     priv  = NM_NDISC_GET_PRIVATE(ndisc);
+    NMNDiscDataInternal *rdata = &priv->rdata;
 
-	g_free (priv->ifname);
-	g_free (priv->network_id);
+    g_free(priv->ifname);
+    g_free(priv->network_id);
 
-	g_array_unref (rdata->gateways);
-	g_array_unref (rdata->addresses);
-	g_array_unref (rdata->routes);
-	g_array_unref (rdata->dns_servers);
-	g_array_unref (rdata->dns_domains);
+    g_array_unref(rdata->gateways);
+    g_array_unref(rdata->addresses);
+    g_array_unref(rdata->routes);
+    g_array_unref(rdata->dns_servers);
+    g_array_unref(rdata->dns_domains);
 
-	g_clear_object (&priv->netns);
-	g_clear_object (&priv->platform);
+    g_clear_object(&priv->netns);
+    g_clear_object(&priv->platform);
 
-	G_OBJECT_CLASS (nm_ndisc_parent_class)->finalize (object);
+    G_OBJECT_CLASS(nm_ndisc_parent_class)->finalize(object);
 }
 
 static void
-nm_ndisc_class_init (NMNDiscClass *klass)
+nm_ndisc_class_init(NMNDiscClass *klass)
 {
-	GObjectClass *object_class = G_OBJECT_CLASS (klass);
-
-	g_type_class_add_private (klass, sizeof (NMNDiscPrivate));
-
-	object_class->set_property = set_property;
-	object_class->dispose      = dispose;
-	object_class->finalize     = finalize;
-
-	obj_properties[PROP_PLATFORM] =
-	    g_param_spec_object (NM_NDISC_PLATFORM, "", "",
-	                         NM_TYPE_PLATFORM,
-	                         G_PARAM_WRITABLE |
-	                         G_PARAM_CONSTRUCT_ONLY |
-	                         G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_IFINDEX] =
-	    g_param_spec_int (NM_NDISC_IFINDEX, "", "",
-	                      0, G_MAXINT, 0,
-	                      G_PARAM_WRITABLE |
-	                      G_PARAM_CONSTRUCT_ONLY |
-	                      G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_IFNAME] =
-	    g_param_spec_string (NM_NDISC_IFNAME, "", "",
-	                         NULL,
-	                         G_PARAM_WRITABLE |
-	                         G_PARAM_CONSTRUCT_ONLY |
-	                         G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_STABLE_TYPE] =
-	    g_param_spec_int (NM_NDISC_STABLE_TYPE, "", "",
-	                      NM_UTILS_STABLE_TYPE_UUID, NM_UTILS_STABLE_TYPE_RANDOM, NM_UTILS_STABLE_TYPE_UUID,
-	                      G_PARAM_WRITABLE |
-	                      G_PARAM_CONSTRUCT_ONLY |
-	                      G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_NETWORK_ID] =
-	    g_param_spec_string (NM_NDISC_NETWORK_ID, "", "",
-	                         NULL,
-	                         G_PARAM_WRITABLE |
-	                         G_PARAM_CONSTRUCT_ONLY |
-	                         G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_ADDR_GEN_MODE] =
-	    g_param_spec_int (NM_NDISC_ADDR_GEN_MODE, "", "",
-	                      NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64, NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY, NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64,
-	                      G_PARAM_WRITABLE |
-	                      G_PARAM_CONSTRUCT_ONLY |
-	                      G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_MAX_ADDRESSES] =
-	    g_param_spec_int (NM_NDISC_MAX_ADDRESSES, "", "",
-	                      0, G_MAXINT32, NM_NDISC_MAX_ADDRESSES_DEFAULT,
-	                      G_PARAM_WRITABLE |
-	                      G_PARAM_CONSTRUCT_ONLY |
-	                      G_PARAM_STATIC_STRINGS);
-	G_STATIC_ASSERT_EXPR (G_MAXINT32 == NM_RA_TIMEOUT_INFINITY);
-	obj_properties[PROP_RA_TIMEOUT] =
-	    g_param_spec_int (NM_NDISC_RA_TIMEOUT, "", "",
-	                      0, G_MAXINT32, 0,
-	                      G_PARAM_WRITABLE |
-	                      G_PARAM_CONSTRUCT_ONLY |
-	                      G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_ROUTER_SOLICITATIONS] =
-	    g_param_spec_int (NM_NDISC_ROUTER_SOLICITATIONS, "", "",
-	                      1, G_MAXINT32, NM_NDISC_ROUTER_SOLICITATIONS_DEFAULT,
-	                      G_PARAM_WRITABLE |
-	                      G_PARAM_CONSTRUCT_ONLY |
-	                      G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_ROUTER_SOLICITATION_INTERVAL] =
-	    g_param_spec_int (NM_NDISC_ROUTER_SOLICITATION_INTERVAL, "", "",
-	                      1, G_MAXINT32, NM_NDISC_ROUTER_SOLICITATION_INTERVAL_DEFAULT,
-	                      G_PARAM_WRITABLE |
-	                      G_PARAM_CONSTRUCT_ONLY |
-	                      G_PARAM_STATIC_STRINGS);
-	obj_properties[PROP_NODE_TYPE] =
-	    g_param_spec_int (NM_NDISC_NODE_TYPE, "", "",
-	                      NM_NDISC_NODE_TYPE_INVALID, NM_NDISC_NODE_TYPE_ROUTER, NM_NDISC_NODE_TYPE_INVALID,
-	                      G_PARAM_WRITABLE |
-	                      G_PARAM_CONSTRUCT_ONLY |
-	                      G_PARAM_STATIC_STRINGS);
-	g_object_class_install_properties (object_class, _PROPERTY_ENUMS_LAST, obj_properties);
-
-	signals[CONFIG_RECEIVED] =
-	    g_signal_new (NM_NDISC_CONFIG_RECEIVED,
-	                  G_OBJECT_CLASS_TYPE (klass),
-	                  G_SIGNAL_RUN_FIRST,
-	                  0,
-	                  NULL, NULL, NULL,
-	                  G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_UINT);
-	signals[RA_TIMEOUT_SIGNAL] =
-	    g_signal_new (NM_NDISC_RA_TIMEOUT_SIGNAL,
-	                  G_OBJECT_CLASS_TYPE (klass),
-	                  G_SIGNAL_RUN_FIRST,
-	                  0,
-	                  NULL, NULL, NULL,
-	                  G_TYPE_NONE, 0);
+    GObjectClass *object_class = G_OBJECT_CLASS(klass);
+
+    g_type_class_add_private(klass, sizeof(NMNDiscPrivate));
+
+    object_class->set_property = set_property;
+    object_class->dispose      = dispose;
+    object_class->finalize     = finalize;
+
+    obj_properties[PROP_PLATFORM] =
+        g_param_spec_object(NM_NDISC_PLATFORM,
+                            "",
+                            "",
+                            NM_TYPE_PLATFORM,
+                            G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_IFINDEX] =
+        g_param_spec_int(NM_NDISC_IFINDEX,
+                         "",
+                         "",
+                         0,
+                         G_MAXINT,
+                         0,
+                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_IFNAME] =
+        g_param_spec_string(NM_NDISC_IFNAME,
+                            "",
+                            "",
+                            NULL,
+                            G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_STABLE_TYPE] =
+        g_param_spec_int(NM_NDISC_STABLE_TYPE,
+                         "",
+                         "",
+                         NM_UTILS_STABLE_TYPE_UUID,
+                         NM_UTILS_STABLE_TYPE_RANDOM,
+                         NM_UTILS_STABLE_TYPE_UUID,
+                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_NETWORK_ID] =
+        g_param_spec_string(NM_NDISC_NETWORK_ID,
+                            "",
+                            "",
+                            NULL,
+                            G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_ADDR_GEN_MODE] =
+        g_param_spec_int(NM_NDISC_ADDR_GEN_MODE,
+                         "",
+                         "",
+                         NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64,
+                         NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY,
+                         NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64,
+                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_MAX_ADDRESSES] =
+        g_param_spec_int(NM_NDISC_MAX_ADDRESSES,
+                         "",
+                         "",
+                         0,
+                         G_MAXINT32,
+                         NM_NDISC_MAX_ADDRESSES_DEFAULT,
+                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    G_STATIC_ASSERT_EXPR(G_MAXINT32 == NM_RA_TIMEOUT_INFINITY);
+    obj_properties[PROP_RA_TIMEOUT] =
+        g_param_spec_uint(NM_NDISC_RA_TIMEOUT,
+                          "",
+                          "",
+                          0,
+                          G_MAXINT32,
+                          0,
+                          G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_ROUTER_SOLICITATIONS] =
+        g_param_spec_int(NM_NDISC_ROUTER_SOLICITATIONS,
+                         "",
+                         "",
+                         1,
+                         G_MAXINT32,
+                         NM_NDISC_ROUTER_SOLICITATIONS_DEFAULT,
+                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_ROUTER_SOLICITATION_INTERVAL] =
+        g_param_spec_int(NM_NDISC_ROUTER_SOLICITATION_INTERVAL,
+                         "",
+                         "",
+                         1,
+                         G_MAXINT32,
+                         NM_NDISC_ROUTER_SOLICITATION_INTERVAL_DEFAULT,
+                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    obj_properties[PROP_NODE_TYPE] =
+        g_param_spec_int(NM_NDISC_NODE_TYPE,
+                         "",
+                         "",
+                         NM_NDISC_NODE_TYPE_INVALID,
+                         NM_NDISC_NODE_TYPE_ROUTER,
+                         NM_NDISC_NODE_TYPE_INVALID,
+                         G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
+    g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
+
+    signals[CONFIG_RECEIVED]   = g_signal_new(NM_NDISC_CONFIG_RECEIVED,
+                                            G_OBJECT_CLASS_TYPE(klass),
+                                            G_SIGNAL_RUN_FIRST,
+                                            0,
+                                            NULL,
+                                            NULL,
+                                            NULL,
+                                            G_TYPE_NONE,
+                                            2,
+                                            G_TYPE_POINTER,
+                                            G_TYPE_UINT);
+    signals[RA_TIMEOUT_SIGNAL] = g_signal_new(NM_NDISC_RA_TIMEOUT_SIGNAL,
+                                              G_OBJECT_CLASS_TYPE(klass),
+                                              G_SIGNAL_RUN_FIRST,
+                                              0,
+                                              NULL,
+                                              NULL,
+                                              NULL,
+                                              G_TYPE_NONE,
+                                              0);
 }