Adding upstream version 8.4.4.upstream/8.4.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 493 insertions, 0 deletions

diff --git a/tests/bgpd/test_mpath.c b/tests/bgpd/test_mpath.c
new file mode 100644
index 0000000..c20403f
--- /dev/null
+++ b/tests/bgpd/test_mpath.c
@@ -0,0 +1,493 @@
+/*
+ * 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", __func__, __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;
+extern 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);
+	FOREACH_AFI_SAFI (afi, 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;
+	FOREACH_AFI_SAFI (afi, 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_dest_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(NULL, &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(NULL, &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, NULL, 0);
+	bgp_master_init(master, BGP_SOCKET_SNDBUF_SIZE, list_new());
+	vrf_init(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;
+}