diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 09:53:30 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-28 09:53:30 +0000 |
commit | 2c7cac91ed6e7db0f6937923d2b57f97dbdbc337 (patch) | |
tree | c05dc0f8e6aa3accc84e3e5cffc933ed94941383 /tests/bgpd/test_mpath.c | |
parent | Initial commit. (diff) | |
download | frr-upstream.tar.xz frr-upstream.zip |
Adding upstream version 8.4.4.upstream/8.4.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'tests/bgpd/test_mpath.c')
-rw-r--r-- | tests/bgpd/test_mpath.c | 493 |
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; +} |