// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2015 Red Hat, Inc.
 */

#include "nm-default.h"

#include "test-common.h"

#define IP4_ADDRESS "192.0.2.1"
#define IP4_ADDRESS_PEER "192.0.2.2"
#define IP4_ADDRESS_PEER2 "192.0.3.1"
#define IP4_PLEN 24
#define IP6_ADDRESS "2001:db8:a:b:1:2:3:4"
#define IP6_PLEN 64

#define DEVICE_IFINDEX NMTSTP_ENV1_IFINDEX
#define EX             NMTSTP_ENV1_EX

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

static void
ip4_address_callback (NMPlatform *platform, NMPObjectType obj_type, int ifindex, NMPlatformIP4Address *received, NMPlatformSignalChangeType change_type, SignalData *data)
{
	g_assert (received);
	g_assert_cmpint (received->ifindex, ==, ifindex);
	g_assert (data && data->name);
	g_assert_cmpstr (data->name, ==, NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED);

	if (data->ifindex && data->ifindex != received->ifindex)
		return;
	if (data->change_type != change_type)
		return;

	if (data->loop)
		g_main_loop_quit (data->loop);

	data->received_count++;
	_LOGD ("Received signal '%s' %dth time.", data->name, data->received_count);
}

static void
ip6_address_callback (NMPlatform *platform, NMPObjectType obj_type, int ifindex, NMPlatformIP6Address *received, NMPlatformSignalChangeType change_type, SignalData *data)
{
	g_assert (received);
	g_assert_cmpint (received->ifindex, ==, ifindex);
	g_assert (data && data->name);
	g_assert_cmpstr (data->name, ==, NM_PLATFORM_SIGNAL_IP6_ADDRESS_CHANGED);

	if (data->ifindex && data->ifindex != received->ifindex)
		return;
	if (data->change_type != change_type)
		return;

	if (data->loop)
		g_main_loop_quit (data->loop);

	data->received_count++;
	_LOGD ("Received signal '%s' %dth time.", data->name, data->received_count);
}

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

static void
test_ip4_address_general (void)
{
	const int ifindex = DEVICE_IFINDEX;
	SignalData *address_added = add_signal_ifindex (NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_ADDED, ip4_address_callback, ifindex);
	SignalData *address_changed = add_signal_ifindex (NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_CHANGED, ip4_address_callback, ifindex);
	SignalData *address_removed = add_signal_ifindex (NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_REMOVED, ip4_address_callback, ifindex);
	GArray *addresses;
	NMPlatformIP4Address *address;
	in_addr_t addr;
	guint32 lifetime = 2000;
	guint32 preferred = 1000;

	inet_pton (AF_INET, IP4_ADDRESS, &addr);

	/* Add address */
	g_assert (!nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr));
	nmtstp_ip4_address_add (NULL, EX, ifindex, addr, IP4_PLEN, addr, lifetime, preferred, 0, NULL);
	g_assert (nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr));
	accept_signal (address_added);

	/* Add address again (aka update) */
	nmtstp_ip4_address_add (NULL, EX, ifindex, addr, IP4_PLEN, addr, lifetime + 100, preferred + 50, 0, NULL);
	accept_signals (address_changed, 0, 1);

	/* Test address listing */
	addresses = nmtstp_platform_ip4_address_get_all (NM_PLATFORM_GET, ifindex);
	g_assert (addresses);
	g_assert_cmpint (addresses->len, ==, 1);
	address = &g_array_index (addresses, NMPlatformIP4Address, 0);
	g_assert_cmpint (address->ifindex, ==, ifindex);
	g_assert_cmphex (address->address, ==, addr);
	g_assert_cmphex (address->peer_address, ==, addr);
	g_assert_cmpint (address->plen, ==, IP4_PLEN);
	g_array_unref (addresses);

	/* Remove address */
	nmtstp_ip4_address_del (NULL, EX, ifindex, addr, IP4_PLEN, addr);
	g_assert (!nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr));
	accept_signal (address_removed);

	/* Remove address again */
	nmtstp_ip4_address_del (NULL, EX, ifindex, addr, IP4_PLEN, addr);

	free_signal (address_added);
	free_signal (address_changed);
	free_signal (address_removed);
}

