tests/bgp_mpath_test.c

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