path: root/tests/bgpd/test_mpath.c

/*
 * BGP Multipath Unit Test
 * Copyright (C) 2010 Google Inc.
 *
 * This file is part of Quagga
 *
 * Quagga is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * Quagga is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "qobj.h"
#include "vty.h"
#include "stream.h"
#include "privs.h"
#include "linklist.h"
#include "memory.h"
#include "zclient.h"
#include "queue.h"
#include "filter.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_table.h"
#include "bgpd/bgp_route.h"
#include "bgpd/bgp_attr.h"
#include "bgpd/bgp_nexthop.h"
#include "bgpd/bgp_mpath.h"
#include "bgpd/bgp_evpn.h"
#include "bgpd/bgp_network.h"

#define VT100_RESET "\x1b[0m"
#define VT100_RED "\x1b[31m"
#define VT100_GREEN "\x1b[32m"
#define VT100_YELLOW "\x1b[33m"
#define OK VT100_GREEN "OK" VT100_RESET
#define FAILED VT100_RED "failed" VT100_RESET

#define TEST_PASSED 0
#define TEST_FAILED -1

#define EXPECT_TRUE(expr, res)                                                 \
	if (!(expr)) {                                                         \
		printf("Test failure in %s line %u: %s\n", __FUNCTION__,       \
		       __LINE__, #expr);                                       \
		(res) = TEST_FAILED;                                           \
	}

typedef struct testcase_t__ testcase_t;

typedef int (*test_setup_func)(testcase_t *);
typedef int (*test_run_func)(testcase_t *);
typedef int (*test_cleanup_func)(testcase_t *);

struct testcase_t__ {
	const char *desc;
	void *test_data;
	void *verify_data;
	void *tmp_data;
	test_setup_func setup;
	test_run_func run;
	test_cleanup_func cleanup;
};

/* need these to link in libbgp */
struct thread_master *master = NULL;
struct zclient *zclient;
struct zebra_privs_t bgpd_privs = {
	.user = NULL,
	.group = NULL,
	.vty_group = NULL,
};

static int tty = 0;

/* Create fake bgp instance */
static struct bgp *bgp_create_fake(as_t *as, const char *name)
{
	struct bgp *bgp;
	afi_t afi;
	safi_t safi;

	if ((bgp = XCALLOC(MTYPE_BGP, sizeof(struct bgp))) == NULL)
		return NULL;

	bgp_lock(bgp);
	// bgp->peer_self = peer_new (bgp);
	// bgp->peer_self->host = XSTRDUP (MTYPE_BGP_PEER_HOST, "Static
	// announcement");

	bgp->peer = list_new();
	// bgp->peer->cmp = (int (*)(void *, void *)) peer_cmp;

	bgp->group = list_new();
	// bgp->group->cmp = (int (*)(void *, void *)) peer_group_cmp;

	bgp_evpn_init(bgp);
	for (afi = AFI_IP; afi < AFI_MAX; afi++)
		for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
			bgp->route[afi][safi] = bgp_table_init(bgp, afi, safi);
			bgp->aggregate[afi][safi] = bgp_table_init(
				bgp, afi, safi);
			bgp->rib[afi][safi] = bgp_table_init(bgp, afi, safi);
			bgp->maxpaths[afi][safi].maxpaths_ebgp = MULTIPATH_NUM;
			bgp->maxpaths[afi][safi].maxpaths_ibgp = MULTIPATH_NUM;
		}

	bgp_scan_init(bgp);
	bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
	bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
	bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
	bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
	bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;

	bgp->as = *as;

	if (name)
		bgp->name = strdup(name);

	return bgp;
}

/*=========================================================
 * Testcase for maximum-paths configuration
 */
static int setup_bgp_cfg_maximum_paths(testcase_t *t)
{
	as_t asn = 1;
	t->tmp_data = bgp_create_fake(&asn, NULL);
	if (!t->tmp_data)
		return -1;
	return 0;
}

static int run_bgp_cfg_maximum_paths(testcase_t *t)
{
	afi_t afi;
	safi_t safi;
	struct bgp *bgp;
	int api_result;
	int test_result = TEST_PASSED;

	bgp = t->tmp_data;
	for (afi = AFI_IP; afi < AFI_MAX; afi++)
		for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
			/* test bgp_maximum_paths_set */
			api_result = bgp_maximum_paths_set(
				bgp, afi, safi, BGP_PEER_EBGP, 10, 0);
			EXPECT_TRUE(api_result == 0, test_result);
			api_result = bgp_maximum_paths_set(
				bgp, afi, safi, BGP_PEER_IBGP, 10, 0);
			EXPECT_TRUE(api_result == 0, test_result);
			EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ebgp
					    == 10,
				    test_result);
			EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ibgp
					    == 10,
				    test_result);

			/* test bgp_maximum_paths_unset */
			api_result = bgp_maximum_paths_unset(bgp, afi, safi,
							     BGP_PEER_EBGP);
			EXPECT_TRUE(api_result == 0, test_result);
			api_result = bgp_maximum_paths_unset(bgp, afi, safi,
							     BGP_PEER_IBGP);
			EXPECT_TRUE(api_result == 0, test_result);
			EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ebgp
				     == MULTIPATH_NUM),
				    test_result);
			EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ibgp
				     == MULTIPATH_NUM),
				    test_result);
		}

	return test_result;
}

