tests/bgp_capability_test.c

   1 #include <zebra.h>
   2
   3 #include "vty.h"
   4 #include "stream.h"
   5 #include "privs.h"
   6 #include "memory.h"
   7
   8 #include "bgpd/bgpd.h"
   9 #include "bgpd/bgp_open.h"
  10 #include "bgpd/bgp_debug.h"
  11
  12 #define VT100_RESET "\x1b[0m"
  13 #define VT100_RED "\x1b[31m"
  14 #define VT100_GREEN "\x1b[32m"
  15 #define VT100_YELLOW "\x1b[33m"
  16
  17
  18 #define CAPABILITY 0
  19 #define DYNCAP     1
  20 #define OPT_PARAM  2
  21
  22 /* need these to link in libbgp */
  23 struct zebra_privs_t *bgpd_privs = NULL;
  24 struct thread_master *master = NULL;
  25
  26 static int failed = 0;
  27 static int tty = 0;
  28
  29 /* test segments to parse and validate, and use for other tests */
  30 static struct test_segment {
  31   const char *name;
  32   const char *desc;
  33   const u_char data[1024];
  34   int len;
  35 #define SHOULD_PARSE    0
  36 #define SHOULD_ERR      -1
  37   int parses; /* whether it should parse or not */
  38   int peek_for; /* what peek_for_as4_capability should say */
  39
  40   /* AFI/SAFI validation */
  41   int validate_afi;
  42   afi_t afi;
  43   safi_t safi;
  44 #define VALID_AFI 1
  45 #define INVALID_AFI 0
  46   int afi_valid;
  47 } test_segments [] =
  48 {
  49   /* 0 */
  50   { "caphdr",
  51     "capability header, and no more",
  52     { CAPABILITY_CODE_REFRESH, 0x0 },
  53     2, SHOULD_PARSE,
  54   },
  55   /* 1 */
  56   { "nodata",
  57     "header, no data but length says there is",
  58     { 0x1, 0xa },
  59     2, SHOULD_ERR,
  60   },
  61   /* 2 */
  62   { "padded",
  63     "valid, with padding",
  64     { CAPABILITY_CODE_REFRESH, 0x2, 0x0, 0x0 },
  65     4, SHOULD_PARSE,
  66   },
  67   /* 3 */
  68   { "minsize",
  69     "violates minsize requirement",
  70     { CAPABILITY_CODE_ORF, 0x2, 0x0, 0x0 },
  71     4, SHOULD_ERR,
  72   },
  73   { NULL, NULL, {0}, 0, 0},
  74 };
  75
  76 static struct test_segment mp_segments[] =
  77 {
  78   { "MP4",
  79     "MP IP/Uni",
  80     { 0x1, 0x4, 0x0, 0x1, 0x0, 0x1 },
  81     6, SHOULD_PARSE, 0,
  82     1, AFI_IP, SAFI_UNICAST, VALID_AFI,
  83   },
  84   { "MPv6",
  85     "MP IPv6/Uni",
  86     { 0x1, 0x4, 0x0, 0x2, 0x0, 0x1 },
  87     6, SHOULD_PARSE, 0,
  88     1, AFI_IP6, SAFI_UNICAST, VALID_AFI,
  89   },
  90   /* 5 */
  91   { "MP2",
  92     "MP IP/Multicast",
  93     { CAPABILITY_CODE_MP, 0x4, 0x0, 0x1, 0x0, 0x2 },
  94     6, SHOULD_PARSE, 0,
  95     1, AFI_IP, SAFI_MULTICAST, VALID_AFI,
  96   },
  97   /* 6 */
  98   { "MP3",
  99     "MP IP6/VPNv4",
 100     { CAPABILITY_CODE_MP, 0x4, 0x0, 0x2, 0x0, 0x80 },
 101     6, SHOULD_PARSE, 0, /* parses, but invalid afi,safi */
 102     1, AFI_IP6, BGP_SAFI_VPNV4, INVALID_AFI,
 103   },
 104   /* 7 */
 105   { "MP5",
 106     "MP IP6/MPLS-VPN",
 107     { CAPABILITY_CODE_MP, 0x4, 0x0, 0x2, 0x0, 0x4 },
 108     6, SHOULD_PARSE, 0,
 109     1, AFI_IP6, SAFI_MPLS_VPN, VALID_AFI,
 110   },
 111   /* 8 */
 112   { "MP6",
 113     "MP IP4/VPNv4",
 114     { CAPABILITY_CODE_MP, 0x4, 0x0, 0x1, 0x0, 0x80 },
 115     6, SHOULD_PARSE, 0,
 116     1, AFI_IP, BGP_SAFI_VPNV4, VALID_AFI,
 117   },
 118   /* 9 */
 119   { "MP7",
 120     "MP IP4/VPNv6",
 121     { CAPABILITY_CODE_MP, 0x4, 0x0, 0x1, 0x0, 0x81 },
 122     6, SHOULD_PARSE, 0, /* parses, but invalid afi,safi tuple */
 123     1, AFI_IP, BGP_SAFI_VPNV6, INVALID_AFI,
 124   },
 125   /* 10 */
 126   { "MP8",
 127     "MP unknown AFI",
 128     { CAPABILITY_CODE_MP, 0x4, 0x0, 0xa, 0x0, 0x81 },
 129     6, SHOULD_PARSE, 0,
 130     1, 0xa, 0x81, INVALID_AFI, /* parses, but unknown */
 131   },
 132   /* 11 */
 133   { "MP-short",
 134     "MP IP4/Unicast, length too short (< minimum)",
 135     { CAPABILITY_CODE_MP, 0x2, 0x0, 0x1, 0x0, 0x1 },
 136     6, SHOULD_ERR,
 137   },
 138   /* 12 */
 139   { "MP-overflow",
 140     "MP IP4/Unicast, length too long",
 141     { CAPABILITY_CODE_MP, 0x6, 0x0, 0x1, 0x0, 0x1 },
 142     6, SHOULD_ERR, 0,
 143     1, AFI_IP, SAFI_UNICAST, VALID_AFI,
 144   },
 145   { NULL, NULL, {0}, 0, 0}
 146 };
 147
 148 static struct test_segment misc_segments[] =
 149 {
 150   /* 13 */
 151   { "ORF",
 152     "ORF, simple, single entry, single tuple",
 153     { /* hdr */         CAPABILITY_CODE_ORF, 0x7,
 154       /* mpc */         0x0, 0x1, 0x0, 0x1,
 155       /* num */         0x1,
 156       /* tuples */      0x40, 0x3
 157     },
 158     9, SHOULD_PARSE,
 159   },
 160   /* 14 */
 161   { "ORF-many",
 162     "ORF, multi entry/tuple",
 163     { /* hdr */         CAPABILITY_CODE_ORF, 0x21,
 164       /* mpc */         0x0, 0x1, 0x0, 0x1,
 165       /* num */         0x3,
 166       /* tuples */      0x40, ORF_MODE_BOTH,
 167                         0x80, ORF_MODE_RECEIVE,
 168                         0x80, ORF_MODE_SEND,
 169       /* mpc */         0x0, 0x2, 0x0, 0x1,
 170       /* num */         0x3,
 171       /* tuples */      0x40, ORF_MODE_BOTH,
 172                         0x80, ORF_MODE_RECEIVE,
 173                         0x80, ORF_MODE_SEND,
 174       /* mpc */         0x0, 0x2, 0x0, 0x2,
 175       /* num */         0x3,
 176       /* tuples */      0x40, ORF_MODE_RECEIVE,
 177                         0x80, ORF_MODE_SEND,
 178                         0x80, ORF_MODE_BOTH,
 179     },
 180     35, SHOULD_PARSE,
 181   },
 182   /* 15 */
 183   { "ORFlo",
 184     "ORF, multi entry/tuple, hdr length too short",
 185     { /* hdr */         CAPABILITY_CODE_ORF, 0x15,
 186       /* mpc */         0x0, 0x1, 0x0, 0x1,
 187       /* num */         0x3,
 188       /* tuples */      0x40, 0x3,
 189                         0x80, 0x1,
 190                         0x80, 0x2,
 191       /* mpc */         0x0, 0x1, 0x0, 0x1,
 192       /* num */         0x3,
 193       /* tuples */      0x40, 0x3,
 194                         0x80, 0x1,
 195                         0x80, 0x2,
 196       /* mpc */         0x0, 0x2, 0x0, 0x2,
 197       /* num */         0x3,
 198       /* tuples */      0x40, 0x3,
 199                         0x80, 0x1,
 200                         0x80, 0x2,
 201     },
 202     35, SHOULD_ERR, /* It should error on invalid Route-Refresh.. */
 203   },
 204   /* 16 */
 205   { "ORFlu",
 206     "ORF, multi entry/tuple, length too long",
 207     { /* hdr */         0x3, 0x22,
 208       /* mpc */         0x0, 0x1, 0x0, 0x1,
 209       /* num */         0x3,
 210       /* tuples */      0x40, 0x3,
 211                         0x80, 0x1,
 212                         0x80, 0x2,
 213       /* mpc */         0x0, 0x2, 0x0, 0x1,
 214       /* num */         0x3,
 215       /* tuples */      0x40, 0x3,
 216                         0x80, 0x1,
 217                         0x80, 0x2,
 218       /* mpc */         0x0, 0x2, 0x0, 0x2,
 219       /* num */         0x3,
 220       /* tuples */      0x40, 0x3,
 221                         0x80, 0x1,
 222                         0x80, 0x2,
 223     },
 224     35, SHOULD_ERR
 225   },
 226   /* 17 */
 227   { "ORFnu",
 228     "ORF, multi entry/tuple, entry number too long",
 229     { /* hdr */         0x3, 0x21,
 230       /* mpc */         0x0, 0x1, 0x0, 0x1,
 231       /* num */         0x3,
 232       /* tuples */      0x40, 0x3,
 233                         0x80, 0x1,
 234                         0x80, 0x2,
 235       /* mpc */         0x0, 0x2, 0x0, 0x1,
 236       /* num */         0x4,
 237       /* tuples */      0x40, 0x3,
 238                         0x80, 0x1,
 239                         0x80, 0x2,
 240       /* mpc */         0x0, 0x2, 0x0, 0x2,
 241       /* num */         0x3,
 242       /* tuples */      0x40, 0x3,
 243                         0x80, 0x1,
 244                         0x80, 0x2,
 245     },
 246     35, SHOULD_PARSE, /* parses, but last few tuples should be gibberish */
 247   },
 248   /* 18 */
 249   { "ORFno",
 250     "ORF, multi entry/tuple, entry number too short",
 251     { /* hdr */         0x3, 0x21,
 252       /* mpc */         0x0, 0x1, 0x0, 0x1,
 253       /* num */         0x3,
 254       /* tuples */      0x40, 0x3,
 255                         0x80, 0x1,
 256                         0x80, 0x2,
 257       /* mpc */         0x0, 0x2, 0x0, 0x1,
 258       /* num */         0x1,
 259       /* tuples */      0x40, 0x3,
 260                         0x80, 0x1,
 261                         0x80, 0x2,
 262       /* mpc */         0x0, 0x2, 0x0, 0x2,
 263       /* num */         0x3,
 264       /* tuples */      0x40, 0x3,
 265                         0x80, 0x1,
 266                         0x80, 0x2,
 267     },
 268     35, SHOULD_PARSE, /* Parses, but should get gibberish afi/safis */
 269   },
 270   /* 17 */
 271   { "ORFpad",
 272     "ORF, multi entry/tuple, padded to align",
 273     { /* hdr */         0x3, 0x22,
 274       /* mpc */         0x0, 0x1, 0x0, 0x1,
 275       /* num */         0x3,
 276       /* tuples */      0x40, 0x3,
 277                         0x80, 0x1,
 278                         0x80, 0x2,
 279       /* mpc */         0x0, 0x2, 0x0, 0x1,
 280       /* num */         0x3,
 281       /* tuples */      0x40, 0x3,
 282                         0x80, 0x1,
 283                         0x80, 0x2,
 284       /* mpc */         0x0, 0x2, 0x0, 0x2,
 285       /* num */         0x3,
 286       /* tuples */      0x40, 0x3,
 287                         0x80, 0x1,
 288                         0x80, 0x2,
 289                         0x00,
 290     },
 291     36, SHOULD_PARSE,
 292   },
 293   /* 19 */
 294   { "AS4",
 295     "AS4 capability",
 296     { 0x41, 0x4, 0xab, 0xcd, 0xef, 0x12 }, /* AS: 2882400018 */
 297     6, SHOULD_PARSE, 2882400018,
 298   },
 299   /* 20 */
 300   { "GR",
 301     "GR capability",
 302     { /* hdr */         CAPABILITY_CODE_RESTART, 0xe,
 303       /* R-bit, time */ 0xf1, 0x12,
 304       /* afi */         0x0, 0x1,
 305       /* safi */        0x1,
 306       /* flags */       0xf,
 307       /* afi */         0x0, 0x2,
 308       /* safi */        0x1,
 309       /* flags */       0x0,
 310       /* afi */         0x0, 0x2,
 311       /* safi */        0x2,
 312       /* flags */       0x1,
 313     },
 314     16, SHOULD_PARSE,
 315   },
 316   /* 21 */
 317   { "GR-short",
 318     "GR capability, but header length too short",
 319     { /* hdr */         0x40, 0xa,
 320       /* R-bit, time */ 0xf1, 0x12,
 321       /* afi */         0x0, 0x1,
 322       /* safi */        0x1,
 323       /* flags */       0xf,
 324       /* afi */         0x0, 0x2,
 325       /* safi */        0x1,
 326       /* flags */       0x0,
 327       /* afi */         0x0, 0x2,
 328       /* safi */        0x2,
 329       /* flags */       0x1,
 330     },
 331     16, SHOULD_PARSE,
 332   },
 333   /* 22 */
 334   { "GR-long",
 335     "GR capability, but header length too long",
 336     { /* hdr */         0x40, 0xf,
 337       /* R-bit, time */ 0xf1, 0x12,
 338       /* afi */         0x0, 0x1,
 339       /* safi */        0x1,
 340       /* flags */       0xf,
 341       /* afi */         0x0, 0x2,
 342       /* safi */        0x1,
 343       /* flags */       0x0,
 344       /* afi */         0x0, 0x2,
 345       /* safi */        0x2,
 346     },
 347     16, SHOULD_ERR,
 348   },
 349   { "GR-trunc",
 350     "GR capability, but truncated",
 351     { /* hdr */         0x40, 0xf,
 352       /* R-bit, time */ 0xf1, 0x12,
 353       /* afi */         0x0, 0x1,
 354       /* safi */        0x1,
 355       /* flags */       0xf,
 356       /* afi */         0x0, 0x2,
 357       /* safi */        0x1,
 358       /* flags */       0x0,
 359       /* afi */         0x0, 0x2,
 360       /* safi */        0x2,
 361       /* flags */       0x1,
 362     },
 363     15, SHOULD_ERR,
 364   },
 365   { "GR-empty",
 366     "GR capability, but empty.",
 367     { /* hdr */         0x40, 0x0,
 368     },
 369     2, SHOULD_ERR,
 370   },
 371   { "MP-empty",
 372     "MP capability, but empty.",
 373     { /* hdr */         0x1, 0x0,
 374     },
 375     2, SHOULD_ERR,
 376   },
 377   { "ORF-empty",
 378     "ORF capability, but empty.",
 379     { /* hdr */         0x3, 0x0,
 380     },
 381     2, SHOULD_ERR,
 382   },
 383   { "AS4-empty",
 384     "AS4 capability, but empty.",
 385     { /* hdr */         0x41, 0x0,
 386     },
 387     2, SHOULD_ERR,
 388   },
 389   { "dyn-empty",
 390     "Dynamic capability, but empty.",
 391     { /* hdr */         0x42, 0x0,
 392     },
 393     2, SHOULD_PARSE,
 394   },
 395   { "dyn-old",
 396     "Dynamic capability (deprecated version)",
 397     { CAPABILITY_CODE_DYNAMIC, 0x0 },
 398     2, SHOULD_PARSE,
 399   },
 400   { NULL, NULL, {0}, 0, 0}
 401 };
 402
 403 /* DYNAMIC message */
 404 struct test_segment dynamic_cap_msgs[] =
 405 {
 406   { "DynCap",
 407     "Dynamic Capability Message, IP/Multicast",
 408     { 0x0, 0x1, 0x4, 0x0, 0x1, 0x0, 0x2 },
 409       7, SHOULD_PARSE, /* horrible alignment, just as with ORF */
 410   },
 411   { "DynCapLong",
 412     "Dynamic Capability Message, IP/Multicast, truncated",
 413     { 0x0, 0x1, 0x4, 0x0, 0x1, 0x0, 0x2 },
 414       5, SHOULD_ERR,
 415   },
 416   { "DynCapPadded",
 417     "Dynamic Capability Message, IP/Multicast, padded",
 418     { 0x0, 0x1, 0x4, 0x0, 0x1, 0x0, 0x2, 0x0 },
 419       8, SHOULD_ERR, /* No way to tell padding from data.. */
 420   },
 421   { "DynCapMPCpadded",
 422     "Dynamic Capability Message, IP/Multicast, cap data padded",
 423     { 0x0, 0x1, 0x5, 0x0, 0x1, 0x0, 0x2, 0x0 },
 424       8, SHOULD_PARSE, /* You can though add padding to the capability data */
 425   },
 426   { "DynCapMPCoverflow",
 427     "Dynamic Capability Message, IP/Multicast, cap data != length",
 428     { 0x0, 0x1, 0x3, 0x0, 0x1, 0x0, 0x2, 0x0 },
 429       8, SHOULD_ERR,
 430   },
 431   { NULL, NULL, {0}, 0, 0}
 432 };
 433
 434 /* Entire Optional-Parameters block */
 435 struct test_segment opt_params[] =
 436 {
 437   { "Cap-singlets",
 438     "One capability per Optional-Param",
 439     { 0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
 440       0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
 441       0x02, 0x02, 0x80, 0x00, /* RR (old) */
 442       0x02, 0x02, 0x02, 0x00, /* RR */
 443     },
 444     24, SHOULD_PARSE,
 445   },
 446   { "Cap-series",
 447     "Series of capability, one Optional-Param",
 448     { 0x02, 0x10,
 449       0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
 450       0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
 451       0x80, 0x00, /* RR (old) */
 452       0x02, 0x00, /* RR */
 453     },
 454     18, SHOULD_PARSE,
 455   },
 456   { "AS4more",
 457     "AS4 capability after other caps (singlets)",
 458     { 0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
 459       0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
 460       0x02, 0x02, 0x80, 0x00, /* RR (old) */
 461       0x02, 0x02, 0x02, 0x00, /* RR */
 462       0x02, 0x06, 0x41, 0x04, 0x00, 0x03, 0x00, 0x06  /* AS4: 1996614 */
 463     },
 464     32, SHOULD_PARSE, 196614,
 465   },
 466   { "AS4series",
 467     "AS4 capability, in series of capabilities",
 468     { 0x02, 0x16,
 469       0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
 470       0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
 471       0x80, 0x00, /* RR (old) */
 472       0x02, 0x00, /* RR */
 473       0x41, 0x04, 0x00, 0x03, 0x00, 0x06  /* AS4: 1996614 */
 474     },
 475     24, SHOULD_PARSE, 196614,
 476   },
 477   { "AS4real",
 478     "AS4 capability, in series of capabilities",
 479     {
 480       0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/uni */
 481       0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/uni */
 482       0x02, 0x02, 0x80, 0x00, /* RR old */
 483       0x02, 0x02, 0x02, 0x00, /* RR */
 484       0x02, 0x06, 0x41, 0x04, 0x00, 0x03, 0x00, 0x06, /* AS4 */
 485     },
 486     32, SHOULD_PARSE, 196614,
 487   },
 488   { "AS4real2",
 489     "AS4 capability, in series of capabilities",
 490     {
 491       0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01,
 492       0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01,
 493       0x02, 0x02, 0x80, 0x00,
 494       0x02, 0x02, 0x02, 0x00,
 495       0x02, 0x06, 0x41, 0x04, 0x00, 0x00, 0xfc, 0x03,
 496       0x02, 0x09, 0x82, 0x07, 0x00, 0x01, 0x00, 0x01, 0x01, 0x80, 0x03,
 497       0x02, 0x09, 0x03, 0x07, 0x00, 0x01, 0x00, 0x01, 0x01, 0x40, 0x03,
 498       0x02, 0x02, 0x42, 0x00,
 499     },
 500     58, SHOULD_PARSE, 64515,
 501   },
 502
 503   { NULL, NULL, {0}, 0, 0}
 504 };
 505
 506 /* basic parsing test */
 507 static void
 508 parse_test (struct peer *peer, struct test_segment *t, int type)
 509 {
 510   int ret;
 511   int capability = 0;
 512   as_t as4 = 0;
 513   int oldfailed = failed;
 514   int len = t->len;
 515 #define RANDOM_FUZZ 35
 516
 517   stream_reset (peer->ibuf);
 518   stream_put (peer->ibuf, NULL, RANDOM_FUZZ);
 519   stream_set_getp (peer->ibuf, RANDOM_FUZZ);
 520
 521   switch (type)
 522     {
 523       case CAPABILITY:
 524         stream_putc (peer->ibuf, BGP_OPEN_OPT_CAP);
 525         stream_putc (peer->ibuf, t->len);
 526         break;
 527       case DYNCAP:
 528 /*        for (i = 0; i < BGP_MARKER_SIZE; i++)
 529           stream_putc (peer->, 0xff);
 530         stream_putw (s, 0);
 531         stream_putc (s, BGP_MSG_CAPABILITY);*/
 532         break;
 533     }
 534   stream_write (peer->ibuf, t->data, t->len);
 535
 536   printf ("%s: %s\n", t->name, t->desc);
 537
 538   switch (type)
 539     {
 540       case CAPABILITY:
 541         len += 2; /* to cover the OPT-Param header */
 542       case OPT_PARAM:
 543         printf ("len: %u\n", len);
 544         /* peek_for_as4 wants getp at capibility*/
 545         as4 = peek_for_as4_capability (peer, len);
 546         printf ("peek_for_as4: as4 is %u\n", as4);
 547         /* and it should leave getp as it found it */
 548         assert (stream_get_getp (peer->ibuf) == RANDOM_FUZZ);
 549
 550         ret = bgp_open_option_parse (peer, len, &capability);
 551         break;
 552       case DYNCAP:
 553         ret = bgp_capability_receive (peer, t->len);
 554         break;
 555       default:
 556         printf ("unknown type %u\n", type);
 557         exit(1);
 558     }
 559
 560   if (!ret && t->validate_afi)
 561     {
 562       safi_t safi = t->safi;
 563
 564       if (bgp_afi_safi_valid_indices (t->afi, &safi) != t->afi_valid)
 565         failed++;
 566
 567       printf ("MP: %u/%u (%u): recv %u, nego %u\n",
 568               t->afi, t->safi, safi,
 569               peer->afc_recv[t->afi][safi],
 570               peer->afc_nego[t->afi][safi]);
 571
 572       if (t->afi_valid == VALID_AFI)
 573         {
 574
 575           if (!peer->afc_recv[t->afi][safi])
 576             failed++;
 577           if (!peer->afc_nego[t->afi][safi])
 578             failed++;
 579         }
 580     }
 581
 582   if (as4 != t->peek_for)
 583     {
 584       printf ("as4 %u != %u\n", as4, t->peek_for);
 585       failed++;
 586     }
 587
 588   printf ("parsed?: %s\n", ret ? "no" : "yes");
 589
 590   if (ret != t->parses)
 591     failed++;
 592
 593   if (tty)
 594     printf ("%s", (failed > oldfailed) ? VT100_RED "failed!" VT100_RESET
 595                                          : VT100_GREEN "OK" VT100_RESET);
 596   else
 597     printf ("%s", (failed > oldfailed) ? "failed!" : "OK" );
 598
 599   if (failed)
 600     printf (" (%u)", failed);
 601
 602   printf ("\n\n");
 603 }
 604
 605 static struct bgp *bgp;
 606 static as_t asn = 100;
 607
 608 int
 609 main (void)
 610 {
 611   struct peer *peer;
 612   int i, j;
 613
 614   conf_bgp_debug_fsm = -1UL;
 615   conf_bgp_debug_events = -1UL;
 616   conf_bgp_debug_packet = -1UL;
 617   conf_bgp_debug_normal = -1UL;
 618   conf_bgp_debug_as4 = -1UL;
 619   term_bgp_debug_fsm = -1UL;
 620   term_bgp_debug_events = -1UL;
 621   term_bgp_debug_packet = -1UL;
 622   term_bgp_debug_normal = -1UL;
 623   term_bgp_debug_as4 = -1UL;
 624
 625   master = thread_master_create ();
 626   bgp_master_init ();
 627
 628   if (fileno (stdout) >= 0)
 629     tty = isatty (fileno (stdout));
 630
 631   if (bgp_get (&bgp, &asn, NULL))
 632     return -1;
 633
 634   peer = peer_create_accept (bgp);
 635   peer->host = "foo";
 636
 637   for (i = AFI_IP; i < AFI_MAX; i++)
 638     for (j = SAFI_UNICAST; j < SAFI_MAX; j++)
 639       {
 640         peer->afc[i][j] = 1;
 641         peer->afc_adv[i][j] = 1;
 642       }
 643
 644   i = 0;
 645   while (mp_segments[i].name)
 646     parse_test (peer, &mp_segments[i++], CAPABILITY);
 647
 648   /* These tests assume mp_segments tests set at least
 649    * one of the afc_nego's
 650    */
 651   i = 0;
 652   while (test_segments[i].name)
 653     parse_test (peer, &test_segments[i++], CAPABILITY);
 654
 655   i = 0;
 656   while (misc_segments[i].name)
 657     parse_test (peer, &misc_segments[i++], CAPABILITY);
 658
 659   i = 0;
 660   while (opt_params[i].name)
 661     parse_test (peer, &opt_params[i++], OPT_PARAM);
 662
 663   SET_FLAG (peer->cap, PEER_CAP_DYNAMIC_ADV);
 664   peer->status = Established;
 665
 666   i = 0;
 667   while (dynamic_cap_msgs[i].name)
 668     parse_test (peer, &dynamic_cap_msgs[i++], DYNCAP);
 669
 670   printf ("failures: %d\n", failed);
 671   return failed;
 672 }