static void
test_ip6_address_general (void)
{
	const int ifindex = DEVICE_IFINDEX;
	SignalData *address_added = add_signal_ifindex (NM_PLATFORM_SIGNAL_IP6_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_ADDED, ip6_address_callback, ifindex);
	SignalData *address_changed = add_signal_ifindex (NM_PLATFORM_SIGNAL_IP6_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_CHANGED, ip6_address_callback, ifindex);
	SignalData *address_removed = add_signal_ifindex (NM_PLATFORM_SIGNAL_IP6_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_REMOVED, ip6_address_callback, ifindex);
	GArray *addresses;
	NMPlatformIP6Address *address;
	struct in6_addr addr;
	guint32 lifetime = 2000;
	guint32 preferred = 1000;
	guint flags = 0;

	inet_pton (AF_INET6, IP6_ADDRESS, &addr);

	/* Add address */
	g_assert (!nm_platform_ip6_address_get (NM_PLATFORM_GET, ifindex, addr));
	nmtstp_ip6_address_add (NULL, EX, ifindex, addr, IP6_PLEN, in6addr_any, lifetime, preferred, flags);
	g_assert (nm_platform_ip6_address_get (NM_PLATFORM_GET, ifindex, addr));
	accept_signal (address_added);

	/* Add address again (aka update) */
	nmtstp_ip6_address_add (NULL, EX, ifindex, addr, IP6_PLEN, in6addr_any, lifetime, preferred, flags);
	accept_signals (address_changed, 0, 2);

	/* Test address listing */
	addresses = nmtstp_platform_ip6_address_get_all (NM_PLATFORM_GET, ifindex);
	g_assert (addresses);
	g_assert_cmpint (addresses->len, ==, 1);
	address = &g_array_index (addresses, NMPlatformIP6Address, 0);
	g_assert_cmpint (address->ifindex, ==, ifindex);
	g_assert (!memcmp (&address->address, &addr, sizeof (addr)));
	g_assert_cmpint (address->plen, ==, IP6_PLEN);
	g_array_unref (addresses);

	/* Remove address */
	nmtstp_ip6_address_del (NULL, EX, ifindex, addr, IP6_PLEN);
	g_assert (!nm_platform_ip6_address_get (NM_PLATFORM_GET, ifindex, addr));
	accept_signal (address_removed);

	/* Remove address again */
	nmtstp_ip6_address_del (NULL, EX, ifindex, addr, IP6_PLEN);

	/* ensure not pending signal. */
	accept_signals (address_changed, 0, 1);

	free_signal (address_added);
	free_signal (address_changed);
	free_signal (address_removed);
}

static void
test_ip4_address_general_2 (void)
{
	const int ifindex = DEVICE_IFINDEX;
	SignalData *address_added = add_signal (NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_ADDED, ip4_address_callback);
	SignalData *address_removed = add_signal (NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_REMOVED, ip4_address_callback);
	in_addr_t addr;
	guint32 lifetime = 2000;
	guint32 preferred = 1000;

	inet_pton (AF_INET, IP4_ADDRESS, &addr);
	g_assert (ifindex > 0);

	/* Looks like addresses are not announced by kernel when the interface
	 * is down. Link-local IPv6 address is automatically added.
	 */
	g_assert (nm_platform_link_set_up (NM_PLATFORM_GET, DEVICE_IFINDEX, NULL));

	/* Add/delete notification */
	nmtstp_ip4_address_add (NULL, EX, ifindex, addr, IP4_PLEN, addr, lifetime, preferred, 0, NULL);
	accept_signal (address_added);
	g_assert (nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr));
	nmtstp_ip4_address_del (NULL, EX, ifindex, addr, IP4_PLEN, addr);
	accept_signal (address_removed);
	g_assert (!nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr));

	/* Add/delete conflict */
	nmtstp_ip4_address_add (NULL, EX, ifindex, addr, IP4_PLEN, addr, lifetime, preferred, 0, NULL);
	g_assert (nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr));
	accept_signal (address_added);

	free_signal (address_added);
	free_signal (address_removed);
}

