tests/bgpd/test_mpath.c

   1 /*
   2  * BGP Multipath Unit Test
   3  * Copyright (C) 2010 Google Inc.
   4  *
   5  * This file is part of Quagga
   6  *
   7  * Quagga is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the
   9  * Free Software Foundation; either version 2, or (at your option) any
  10  * later version.
  11  *
  12  * Quagga is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; see the file COPYING; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "qobj.h"
  25 #include "vty.h"
  26 #include "stream.h"
  27 #include "privs.h"
  28 #include "linklist.h"
  29 #include "memory.h"
  30 #include "zclient.h"
  31 #include "queue.h"
  32 #include "filter.h"
  33
  34 #include "bgpd/bgpd.h"
  35 #include "bgpd/bgp_table.h"
  36 #include "bgpd/bgp_route.h"
  37 #include "bgpd/bgp_attr.h"
  38 #include "bgpd/bgp_nexthop.h"
  39 #include "bgpd/bgp_mpath.h"
  40
  41 #define VT100_RESET "\x1b[0m"
  42 #define VT100_RED "\x1b[31m"
  43 #define VT100_GREEN "\x1b[32m"
  44 #define VT100_YELLOW "\x1b[33m"
  45 #define OK VT100_GREEN "OK" VT100_RESET
  46 #define FAILED VT100_RED "failed" VT100_RESET
  47
  48 #define TEST_PASSED 0
  49 #define TEST_FAILED -1
  50
  51 #define EXPECT_TRUE(expr, res)                                                 \
  52         if (!(expr)) {                                                         \
  53                 printf("Test failure in %s line %u: %s\n", __FUNCTION__,       \
  54                        __LINE__, #expr);                                       \
  55                 (res) = TEST_FAILED;                                           \
  56         }
  57
  58 typedef struct testcase_t__ testcase_t;
  59
  60 typedef int (*test_setup_func)(testcase_t *);
  61 typedef int (*test_run_func)(testcase_t *);
  62 typedef int (*test_cleanup_func)(testcase_t *);
  63
  64 struct testcase_t__ {
  65         const char *desc;
  66         void *test_data;
  67         void *verify_data;
  68         void *tmp_data;
  69         test_setup_func setup;
  70         test_run_func run;
  71         test_cleanup_func cleanup;
  72 };
  73
  74 /* need these to link in libbgp */
  75 struct thread_master *master = NULL;
  76 struct zclient *zclient;
  77 struct zebra_privs_t bgpd_privs = {
  78         .user = NULL,
  79         .group = NULL,
  80         .vty_group = NULL,
  81 };
  82
  83 static int tty = 0;
  84
  85 /* Create fake bgp instance */
  86 static struct bgp *bgp_create_fake(as_t *as, const char *name)
  87 {
  88         struct bgp *bgp;
  89         afi_t afi;
  90         safi_t safi;
  91
  92         if ((bgp = XCALLOC(MTYPE_BGP, sizeof(struct bgp))) == NULL)
  93                 return NULL;
  94
  95         bgp_lock(bgp);
  96         // bgp->peer_self = peer_new (bgp);
  97         // bgp->peer_self->host = XSTRDUP (MTYPE_BGP_PEER_HOST, "Static
  98         // announcement");
  99
 100         bgp->peer = list_new();
 101         // bgp->peer->cmp = (int (*)(void *, void *)) peer_cmp;
 102
 103         bgp->group = list_new();
 104         // bgp->group->cmp = (int (*)(void *, void *)) peer_group_cmp;
 105
 106         for (afi = AFI_IP; afi < AFI_MAX; afi++)
 107                 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
 108                         bgp->route[afi][safi] = bgp_table_init(bgp, afi, safi);
 109                         bgp->aggregate[afi][safi] = bgp_table_init(
 110                                 bgp, afi, safi);
 111                         bgp->rib[afi][safi] = bgp_table_init(bgp, afi, safi);
 112                         bgp->maxpaths[afi][safi].maxpaths_ebgp = MULTIPATH_NUM;
 113                         bgp->maxpaths[afi][safi].maxpaths_ibgp = MULTIPATH_NUM;
 114                 }
 115
 116         bgp_scan_init(bgp);
 117         bgp->default_local_pref = BGP_DEFAULT_LOCAL_PREF;
 118         bgp->default_holdtime = BGP_DEFAULT_HOLDTIME;
 119         bgp->default_keepalive = BGP_DEFAULT_KEEPALIVE;
 120         bgp->restart_time = BGP_DEFAULT_RESTART_TIME;
 121         bgp->stalepath_time = BGP_DEFAULT_STALEPATH_TIME;
 122
 123         bgp->as = *as;
 124
 125         if (name)
 126                 bgp->name = strdup(name);
 127
 128         return bgp;
 129 }
 130
 131 /*=========================================================
 132  * Testcase for maximum-paths configuration
 133  */
 134 static int setup_bgp_cfg_maximum_paths(testcase_t *t)
 135 {
 136         as_t asn = 1;
 137         t->tmp_data = bgp_create_fake(&asn, NULL);
 138         if (!t->tmp_data)
 139                 return -1;
 140         return 0;
 141 }
 142
 143 static int run_bgp_cfg_maximum_paths(testcase_t *t)
 144 {
 145         afi_t afi;
 146         safi_t safi;
 147         struct bgp *bgp;
 148         int api_result;
 149         int test_result = TEST_PASSED;
 150
 151         bgp = t->tmp_data;
 152         for (afi = AFI_IP; afi < AFI_MAX; afi++)
 153                 for (safi = SAFI_UNICAST; safi < SAFI_MAX; safi++) {
 154                         /* test bgp_maximum_paths_set */
 155                         api_result = bgp_maximum_paths_set(
 156                                 bgp, afi, safi, BGP_PEER_EBGP, 10, 0);
 157                         EXPECT_TRUE(api_result == 0, test_result);
 158                         api_result = bgp_maximum_paths_set(
 159                                 bgp, afi, safi, BGP_PEER_IBGP, 10, 0);
 160                         EXPECT_TRUE(api_result == 0, test_result);
 161                         EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ebgp
 162                                             == 10,
 163                                     test_result);
 164                         EXPECT_TRUE(bgp->maxpaths[afi][safi].maxpaths_ibgp
 165                                             == 10,
 166                                     test_result);
 167
 168                         /* test bgp_maximum_paths_unset */
 169                         api_result = bgp_maximum_paths_unset(bgp, afi, safi,
 170                                                              BGP_PEER_EBGP);
 171                         EXPECT_TRUE(api_result == 0, test_result);
 172                         api_result = bgp_maximum_paths_unset(bgp, afi, safi,
 173                                                              BGP_PEER_IBGP);
 174                         EXPECT_TRUE(api_result == 0, test_result);
 175                         EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ebgp
 176                                      == MULTIPATH_NUM),
 177                                     test_result);
 178                         EXPECT_TRUE((bgp->maxpaths[afi][safi].maxpaths_ibgp
 179                                      == MULTIPATH_NUM),
 180                                     test_result);
 181                 }
 182
 183         return test_result;
 184 }
 185
 186 static int cleanup_bgp_cfg_maximum_paths(testcase_t *t)
 187 {
 188         return bgp_delete((struct bgp *)t->tmp_data);
 189 }
 190
 191 testcase_t test_bgp_cfg_maximum_paths = {
 192         .desc = "Test bgp maximum-paths config",
 193         .setup = setup_bgp_cfg_maximum_paths,
 194         .run = run_bgp_cfg_maximum_paths,
 195         .cleanup = cleanup_bgp_cfg_maximum_paths,
 196 };
 197
 198 /*=========================================================
 199  * Testcase for bgp_mp_list
 200  */
 201 struct peer test_mp_list_peer[] = {
 202         {.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
 203         {.local_as = 1, .as = 2}, {.local_as = 1, .as = 2},
 204         {.local_as = 1, .as = 2},
 205 };
 206 int test_mp_list_peer_count = sizeof(test_mp_list_peer) / sizeof(struct peer);
 207 struct attr test_mp_list_attr[4];
 208 struct bgp_info test_mp_list_info[] = {
 209         {.peer = &test_mp_list_peer[0], .attr = &test_mp_list_attr[0]},
 210         {.peer = &test_mp_list_peer[1], .attr = &test_mp_list_attr[1]},
 211         {.peer = &test_mp_list_peer[2], .attr = &test_mp_list_attr[1]},
 212         {.peer = &test_mp_list_peer[3], .attr = &test_mp_list_attr[2]},
 213         {.peer = &test_mp_list_peer[4], .attr = &test_mp_list_attr[3]},
 214 };
 215 int test_mp_list_info_count =
 216         sizeof(test_mp_list_info) / sizeof(struct bgp_info);
 217
 218 static int setup_bgp_mp_list(testcase_t *t)
 219 {
 220         test_mp_list_attr[0].nexthop.s_addr = 0x01010101;
 221         test_mp_list_attr[1].nexthop.s_addr = 0x02020202;
 222         test_mp_list_attr[2].nexthop.s_addr = 0x03030303;
 223         test_mp_list_attr[3].nexthop.s_addr = 0x04040404;
 224
 225         if ((test_mp_list_peer[0].su_remote = sockunion_str2su("1.1.1.1"))
 226             == NULL)
 227                 return -1;
 228         if ((test_mp_list_peer[1].su_remote = sockunion_str2su("2.2.2.2"))
 229             == NULL)
 230                 return -1;
 231         if ((test_mp_list_peer[2].su_remote = sockunion_str2su("3.3.3.3"))
 232             == NULL)
 233                 return -1;
 234         if ((test_mp_list_peer[3].su_remote = sockunion_str2su("4.4.4.4"))
 235             == NULL)
 236                 return -1;
 237         if ((test_mp_list_peer[4].su_remote = sockunion_str2su("5.5.5.5"))
 238             == NULL)
 239                 return -1;
 240
 241         return 0;
 242 }
 243
 244 static int run_bgp_mp_list(testcase_t *t)
 245 {
 246         struct list mp_list;
 247         struct listnode *mp_node;
 248         struct bgp_info *info;
 249         int i;
 250         int test_result = TEST_PASSED;
 251         bgp_mp_list_init(&mp_list);
 252         EXPECT_TRUE(listcount(&mp_list) == 0, test_result);
 253
 254         bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
 255         bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
 256         bgp_mp_list_add(&mp_list, &test_mp_list_info[2]);
 257         bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
 258         bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
 259
 260         for (i = 0, mp_node = mp_list.head; i < test_mp_list_info_count;
 261              i++, mp_node = listnextnode(mp_node)) {
 262                 info = listgetdata(mp_node);
 263                 EXPECT_TRUE(info == &test_mp_list_info[i], test_result);
 264         }
 265
 266         bgp_mp_list_clear(&mp_list);
 267         EXPECT_TRUE(listcount(&mp_list) == 0, test_result);
 268
 269         return test_result;
 270 }
 271
 272 static int cleanup_bgp_mp_list(testcase_t *t)
 273 {
 274         int i;
 275
 276         for (i = 0; i < test_mp_list_peer_count; i++)
 277                 sockunion_free(test_mp_list_peer[i].su_remote);
 278
 279         return 0;
 280 }
 281
 282 testcase_t test_bgp_mp_list = {
 283         .desc = "Test bgp_mp_list",
 284         .setup = setup_bgp_mp_list,
 285         .run = run_bgp_mp_list,
 286         .cleanup = cleanup_bgp_mp_list,
 287 };
 288
 289 /*=========================================================
 290  * Testcase for bgp_info_mpath_update
 291  */
 292
 293 struct bgp_node test_rn;
 294
 295 static int setup_bgp_info_mpath_update(testcase_t *t)
 296 {
 297         int i;
 298         str2prefix("42.1.1.0/24", &test_rn.p);
 299         setup_bgp_mp_list(t);
 300         for (i = 0; i < test_mp_list_info_count; i++)
 301                 bgp_info_add(&test_rn, &test_mp_list_info[i]);
 302         return 0;
 303 }
 304
 305 static int run_bgp_info_mpath_update(testcase_t *t)
 306 {
 307         struct bgp_info *new_best, *old_best, *mpath;
 308         struct list mp_list;
 309         struct bgp_maxpaths_cfg mp_cfg = {3, 3};
 310         int test_result = TEST_PASSED;
 311         bgp_mp_list_init(&mp_list);
 312         bgp_mp_list_add(&mp_list, &test_mp_list_info[4]);
 313         bgp_mp_list_add(&mp_list, &test_mp_list_info[3]);
 314         bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
 315         bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
 316         new_best = &test_mp_list_info[3];
 317         old_best = NULL;
 318         bgp_info_mpath_update(&test_rn, new_best, old_best, &mp_list, &mp_cfg);
 319         bgp_mp_list_clear(&mp_list);
 320         EXPECT_TRUE(bgp_info_mpath_count(new_best) == 2, test_result);
 321         mpath = bgp_info_mpath_first(new_best);
 322         EXPECT_TRUE(mpath == &test_mp_list_info[0], test_result);
 323         EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
 324         mpath = bgp_info_mpath_next(mpath);
 325         EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
 326         EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
 327
 328         bgp_mp_list_add(&mp_list, &test_mp_list_info[0]);
 329         bgp_mp_list_add(&mp_list, &test_mp_list_info[1]);
 330         new_best = &test_mp_list_info[0];
 331         old_best = &test_mp_list_info[3];
 332         bgp_info_mpath_update(&test_rn, new_best, old_best, &mp_list, &mp_cfg);
 333         bgp_mp_list_clear(&mp_list);
 334         EXPECT_TRUE(bgp_info_mpath_count(new_best) == 1, test_result);
 335         mpath = bgp_info_mpath_first(new_best);
 336         EXPECT_TRUE(mpath == &test_mp_list_info[1], test_result);
 337         EXPECT_TRUE(CHECK_FLAG(mpath->flags, BGP_INFO_MULTIPATH), test_result);
 338         EXPECT_TRUE(!CHECK_FLAG(test_mp_list_info[0].flags, BGP_INFO_MULTIPATH),
 339                     test_result);
 340
 341         return test_result;
 342 }
 343
 344 static int cleanup_bgp_info_mpath_update(testcase_t *t)
 345 {
 346         int i;
 347
 348         for (i = 0; i < test_mp_list_peer_count; i++)
 349                 sockunion_free(test_mp_list_peer[i].su_remote);
 350
 351         return 0;
 352 }
 353
 354 testcase_t test_bgp_info_mpath_update = {
 355         .desc = "Test bgp_info_mpath_update",
 356         .setup = setup_bgp_info_mpath_update,
 357         .run = run_bgp_info_mpath_update,
 358         .cleanup = cleanup_bgp_info_mpath_update,
 359 };
 360
 361 /*=========================================================
 362  * Set up testcase vector
 363  */
 364 testcase_t *all_tests[] = {
 365         &test_bgp_cfg_maximum_paths, &test_bgp_mp_list,
 366         &test_bgp_info_mpath_update,
 367 };
 368
 369 int all_tests_count = (sizeof(all_tests) / sizeof(testcase_t *));
 370
 371 /*=========================================================
 372  * Test Driver Functions
 373  */
 374 static int global_test_init(void)
 375 {
 376         qobj_init();
 377         master = thread_master_create(NULL);
 378         zclient = zclient_new_notify(master, &zclient_options_default);
 379         bgp_master_init(master);
 380         vrf_init(NULL, NULL, NULL, NULL);
 381         bgp_option_set(BGP_OPT_NO_LISTEN);
 382
 383         if (fileno(stdout) >= 0)
 384                 tty = isatty(fileno(stdout));
 385         return 0;
 386 }
 387
 388 static int global_test_cleanup(void)
 389 {
 390         if (zclient != NULL)
 391                 zclient_free(zclient);
 392         thread_master_free(master);
 393         return 0;
 394 }
 395
 396 static void display_result(testcase_t *test, int result)
 397 {
 398         if (tty)
 399                 printf("%s: %s\n", test->desc,
 400                        result == TEST_PASSED ? OK : FAILED);
 401         else
 402                 printf("%s: %s\n", test->desc,
 403                        result == TEST_PASSED ? "OK" : "FAILED");
 404 }
 405
 406 static int setup_test(testcase_t *t)
 407 {
 408         int res = 0;
 409         if (t->setup)
 410                 res = t->setup(t);
 411         return res;
 412 }
 413
 414 static int cleanup_test(testcase_t *t)
 415 {
 416         int res = 0;
 417         if (t->cleanup)
 418                 res = t->cleanup(t);
 419         return res;
 420 }
 421
 422 static void run_tests(testcase_t *tests[], int num_tests, int *pass_count,
 423                       int *fail_count)
 424 {
 425         int test_index, result;
 426         testcase_t *cur_test;
 427
 428         *pass_count = *fail_count = 0;
 429
 430         for (test_index = 0; test_index < num_tests; test_index++) {
 431                 cur_test = tests[test_index];
 432                 if (!cur_test->desc) {
 433                         printf("error: test %d has no description!\n",
 434                                test_index);
 435                         continue;
 436                 }
 437                 if (!cur_test->run) {
 438                         printf("error: test %s has no run function!\n",
 439                                cur_test->desc);
 440                         continue;
 441                 }
 442                 if (setup_test(cur_test) != 0) {
 443                         printf("error: setup failed for test %s\n",
 444                                cur_test->desc);
 445                         continue;
 446                 }
 447                 result = cur_test->run(cur_test);
 448                 if (result == TEST_PASSED)
 449                         *pass_count += 1;
 450                 else
 451                         *fail_count += 1;
 452                 display_result(cur_test, result);
 453                 if (cleanup_test(cur_test) != 0) {
 454                         printf("error: cleanup failed for test %s\n",
 455                                cur_test->desc);
 456                         continue;
 457                 }
 458         }
 459 }
 460
 461 int main(void)
 462 {
 463         int pass_count, fail_count;
 464         time_t cur_time;
 465
 466         time(&cur_time);
 467         printf("BGP Multipath Tests Run at %s", ctime(&cur_time));
 468         if (global_test_init() != 0) {
 469                 printf("Global init failed. Terminating.\n");
 470                 exit(1);
 471         }
 472         run_tests(all_tests, all_tests_count, &pass_count, &fail_count);
 473         global_test_cleanup();
 474         printf("Total pass/fail: %d/%d\n", pass_count, fail_count);
 475         return fail_count;
 476 }