static int cleanup_bgp_cfg_maximum_paths(testcase_t *t)
{
	return bgp_delete((struct bgp *)t->tmp_data);
}

testcase_t test_bgp_cfg_maximum_paths = {
	.desc = "Test bgp maximum-paths config",
	.setup = setup_bgp_cfg_maximum_paths,
	.run = run_bgp_cfg_maximum_paths,
	.cleanup = cleanup_bgp_cfg_maximum_paths,
};

/*=========================================================
 * Testcase for bgp_mp_list
 */
struct peer test_mp_list_peer[] = {
	{.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
	{.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
	{.local_as = 1, .as = 2},
};
int test_mp_list_peer_count = array_size(test_mp_list_peer);
struct attr test_mp_list_attr[4];
struct bgp_path_info test_mp_list_info[] = {
	{.peer = &test_mp_list_peer[0], .attr = &test_mp_list_attr[0]},
	{.peer = &test_mp_list_peer[1], .attr = &test_mp_list_attr[1]},
	{.peer = &test_mp_list_peer[2], .attr = &test_mp_list_attr[1]},
	{.peer = &test_mp_list_peer[3], .attr = &test_mp_list_attr[2]},
	{.peer = &test_mp_list_peer[4], .attr = &test_mp_list_attr[3]},
};
int test_mp_list_info_count = array_size(test_mp_list_info);

static int setup_bgp_mp_list(testcase_t *t)
{
	test_mp_list_attr[0].nexthop.s_addr = 0x01010101;
	test_mp_list_attr[1].nexthop.s_addr = 0x02020202;
	test_mp_list_attr[2].nexthop.s_addr = 0x03030303;
	test_mp_list_attr[3].nexthop.s_addr = 0x04040404;

	if ((test_mp_list_peer[0].su_remote = sockunion_str2su("1.1.1.1"))
	    == NULL)
		return -1;
	if ((test_mp_list_peer[1].su_remote = sockunion_str2su("2.2.2.2"))
	    == NULL)
		return -1;
	if ((test_mp_list_peer[2].su_remote = sockunion_str2su("3.3.3.3"))
	    == NULL)
		return -1;
	if ((test_mp_list_peer[3].su_remote = sockunion_str2su("4.4.4.4"))
	    == NULL)
		return -1;
	if ((test_mp_list_peer[4].su_remote = sockunion_str2su("5.5.5.5"))
	    == NULL)
		return -1;

	return 0;
}

static int run_bgp_mp_list(testcase_t *t)
{
	struct list mp_list;
	struct listnode *mp_node;
	struct bgp_path_info *info;
	int i;
	int test_result = TEST_PASSED;
	bgp_mp_list_init(&mp_list);
	EXPECT_TRUE(listcount(&mp_list) == 0, test_result);

	bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[2]);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);

	for (i = 0, mp_node = mp_list.head; i < test_mp_list_info_count;
	     i++, mp_node = listnextnode(mp_node)) {
		info = listgetdata(mp_node);
		EXPECT_TRUE(info == &test_mp_list_info[i], test_result);
	}

	bgp_mp_list_clear(&mp_list);
	EXPECT_TRUE(listcount(&mp_list) == 0, test_result);

	return test_result;
}

static int cleanup_bgp_mp_list(testcase_t *t)
{
	int i;

	for (i = 0; i < test_mp_list_peer_count; i++)
		sockunion_free(test_mp_list_peer[i].su_remote);

	return 0;
}

testcase_t test_bgp_mp_list = {
	.desc = "Test bgp_mp_list",
	.setup = setup_bgp_mp_list,
	.run = run_bgp_mp_list,
	.cleanup = cleanup_bgp_mp_list,
};

/*=========================================================
 * Testcase for bgp_path_info_mpath_update
 */

struct bgp_node test_rn;

static int setup_bgp_path_info_mpath_update(testcase_t *t)
{
	int i;
	struct bgp *bgp;
	struct bgp_table *rt;
	struct route_node *rt_node;
	as_t asn = 1;

	t->tmp_data = bgp_create_fake(&asn, NULL);
	if (!t->tmp_data)
		return -1;

	bgp = t->tmp_data;
	rt = bgp->rib[AFI_IP][SAFI_UNICAST];

	if (!rt)
		return -1;

	str2prefix("42.1.1.0/24", &test_rn.p);
	rt_node = bgp_node_to_rnode(&test_rn);
	memcpy((struct route_table *)&rt_node->table, &rt->route_table,
	       sizeof(struct route_table));
	setup_bgp_mp_list(t);
	for (i = 0; i < test_mp_list_info_count; i++)
		bgp_path_info_add(&test_rn, &test_mp_list_info[i]);
	return 0;
}