static void
test_ip6_address_general_2 (void)
{
	const int ifindex = DEVICE_IFINDEX;
	SignalData *address_added = add_signal (NM_PLATFORM_SIGNAL_IP6_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_ADDED, ip6_address_callback);
	SignalData *address_removed = add_signal (NM_PLATFORM_SIGNAL_IP6_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_REMOVED, ip6_address_callback);
	struct in6_addr addr;
	guint32 lifetime = 2000;
	guint32 preferred = 1000;
	guint flags = 0;

	inet_pton (AF_INET6, IP6_ADDRESS, &addr);

	/* Add/delete notification */
	nmtstp_ip6_address_add (NULL, EX, ifindex, addr, IP6_PLEN, in6addr_any, lifetime, preferred, 0);
	accept_signal (address_added);
	g_assert (nm_platform_ip6_address_get (NM_PLATFORM_GET, ifindex, addr));

	nmtstp_ip6_address_del (NULL, EX, ifindex, addr, IP6_PLEN);
	accept_signal (address_removed);
	g_assert (!nm_platform_ip6_address_get (NM_PLATFORM_GET, ifindex, addr));

	/* Add/delete conflict */
	nmtstp_ip6_address_add (NULL, EX, ifindex, addr, IP6_PLEN, in6addr_any, lifetime, preferred, 0);
	accept_signal (address_added);
	g_assert (nm_platform_ip6_address_get (NM_PLATFORM_GET, ifindex, addr));

	nmtstp_ip6_address_add (NULL, EX, ifindex, addr, IP6_PLEN, in6addr_any, lifetime, preferred, flags);
	ensure_no_signal (address_added);
	g_assert (nm_platform_ip6_address_get (NM_PLATFORM_GET, ifindex, addr));

	free_signal (address_added);
	free_signal (address_removed);
}

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

static void
test_ip4_address_peer (void)
{
	const int ifindex = DEVICE_IFINDEX;
	SignalData *address_added = add_signal (NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_ADDED, ip4_address_callback);
	SignalData *address_removed = add_signal (NM_PLATFORM_SIGNAL_IP4_ADDRESS_CHANGED, NM_PLATFORM_SIGNAL_REMOVED, ip4_address_callback);
	in_addr_t addr, addr_peer, addr_peer2;
	guint32 lifetime = 2000;
	guint32 preferred = 1000;
	const NMPlatformIP4Address *a;

	inet_pton (AF_INET, IP4_ADDRESS, &addr);
	inet_pton (AF_INET, IP4_ADDRESS_PEER, &addr_peer);
	inet_pton (AF_INET, IP4_ADDRESS_PEER2, &addr_peer2);
	g_assert (ifindex > 0);

	g_assert (addr != addr_peer);

	g_assert (nm_platform_link_set_up (NM_PLATFORM_GET, ifindex, NULL));
	accept_signals (address_removed, 0, G_MAXINT);
	accept_signals (address_added, 0, G_MAXINT);

	/* Add/delete notification */
	nmtstp_ip4_address_add (NULL, EX, ifindex, addr, IP4_PLEN, addr_peer, lifetime, preferred, 0, NULL);
	accept_signal (address_added);
	a = nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr_peer);
	g_assert (a);
	g_assert (!nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr_peer2));

	nmtstp_ip_address_assert_lifetime ((NMPlatformIPAddress *) a, -1, lifetime, preferred);

	nmtstp_ip4_address_add (NULL, EX, ifindex, addr, IP4_PLEN, addr_peer2, lifetime, preferred, 0, NULL);
	accept_signal (address_added);
	g_assert (nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr_peer));
	a = nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr_peer2);
	g_assert (a);

	nmtstp_ip_address_assert_lifetime ((NMPlatformIPAddress *) a, -1, lifetime, preferred);

	g_assert (addr != addr_peer);
	nmtstp_ip4_address_del (NULL, EX, ifindex, addr, IP4_PLEN, addr_peer);
	accept_signal (address_removed);
	g_assert (!nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr_peer));
	g_assert (nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, IP4_PLEN, addr_peer2));

	free_signal (address_added);
	free_signal (address_removed);
}

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

