// SPDX-License-Identifier: GPL-2.0+

/*

 * Copyright (C) 2016 - 2017 Red Hat, Inc.

 */

#include "nm-default.h"

#include <sys/mount.h>

#include <sched.h>

#include <sys/wait.h>

#include <fcntl.h>

#include <linux/if_tun.h>

#include "test-common.h"

#define SIGNAL_DATA_FMT "'%s-%s' ifindex %d%s%s%s (%d times received)"

#define SIGNAL_DATA_ARG(data) (data)->name, nm_platform_signal_change_type_to_string ((data)->change_type), (data)->ifindex, (data)->ifname ? " ifname '" : "", (data)->ifname ?: "", (data)->ifname ? "'" : "", (data)->received_count

int NMTSTP_ENV1_IFINDEX = -1;

int NMTSTP_ENV1_EX = -1;

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

void

nmtstp_setup_platform (void)

{

	g_assert (_nmtstp_setup_platform_func);

	_nmtstp_setup_platform_func ();

}

gboolean

nmtstp_is_root_test (void)

{

	g_assert (_nmtstp_setup_platform_func);

	return _nmtstp_setup_platform_func == nm_linux_platform_setup;

}

gboolean

nmtstp_is_sysfs_writable (void)

{

	return    !nmtstp_is_root_test ()

	       || (access ("/sys/devices", W_OK) == 0);

}

static void

_init_platform (NMPlatform **platform, gboolean external_command)

{

	g_assert (platform);

	if (!*platform)

		*platform = NM_PLATFORM_GET;

	g_assert (NM_IS_PLATFORM (*platform));

	if (external_command)

		g_assert (NM_IS_LINUX_PLATFORM (*platform));

}

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

static GArray *

_ipx_address_get_all (NMPlatform *self, int ifindex, NMPObjectType obj_type)

{

	NMPLookup lookup;

	g_assert (NM_IS_PLATFORM (self));

	g_assert (ifindex > 0);

	g_assert (NM_IN_SET (obj_type, NMP_OBJECT_TYPE_IP4_ADDRESS, NMP_OBJECT_TYPE_IP6_ADDRESS));

	nmp_lookup_init_object (&lookup,

	                        obj_type,

	                        ifindex);

	return nmp_cache_lookup_to_array (nm_platform_lookup (self, &lookup),

	                                  obj_type,

	                                  FALSE /*addresses are always visible. */);

}

GArray *

nmtstp_platform_ip4_address_get_all (NMPlatform *self, int ifindex)

{

	return _ipx_address_get_all (self, ifindex, NMP_OBJECT_TYPE_IP4_ADDRESS);

}

GArray *

nmtstp_platform_ip6_address_get_all (NMPlatform *self, int ifindex)

{

	return _ipx_address_get_all (self, ifindex, NMP_OBJECT_TYPE_IP6_ADDRESS);

}

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

gboolean

nmtstp_platform_ip4_route_delete (NMPlatform *platform, int ifindex, in_addr_t network, guint8 plen, guint32 metric)

{

	NMDedupMultiIter iter;

	nm_platform_process_events (platform);

	nm_dedup_multi_iter_for_each (&iter,

	                              nm_platform_lookup_object (platform,

	                                                         NMP_OBJECT_TYPE_IP4_ROUTE,

	                                                         ifindex)) {

		const NMPlatformIP4Route *r = NMP_OBJECT_CAST_IP4_ROUTE (iter.current->obj);

		if (   r->ifindex != ifindex

		    || r->network != network

		    || r->plen != plen

		    || r->metric != metric) {

			continue;

		}

		return nm_platform_object_delete (platform, NMP_OBJECT_UP_CAST (r));

	}

	return TRUE;

}

gboolean

nmtstp_platform_ip6_route_delete (NMPlatform *platform, int ifindex, struct in6_addr network, guint8 plen, guint32 metric)

{

	NMDedupMultiIter iter;

	nm_platform_process_events (platform);

	nm_dedup_multi_iter_for_each (&iter,

	                              nm_platform_lookup_object (platform,

	                                                         NMP_OBJECT_TYPE_IP6_ROUTE,

	                                                         ifindex)) {

		const NMPlatformIP6Route *r = NMP_OBJECT_CAST_IP6_ROUTE (iter.current->obj);

		if (   r->ifindex != ifindex

		    || !IN6_ARE_ADDR_EQUAL (&r->network, &network)

		    || r->plen != plen

		    || r->metric != metric) {

			continue;

		}

		return nm_platform_object_delete (platform, NMP_OBJECT_UP_CAST (r));

	}

	return TRUE;

}

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