static int run_bgp_path_info_mpath_update(testcase_t *t)
{
	struct bgp_path_info *new_best, *old_best, *mpath;
	struct list mp_list;
	struct bgp_maxpaths_cfg mp_cfg = {3, 3};
	int test_result = TEST_PASSED;
	bgp_mp_list_init(&mp_list);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
	new_best = &test_mp_list_info[3];
	old_best = NULL;
	bgp_path_info_mpath_update(&test_rn, new_best, old_best, &mp_list,
				   &mp_cfg);
	bgp_mp_list_clear(&mp_list);
	EXPECT_TRUE(bgp_path_info_mpath_count(new_best) == 2, test_result);
	mpath = bgp_path_info_mpath_first(new_best);
	EXPECT_TRUE(mpath == &test_mp_list_info[0], test_result);
	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_MULTIPATH), test_result);
	mpath = bgp_path_info_mpath_next(mpath);
	EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_MULTIPATH), test_result);

	bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
	bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
	new_best = &test_mp_list_info[0];
	old_best = &test_mp_list_info[3];
	bgp_path_info_mpath_update(&test_rn, new_best, old_best, &mp_list,
				   &mp_cfg);
	bgp_mp_list_clear(&mp_list);
	EXPECT_TRUE(bgp_path_info_mpath_count(new_best) == 1, test_result);
	mpath = bgp_path_info_mpath_first(new_best);
	EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
	EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_PATH_MULTIPATH), test_result);
	EXPECT_TRUE(!CHECK_FLAG(test_mp_list_info[0].flags, BGP_PATH_MULTIPATH),
		    test_result);

	return test_result;
}

static int cleanup_bgp_path_info_mpath_update(testcase_t *t)
{
	int i;

	for (i = 0; i < test_mp_list_peer_count; i++)
		sockunion_free(test_mp_list_peer[i].su_remote);

	return bgp_delete((struct bgp *)t->tmp_data);
}

testcase_t test_bgp_path_info_mpath_update = {
	.desc = "Test bgp_path_info_mpath_update",
	.setup = setup_bgp_path_info_mpath_update,
	.run = run_bgp_path_info_mpath_update,
	.cleanup = cleanup_bgp_path_info_mpath_update,
};

/*=========================================================
 * Set up testcase vector
 */
testcase_t *all_tests[] = {
	&test_bgp_cfg_maximum_paths, &test_bgp_mp_list,
	&test_bgp_path_info_mpath_update,
};

int all_tests_count = array_size(all_tests);

/*=========================================================
 * Test Driver Functions
 */
static int global_test_init(void)
{
	qobj_init();
	master = thread_master_create(NULL);
	zclient = zclient_new(master, &zclient_options_default);
	bgp_master_init(master, BGP_SOCKET_SNDBUF_SIZE);
	vrf_init(NULL, NULL, NULL, NULL, NULL);
	bgp_option_set(BGP_OPT_NO_LISTEN);

	if (fileno(stdout) >= 0)
		tty = isatty(fileno(stdout));
	return 0;
}

static int global_test_cleanup(void)
{
	if (zclient != NULL)
		zclient_free(zclient);
	thread_master_free(master);
	return 0;
}

static void display_result(testcase_t *test, int result)
{
	if (tty)
		printf("%s: %s\n", test->desc,
		       result == TEST_PASSED ? OK : FAILED);
	else
		printf("%s: %s\n", test->desc,
		       result == TEST_PASSED ? "OK" : "FAILED");
}

static int setup_test(testcase_t *t)
{
	int res = 0;
	if (t->setup)
		res = t->setup(t);
	return res;
}

static int cleanup_test(testcase_t *t)
{
	int res = 0;
	if (t->cleanup)
		res = t->cleanup(t);
	return res;
}

static void run_tests(testcase_t *tests[], int num_tests, int *pass_count,
		      int *fail_count)
{
	int test_index, result;
	testcase_t *cur_test;

	*pass_count = *fail_count = 0;

	for (test_index = 0; test_index < num_tests; test_index++) {
		cur_test = tests[test_index];
		if (!cur_test->desc) {
			printf("error: test %d has no description!\n",
			       test_index);
			continue;
		}
		if (!cur_test->run) {
			printf("error: test %s has no run function!\n",
			       cur_test->desc);
			continue;
		}
		if (setup_test(cur_test) != 0) {
			printf("error: setup failed for test %s\n",
			       cur_test->desc);
			continue;
		}
		result = cur_test->run(cur_test);
		if (result == TEST_PASSED)
			*pass_count += 1;
		else
			*fail_count += 1;
		display_result(cur_test, result);
		if (cleanup_test(cur_test) != 0) {
			printf("error: cleanup failed for test %s\n",
			       cur_test->desc);
			continue;
		}
	}
}

int main(void)
{
	int pass_count, fail_count;
	time_t cur_time;

	time(&cur_time);
	printf("BGP Multipath Tests Run at %s", ctime(&cur_time));
	if (global_test_init() != 0) {
		printf("Global init failed. Terminating.\n");
		exit(1);
	}
	run_tests(all_tests, all_tests_count, &pass_count, &fail_count);
	global_test_cleanup();
	printf("Total pass/fail: %d/%d\n", pass_count, fail_count);
	return fail_count;
}