static void
test_ip4_address_peer_zero (void)
{
	const int ifindex = DEVICE_IFINDEX;
	in_addr_t addr, addr_peer;
	guint32 lifetime = 2000;
	guint32 preferred = 1000;
	const gint8 plen = 24;
	const char *label = NULL;
	in_addr_t peers[3], r_peers[3];
	int i;
	GArray *addrs;

	g_assert (ifindex > 0);

	inet_pton (AF_INET, "192.168.5.2", &addr);
	inet_pton (AF_INET, "192.168.6.2", &addr_peer);
	peers[0] = addr;
	peers[1] = addr_peer;
	peers[2] = 0;

	g_assert (nm_platform_link_set_up (NM_PLATFORM_GET, ifindex, NULL));

	nmtst_rand_perm (NULL, r_peers, peers, sizeof (peers[0]), G_N_ELEMENTS (peers));
	for (i = 0; i < G_N_ELEMENTS (peers); i++) {
		g_assert (!nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, plen, r_peers[i]));

		nmtstp_ip4_address_add (NULL, EX, ifindex, addr, plen, r_peers[i], lifetime, preferred, 0, label);

		addrs = nmtstp_platform_ip4_address_get_all (NM_PLATFORM_GET, ifindex);
		g_assert (addrs);
		g_assert_cmpint (addrs->len, ==, i + 1);
		g_array_unref (addrs);
	}

	if (nmtst_is_debug () && nmtstp_is_root_test ())
		nmtstp_run_command_check ("ip address show dev %s", DEVICE_NAME);

	nmtst_rand_perm (NULL, r_peers, peers, sizeof (peers[0]), G_N_ELEMENTS (peers));
	for (i = 0; i < G_N_ELEMENTS (peers); i++) {
		g_assert (nm_platform_ip4_address_get (NM_PLATFORM_GET, ifindex, addr, plen, r_peers[i]));

		nmtstp_ip4_address_del (NULL, EX, ifindex, addr, plen, r_peers[i]);

		addrs = nmtstp_platform_ip4_address_get_all (NM_PLATFORM_GET, ifindex);
		g_assert (addrs);
		g_assert_cmpint (addrs->len, ==, G_N_ELEMENTS (peers) - i - 1);
		g_array_unref (addrs);
	}
}

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

NMTstpSetupFunc const _nmtstp_setup_platform_func = SETUP;

void
_nmtstp_init_tests (int *argc, char ***argv)
{
	nmtst_init_with_logging (argc, argv, NULL, "ALL");
}

/*****************************************************************************
 * SETUP TESTS
 *****************************************************************************/

void
_nmtstp_setup_tests (void)
{
#define add_test_func(testpath, test_func) nmtstp_env1_add_test_func(testpath, test_func, FALSE)
	add_test_func ("/address/ipv4/general", test_ip4_address_general);
	add_test_func ("/address/ipv6/general", test_ip6_address_general);

	add_test_func ("/address/ipv4/general-2", test_ip4_address_general_2);
	add_test_func ("/address/ipv6/general-2", test_ip6_address_general_2);

	add_test_func ("/address/ipv4/peer", test_ip4_address_peer);
	add_test_func ("/address/ipv4/peer/zero", test_ip4_address_peer_zero);
}