SignalData *

add_signal_full (const char *name, NMPlatformSignalChangeType change_type, GCallback callback, int ifindex, const char *ifname)

{

	SignalData *data = g_new0 (SignalData, 1);

	data->name = name;

	data->change_type = change_type;

	data->received_count = 0;

	data->handler_id = g_signal_connect (NM_PLATFORM_GET, name, callback, data);

	data->ifindex = ifindex;

	data->ifname = ifname;

	g_assert (data->handler_id > 0);

	return data;

}

void

_accept_signal (const char *file, int line, const char *func, SignalData *data)

{

	_LOGD ("NMPlatformSignalAssert: %s:%d, %s(): Accepting signal one time: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

	if (data->received_count != 1)

		g_error ("NMPlatformSignalAssert: %s:%d, %s(): failure to accept signal one time: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

	data->received_count = 0;

}

void

_accept_signals (const char *file, int line, const char *func, SignalData *data, int min, int max)

{

	_LOGD ("NMPlatformSignalAssert: %s:%d, %s(): Accepting signal [%d,%d] times: "SIGNAL_DATA_FMT, file, line, func, min, max, SIGNAL_DATA_ARG (data));

	if (data->received_count < min || data->received_count > max)

		g_error ("NMPlatformSignalAssert: %s:%d, %s(): failure to accept signal [%d,%d] times: "SIGNAL_DATA_FMT, file, line, func, min, max, SIGNAL_DATA_ARG (data));

	data->received_count = 0;

}

void

_ensure_no_signal (const char *file, int line, const char *func, SignalData *data)

{

	_LOGD ("NMPlatformSignalAssert: %s:%d, %s(): Accepting signal 0 times: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

	if (data->received_count > 0)

		g_error ("NMPlatformSignalAssert: %s:%d, %s(): failure to accept signal 0 times: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

}

void

_accept_or_wait_signal (const char *file, int line, const char *func, SignalData *data)

{

	_LOGD ("NMPlatformSignalAssert: %s:%d, %s(): accept-or-wait signal: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

	if (data->received_count == 0) {

		data->loop = g_main_loop_new (NULL, FALSE);

		g_main_loop_run (data->loop);

		nm_clear_pointer (&data->loop, g_main_loop_unref);

	}

	_accept_signal (file, line, func, data);

}

void

_wait_signal (const char *file, int line, const char *func, SignalData *data)

{

	_LOGD ("NMPlatformSignalAssert: %s:%d, %s(): wait signal: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

	if (data->received_count)

		g_error ("NMPlatformSignalAssert: %s:%d, %s(): failure to wait for signal: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

	data->loop = g_main_loop_new (NULL, FALSE);

	g_main_loop_run (data->loop);

	nm_clear_pointer (&data->loop, g_main_loop_unref);

	_accept_signal (file, line, func, data);

}

void

_free_signal (const char *file, int line, const char *func, SignalData *data)

{

	_LOGD ("NMPlatformSignalAssert: %s:%d, %s(): free signal: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

	if (data->received_count != 0)

		g_error ("NMPlatformSignalAssert: %s:%d, %s(): failure to free non-accepted signal: "SIGNAL_DATA_FMT, file, line, func, SIGNAL_DATA_ARG (data));

	g_signal_handler_disconnect (NM_PLATFORM_GET, data->handler_id);

	g_free (data);

}

void

link_callback (NMPlatform *platform, int obj_type_i, int ifindex, NMPlatformLink *received, int change_type_i, SignalData *data)

{

	const NMPObjectType obj_type = obj_type_i;

	const NMPlatformSignalChangeType change_type = change_type_i;

	NMPLookup lookup;

	NMDedupMultiIter iter;

	const NMPlatformLink *cached;

	g_assert_cmpint (obj_type, ==, NMP_OBJECT_TYPE_LINK);

	g_assert (received);

	g_assert_cmpint (received->ifindex, ==, ifindex);

	g_assert (data && data->name);

	g_assert_cmpstr (data->name, ==, NM_PLATFORM_SIGNAL_LINK_CHANGED);

	if (data->ifindex && data->ifindex != received->ifindex)

		return;

	if (data->ifname && g_strcmp0 (data->ifname, nm_platform_link_get_name (NM_PLATFORM_GET, ifindex)) != 0)

		return;

	if (change_type != data->change_type)

		return;

	if (data->loop) {

		_LOGD ("Quitting main loop.");

		g_main_loop_quit (data->loop);

	}

	data->received_count++;

	_LOGD ("Received signal '%s-%s' ifindex %d ifname '%s' %dth time.", data->name, nm_platform_signal_change_type_to_string (data->change_type), ifindex, received->name, data->received_count);

	if (change_type == NM_PLATFORM_SIGNAL_REMOVED)

		g_assert (!nm_platform_link_get_name (NM_PLATFORM_GET, ifindex));

	else

		g_assert (nm_platform_link_get_name (NM_PLATFORM_GET, ifindex));

	/* Check the data */

	g_assert (received->ifindex > 0);

	nmp_lookup_init_obj_type (&lookup, NMP_OBJECT_TYPE_LINK);

	nmp_cache_iter_for_each_link (&iter,

	                              nm_platform_lookup (platform, &lookup),

	                              &cached) {

		if (!nmp_object_is_visible (NMP_OBJECT_UP_CAST (cached)))

			continue;

		if (cached->ifindex == received->ifindex) {

			g_assert_cmpint (nm_platform_link_cmp (cached, received), ==, 0);

			g_assert (!memcmp (cached, received, sizeof (*cached)));

			if (data->change_type == NM_PLATFORM_SIGNAL_REMOVED)

				g_error ("Deleted link still found in the local cache.");

			return;

		}

	}

	if (data->change_type != NM_PLATFORM_SIGNAL_REMOVED)

		g_error ("Added/changed link not found in the local cache.");

}

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

static const NMPlatformIP4Route *

_ip4_route_get (NMPlatform *platform,

                int ifindex,

                guint32 network,

                int plen,

                guint32 metric,

                guint8 tos,

                guint *out_c_exists)

{

	NMDedupMultiIter iter;

	NMPLookup lookup;

	const NMPObject *o = NULL;

	guint c;

	const NMPlatformIP4Route *r = NULL;

	_init_platform (&platform, FALSE);

	nmp_lookup_init_ip4_route_by_weak_id (&lookup,

	                                      network,

	                                      plen,

	                                      metric,

	                                      tos);

	c = 0;

	nmp_cache_iter_for_each (&iter,

	                         nm_platform_lookup (platform, &lookup),

	                         &o) {

		if (   NMP_OBJECT_CAST_IP4_ROUTE (o)->ifindex != ifindex

		    && ifindex > 0)

			continue;

		if (!r)

			r = NMP_OBJECT_CAST_IP4_ROUTE (o);

		c++;

	}

	NM_SET_OUT (out_c_exists, c);

	return r;

}

const NMPlatformIP4Route *

_nmtstp_assert_ip4_route_exists (const char *file,

                                 guint line,

                                 const char *func,

                                 NMPlatform *platform,

                                 int c_exists,

                                 const char *ifname,

                                 guint32 network,

                                 int plen,

                                 guint32 metric,

                                 guint8 tos)

{

	int ifindex;

	guint c;

	const NMPlatformIP4Route *r = NULL;

	_init_platform (&platform, FALSE);

	ifindex = -1;

	if (ifname) {

		ifindex = nm_platform_link_get_ifindex (platform, ifname);

		g_assert (ifindex > 0);

	}

	r = _ip4_route_get (platform,

	                    ifindex,

	                    network,

	                    plen,

	                    metric,

	                    tos,

	                    &c);

	if (c != c_exists && c_exists != -1) {

		char sbuf[NM_UTILS_INET_ADDRSTRLEN];

		g_error ("[%s:%u] %s(): The ip4 route %s/%d metric %u tos %u shall exist %u times, but platform has it %u times",

		         file, line, func,

		         _nm_utils_inet4_ntop (network, sbuf),

		         plen,

		         metric,

		         tos,

		         c_exists,

		         c);

	}

	return r;

}

const NMPlatformIP4Route *

nmtstp_ip4_route_get (NMPlatform *platform,

                      int ifindex,

                      guint32 network,

                      int plen,

                      guint32 metric,

                      guint8 tos)

{

	return _ip4_route_get (platform,

	                       ifindex,

	                       network,

	                       plen,

	                       metric,

	                       tos,

	                       NULL);

}

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

static const NMPlatformIP6Route *

_ip6_route_get (NMPlatform *platform,

                int ifindex,

                const struct in6_addr *network,

                guint plen,

                guint32 metric,

                const struct in6_addr *src,

                guint8 src_plen,

                guint *out_c_exists)

{

	NMDedupMultiIter iter;

	NMPLookup lookup;

	const NMPObject *o = NULL;

	guint c;

	const NMPlatformIP6Route *r = NULL;

	_init_platform (&platform, FALSE);

	nmp_lookup_init_ip6_route_by_weak_id (&lookup,

	                                      network,

	                                      plen,

	                                      metric,

	                                      src,

	                                      src_plen);

	c = 0;

	nmp_cache_iter_for_each (&iter,

	                         nm_platform_lookup (platform, &lookup),

	                         &o) {

		if (   NMP_OBJECT_CAST_IP6_ROUTE (o)->ifindex != ifindex

		    && ifindex > 0)

			continue;

		if (!r)

			r = NMP_OBJECT_CAST_IP6_ROUTE (o);

		c++;

	}

	NM_SET_OUT (out_c_exists, c);

	return r;

}

const NMPlatformIP6Route *

_nmtstp_assert_ip6_route_exists (const char *file,

                                 guint line,

                                 const char *func,

                                 NMPlatform *platform,

                                 int c_exists,

                                 const char *ifname,

                                 const struct in6_addr *network,

                                 guint plen,

                                 guint32 metric,

                                 const struct in6_addr *src,

                                 guint8 src_plen)

{

	int ifindex;

	guint c;

	const NMPlatformIP6Route *r = NULL;

	_init_platform (&platform, FALSE);

	ifindex = -1;

	if (ifname) {

		ifindex = nm_platform_link_get_ifindex (platform, ifname);

		g_assert (ifindex > 0);

	}

	r = _ip6_route_get (platform,

	                    ifindex,

	                    network,

	                    plen,

	                    metric,

	                    src,

	                    src_plen,

	                    &c);

	if (c != c_exists && c_exists != -1) {

		char s_src[NM_UTILS_INET_ADDRSTRLEN];

		char s_network[NM_UTILS_INET_ADDRSTRLEN];

		g_error ("[%s:%u] %s(): The ip6 route %s/%d metric %u src %s/%d shall exist %u times, but platform has it %u times",

		         file, line, func,

		         _nm_utils_inet6_ntop (network, s_network),

		         plen,

		         metric,

		         _nm_utils_inet6_ntop (src, s_src),

		         src_plen,

		         c_exists,

		         c);

	}

	return r;

}

const NMPlatformIP6Route *

nmtstp_ip6_route_get (NMPlatform *platform,

                      int ifindex,

                      const struct in6_addr *network,

                      guint plen,

                      guint32 metric,

                      const struct in6_addr *src,

                      guint8 src_plen)

{

	return _ip6_route_get (platform,

	                       ifindex,

	                       network,

	                       plen,

	                       metric,

	                       src,

	                       src_plen,

	                       NULL);

}

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

int

nmtstp_run_command (const char *format, ...)

{

	int result;

	gs_free char *command = NULL;

	va_list ap;

	va_start (ap, format);

	command = g_strdup_vprintf (format, ap);

	va_end (ap);

	_LOGD ("Running command: %s", command);

	result = system (command);

	_LOGD ("Command finished: result=%d", result);

	return result;

}

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

typedef struct {

	GMainLoop *loop;

	guint signal_counts;

	guint id;

} WaitForSignalData;

static void

_wait_for_signal_cb (NMPlatform *platform,

                     int obj_type_i,

                     int ifindex,

                     NMPlatformLink *plink,

                     int change_type_i,

                     gpointer user_data)

{

	WaitForSignalData *data = user_data;

	data->signal_counts++;

	nm_clear_g_source (&data->id);

	g_main_loop_quit (data->loop);

}

static gboolean

_wait_for_signal_timeout (gpointer user_data)

{

	WaitForSignalData *data = user_data;

	g_assert (data->id);

	data->id = 0;

	g_main_loop_quit (data->loop);

	return G_SOURCE_REMOVE;

}

guint

nmtstp_wait_for_signal (NMPlatform *platform, gint64 timeout_msec)

{

	WaitForSignalData data = { 0 };

	gulong id_link, id_ip4_address, id_ip6_address, id_ip4_route, id_ip6_route;

	gulong id_qdisc, id_tfilter;

	_init_platform (&platform, FALSE);

	data.loop = g_main_loop_new (NULL, FALSE);

	id_link        = g_signal_connect (platform, NM_PLATFORM_SIGNAL_LINK_CHANGED, G_CALLBACK (_wait_for_signal_cb), &data);

	id_ip4_address = g_signal_connect (platform, NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED, G_CALLBACK (_wait_for_signal_cb), &data);

	id_ip6_address = g_signal_connect (platform, NM_PLATFORM_SIGNAL_IP6_ADDRESS_CHANGED, G_CALLBACK (_wait_for_signal_cb), &data);

	id_ip4_route   = g_signal_connect (platform, NM_PLATFORM_SIGNAL_IP4_ROUTE_CHANGED, G_CALLBACK (_wait_for_signal_cb), &data);

	id_ip6_route   = g_signal_connect (platform, NM_PLATFORM_SIGNAL_IP6_ROUTE_CHANGED, G_CALLBACK (_wait_for_signal_cb), &data);

	id_qdisc       = g_signal_connect (platform, NM_PLATFORM_SIGNAL_QDISC_CHANGED, G_CALLBACK (_wait_for_signal_cb), &data);

	id_tfilter     = g_signal_connect (platform, NM_PLATFORM_SIGNAL_TFILTER_CHANGED, G_CALLBACK (_wait_for_signal_cb), &data);

	/* if timeout_msec is negative, it means the wait-time already expired.

	 * Maybe, we should do nothing and return right away, without even

	 * processing events from platform. However, that inconsistency (of not

	 * processing events from mainloop) is inconvenient.

	 *

	 * It's better that on the return of nmtstp_wait_for_signal(), we always

	 * have no events pending. So, a negative timeout is treated the same as

	 * a zero timeout: we check whether there are any events pending in platform,

	 * and quite the mainloop immediately afterwards. But we always check. */

	data.id = g_timeout_add (CLAMP (timeout_msec, 0, G_MAXUINT32),

	                         _wait_for_signal_timeout, &data);

	g_main_loop_run (data.loop);

	g_assert (!data.id);

	g_assert (nm_clear_g_signal_handler (platform, &id_link));

	g_assert (nm_clear_g_signal_handler (platform, &id_ip4_address));

	g_assert (nm_clear_g_signal_handler (platform, &id_ip6_address));

	g_assert (nm_clear_g_signal_handler (platform, &id_ip4_route));

	g_assert (nm_clear_g_signal_handler (platform, &id_ip6_route));

	g_assert (nm_clear_g_signal_handler (platform, &id_tfilter));

	g_assert (nm_clear_g_signal_handler (platform, &id_qdisc));

	nm_clear_pointer (&data.loop, g_main_loop_unref);

	/* return the number of signals, or 0 if timeout was reached .*/

	return data.signal_counts;

}

guint

nmtstp_wait_for_signal_until (NMPlatform *platform, gint64 until_ms)

{

	gint64 now;

	guint signal_counts;

	while (TRUE) {

		now = nm_utils_get_monotonic_timestamp_msec ();

		if (until_ms < now)

			return 0;

		signal_counts = nmtstp_wait_for_signal (platform, until_ms - now);

		if (signal_counts)

			return signal_counts;

	}

}

const NMPlatformLink *

nmtstp_wait_for_link (NMPlatform *platform, const char *ifname, NMLinkType expected_link_type, gint64 timeout_msec)

{

	return nmtstp_wait_for_link_until (platform, ifname, expected_link_type,

	                                   timeout_msec

	                                     ? nm_utils_get_monotonic_timestamp_msec () + timeout_msec

	                                     : 0);

}

const NMPlatformLink *

nmtstp_wait_for_link_until (NMPlatform *platform, const char *ifname, NMLinkType expected_link_type, gint64 until_ms)

{

	const NMPlatformLink *plink;

	gint64 now;

	gboolean waited_once = FALSE;

	_init_platform (&platform, FALSE);

	while (TRUE) {

		now = nm_utils_get_monotonic_timestamp_msec ();

		plink = nm_platform_link_get_by_ifname (platform, ifname);

		if (   plink

		    && (expected_link_type == NM_LINK_TYPE_NONE || plink->type == expected_link_type))

			return plink;

		if (until_ms == 0) {

			/* don't wait, don't even poll the socket. */

			return NULL;

		}

		if (   waited_once

		    && until_ms < now) {

			/* timeout reached (+ we already waited for a signal at least once). */

			return NULL;

		}

		waited_once = TRUE;

		/* regardless of whether timeout is already reached, we poll the netlink

		 * socket a bit. */

		nmtstp_wait_for_signal (platform, until_ms - now);

	}

}

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

int

nmtstp_run_command_check_external_global (void)

{

	if (!nmtstp_is_root_test ())

		return FALSE;

	switch (nmtst_get_rand_uint32 () % 3) {

	case 0:

		return -1;

	case 1:

		return FALSE;

	default:

		return TRUE;

	}

}

gboolean

nmtstp_run_command_check_external (int external_command)

{

	if (external_command != -1) {

		g_assert (NM_IN_SET (external_command, FALSE, TRUE));

		g_assert (!external_command || nmtstp_is_root_test ());

		return !!external_command;

	}

	if (!nmtstp_is_root_test ())

		return FALSE;

	return (nmtst_get_rand_uint32 () % 2) == 0;

}

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

#define CHECK_LIFETIME_MAX_DIFF    2

gboolean

nmtstp_ip_address_check_lifetime (const NMPlatformIPAddress *addr,

                                  gint64 now,

                                  guint32 expected_lifetime,

                                  guint32 expected_preferred)

{

	gint64 offset;

	int i;

	g_assert (addr);

	if (now == -1)

		now = nm_utils_get_monotonic_timestamp_sec ();

	g_assert (now > 0);

	g_assert (expected_preferred <= expected_lifetime);

	if (   expected_lifetime == NM_PLATFORM_LIFETIME_PERMANENT

	    && expected_preferred == NM_PLATFORM_LIFETIME_PERMANENT) {

		return    addr->timestamp == 0

		       && addr->lifetime == NM_PLATFORM_LIFETIME_PERMANENT

		       && addr->preferred == NM_PLATFORM_LIFETIME_PERMANENT;

	}

	if (addr->timestamp == 0)

		return FALSE;

	offset = (gint64) now - addr->timestamp;

	for (i = 0; i < 2; i++) {

		guint32 lft = i ? expected_lifetime : expected_preferred;

		guint32 adr = i ? addr->lifetime : addr->preferred;

		if (lft == NM_PLATFORM_LIFETIME_PERMANENT) {

			if (adr != NM_PLATFORM_LIFETIME_PERMANENT)

				return FALSE;

		} else {

			if (   adr - offset <= lft - CHECK_LIFETIME_MAX_DIFF

			    || adr - offset >= lft + CHECK_LIFETIME_MAX_DIFF)

				return FALSE;

		}

	}

	return TRUE;

}

void

nmtstp_ip_address_assert_lifetime (const NMPlatformIPAddress *addr,

                                   gint64 now,

                                   guint32 expected_lifetime,

                                   guint32 expected_preferred)

{

	gint64 n = now;

	gint64 offset;

	int i;

	g_assert (addr);

	if (now == -1)

		now = nm_utils_get_monotonic_timestamp_sec ();

	g_assert (now > 0);

	g_assert (expected_preferred <= expected_lifetime);

	if (   expected_lifetime == NM_PLATFORM_LIFETIME_PERMANENT

	    && expected_preferred == NM_PLATFORM_LIFETIME_PERMANENT) {

		g_assert_cmpint (addr->timestamp, ==, 0);

		g_assert_cmpint (addr->lifetime, ==, NM_PLATFORM_LIFETIME_PERMANENT);

		g_assert_cmpint (addr->preferred, ==, NM_PLATFORM_LIFETIME_PERMANENT);

		return;

	}

	g_assert_cmpint (addr->timestamp, >, 0);

	g_assert_cmpint (addr->timestamp, <=, now);

	offset = (gint64) now - addr->timestamp;

	g_assert_cmpint (offset, >=, 0);

	for (i = 0; i < 2; i++) {

		guint32 lft = i ? expected_lifetime : expected_preferred;

		guint32 adr = i ? addr->lifetime : addr->preferred;

		if (lft == NM_PLATFORM_LIFETIME_PERMANENT)

			g_assert_cmpint (adr, ==, NM_PLATFORM_LIFETIME_PERMANENT);

		else {

			g_assert_cmpint (adr - offset, <=, lft + CHECK_LIFETIME_MAX_DIFF);

			g_assert_cmpint (adr - offset, >=, lft - CHECK_LIFETIME_MAX_DIFF);

		}

	}

	g_assert (nmtstp_ip_address_check_lifetime (addr, n, expected_lifetime, expected_preferred));

}

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

static void

_ip_address_add (NMPlatform *platform,

                 gboolean external_command,

                 gboolean is_v4,

                 int ifindex,

                 const NMIPAddr *address,

                 int plen,

                 const NMIPAddr *peer_address,

                 guint32 lifetime,

                 guint32 preferred,

                 guint32 flags,

                 const char *label)

{

	gint64 end_time;

	external_command = nmtstp_run_command_check_external (external_command);

	_init_platform (&platform, external_command);

	if (external_command) {

		const char *ifname;

		gs_free char *s_valid = NULL;

		gs_free char *s_preferred = NULL;

		gs_free char *s_label = NULL;

		char b1[NM_UTILS_INET_ADDRSTRLEN];

		char b2[NM_UTILS_INET_ADDRSTRLEN];

		ifname = nm_platform_link_get_name (platform, ifindex);

		g_assert (ifname);

		if (lifetime != NM_PLATFORM_LIFETIME_PERMANENT)

			s_valid = g_strdup_printf (" valid_lft %d", lifetime);

		if (preferred != NM_PLATFORM_LIFETIME_PERMANENT)

			s_preferred = g_strdup_printf (" preferred_lft %d", preferred);

		if (label)

			s_label = g_strdup_printf ("%s:%s", ifname, label);

		if (is_v4) {

			char s_peer[NM_UTILS_INET_ADDRSTRLEN + 50];

			g_assert (flags == 0);

			if (   peer_address->addr4 != address->addr4

			    || nmtst_get_rand_uint32 () % 2) {

				/* If the peer is the same as the local address, we can omit it. The result should be identical */

				nm_sprintf_buf (s_peer, " peer %s", _nm_utils_inet4_ntop (peer_address->addr4, b2));

			} else

				s_peer[0] = '\0';

			nmtstp_run_command_check ("ip address change %s%s/%d dev %s%s%s%s",

			                          _nm_utils_inet4_ntop (address->addr4, b1),

			                          s_peer,

			                          plen,

			                          ifname,

			                          s_valid ?: "",

			                          s_preferred ?: "",

			                          s_label ?: "");

		} else {

			g_assert (label == NULL);

			/* flags not implemented (yet) */

			g_assert (flags == 0);

			nmtstp_run_command_check ("ip address change %s%s%s/%d dev %s%s%s%s",

			                          _nm_utils_inet6_ntop (&address->addr6, b1),

			                          !IN6_IS_ADDR_UNSPECIFIED (&peer_address->addr6) ? " peer " : "",

			                          !IN6_IS_ADDR_UNSPECIFIED (&peer_address->addr6) ? _nm_utils_inet6_ntop (&peer_address->addr6, b2) : "",

			                          plen,

			                          ifname,

			                          s_valid ?: "",

			                          s_preferred ?: "",

			                          s_label ?: "");

		}

	} else {

		gboolean success;

		if (is_v4) {

			success = nm_platform_ip4_address_add (platform,

			                                       ifindex,

			                                       address->addr4,

			                                       plen,

			                                       peer_address->addr4,

			                                       0u,

			                                       lifetime,

			                                       preferred,

			                                       flags,

			                                       label);