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   { "dyn-old",
 366     "Dynamic capability (deprecated version)",
 367     { CAPABILITY_CODE_DYNAMIC, 0x0 },
 368     2, SHOULD_PARSE,
 369   },
 370   { NULL, NULL, {0}, 0, 0}
 371 };
 372
 373 /* DYNAMIC message */
 374 struct test_segment dynamic_cap_msgs[] =
 375 {
 376   { "DynCap",
 377     "Dynamic Capability Message, IP/Multicast",
 378     { 0x0, 0x1, 0x4, 0x0, 0x1, 0x0, 0x2 },
 379       7, SHOULD_PARSE, /* horrible alignment, just as with ORF */
 380   },
 381   { "DynCapLong",
 382     "Dynamic Capability Message, IP/Multicast, truncated",
 383     { 0x0, 0x1, 0x4, 0x0, 0x1, 0x0, 0x2 },
 384       5, SHOULD_ERR,
 385   },
 386   { "DynCapPadded",
 387     "Dynamic Capability Message, IP/Multicast, padded",
 388     { 0x0, 0x1, 0x4, 0x0, 0x1, 0x0, 0x2, 0x0 },
 389       8, SHOULD_ERR, /* No way to tell padding from data.. */
 390   },
 391   { "DynCapMPCpadded",
 392     "Dynamic Capability Message, IP/Multicast, cap data padded",
 393     { 0x0, 0x1, 0x5, 0x0, 0x1, 0x0, 0x2, 0x0 },
 394       8, SHOULD_PARSE, /* You can though add padding to the capability data */
 395   },
 396   { "DynCapMPCoverflow",
 397     "Dynamic Capability Message, IP/Multicast, cap data != length",
 398     { 0x0, 0x1, 0x3, 0x0, 0x1, 0x0, 0x2, 0x0 },
 399       8, SHOULD_ERR,
 400   },
 401   { NULL, NULL, {0}, 0, 0}
 402 };
 403
 404 /* Entire Optional-Parameters block */
 405 struct test_segment opt_params[] =
 406 {
 407   { "Cap-singlets",
 408     "One capability per Optional-Param",
 409     { 0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
 410       0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
 411       0x02, 0x02, 0x80, 0x00, /* RR (old) */
 412       0x02, 0x02, 0x02, 0x00, /* RR */
 413     },
 414     24, SHOULD_PARSE,
 415   },
 416   { "Cap-series",
 417     "Series of capability, one Optional-Param",
 418     { 0x02, 0x10,
 419       0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
 420       0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
 421       0x80, 0x00, /* RR (old) */
 422       0x02, 0x00, /* RR */
 423     },
 424     18, SHOULD_PARSE,
 425   },
 426   { "AS4more",
 427     "AS4 capability after other caps (singlets)",
 428     { 0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
 429       0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
 430       0x02, 0x02, 0x80, 0x00, /* RR (old) */
 431       0x02, 0x02, 0x02, 0x00, /* RR */
 432       0x02, 0x06, 0x41, 0x04, 0x00, 0x03, 0x00, 0x06  /* AS4: 1996614 */
 433     },
 434     32, SHOULD_PARSE, 196614,
 435   },
 436   { "AS4series",
 437     "AS4 capability, in series of capabilities",
 438     { 0x02, 0x16,
 439       0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/Uni */
 440       0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/Uni */
 441       0x80, 0x00, /* RR (old) */
 442       0x02, 0x00, /* RR */
 443       0x41, 0x04, 0x00, 0x03, 0x00, 0x06  /* AS4: 1996614 */
 444     },
 445     24, SHOULD_PARSE, 196614,
 446   },
 447   { "AS4real",
 448     "AS4 capability, in series of capabilities",
 449     {
 450       0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01, /* MP IPv4/uni */
 451       0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01, /* MP IPv6/uni */
 452       0x02, 0x02, 0x80, 0x00, /* RR old */
 453       0x02, 0x02, 0x02, 0x00, /* RR */
 454       0x02, 0x06, 0x41, 0x04, 0x00, 0x03, 0x00, 0x06, /* AS4 */
 455     },
 456     32, SHOULD_PARSE, 196614,
 457   },
 458   { "AS4real2",
 459     "AS4 capability, in series of capabilities",
 460     {
 461       0x02, 0x06, 0x01, 0x04, 0x00, 0x01, 0x00, 0x01,
 462       0x02, 0x06, 0x01, 0x04, 0x00, 0x02, 0x00, 0x01,
 463       0x02, 0x02, 0x80, 0x00,
 464       0x02, 0x02, 0x02, 0x00,
 465       0x02, 0x06, 0x41, 0x04, 0x00, 0x00, 0xfc, 0x03,
 466       0x02, 0x09, 0x82, 0x07, 0x00, 0x01, 0x00, 0x01, 0x01, 0x80, 0x03,
 467       0x02, 0x09, 0x03, 0x07, 0x00, 0x01, 0x00, 0x01, 0x01, 0x40, 0x03,
 468       0x02, 0x02, 0x42, 0x00,
 469     },
 470     58, SHOULD_PARSE, 64515,
 471   },
 472
 473   { NULL, NULL, {0}, 0, 0}
 474 };
 475
 476 /* basic parsing test */
 477 static void
 478 parse_test (struct peer *peer, struct test_segment *t, int type)
 479 {
 480   int ret;
 481   int capability = 0;
 482   as_t as4 = 0;
 483   int oldfailed = failed;
 484   int len = t->len;
 485 #define RANDOM_FUZZ 35
 486
 487   stream_reset (peer->ibuf);
 488   stream_put (peer->ibuf, NULL, RANDOM_FUZZ);
 489   stream_set_getp (peer->ibuf, RANDOM_FUZZ);
 490
 491   switch (type)
 492     {
 493       case CAPABILITY:
 494         stream_putc (peer->ibuf, BGP_OPEN_OPT_CAP);
 495         stream_putc (peer->ibuf, t->len);
 496         break;
 497       case DYNCAP:
 498 /*        for (i = 0; i < BGP_MARKER_SIZE; i++)
 499           stream_putc (peer->, 0xff);
 500         stream_putw (s, 0);
 501         stream_putc (s, BGP_MSG_CAPABILITY);*/
 502         break;
 503     }
 504   stream_write (peer->ibuf, t->data, t->len);
 505
 506   printf ("%s: %s\n", t->name, t->desc);
 507
 508   switch (type)
 509     {
 510       case CAPABILITY:
 511         len += 2; /* to cover the OPT-Param header */
 512       case OPT_PARAM:
 513         printf ("len: %u\n", len);
 514         /* peek_for_as4 wants getp at capibility*/
 515         as4 = peek_for_as4_capability (peer, len);
 516         printf ("peek_for_as4: as4 is %u\n", as4);
 517         /* and it should leave getp as it found it */
 518         assert (stream_get_getp (peer->ibuf) == RANDOM_FUZZ);
 519
 520         ret = bgp_open_option_parse (peer, len, &capability);
 521         break;
 522       case DYNCAP:
 523         ret = bgp_capability_receive (peer, t->len);
 524         break;
 525       default:
 526         printf ("unknown type %u\n", type);
 527         exit(1);
 528     }
 529
 530   if (!ret && t->validate_afi)
 531     {
 532       safi_t safi = t->safi;
 533
 534       if (bgp_afi_safi_valid_indices (t->afi, &safi) != t->afi_valid)
 535         failed++;
 536
 537       printf ("MP: %u/%u (%u): recv %u, nego %u\n",
 538               t->afi, t->safi, safi,
 539               peer->afc_recv[t->afi][safi],
 540               peer->afc_nego[t->afi][safi]);
 541
 542       if (t->afi_valid == VALID_AFI)
 543         {
 544
 545           if (!peer->afc_recv[t->afi][safi])
 546             failed++;
 547           if (!peer->afc_nego[t->afi][safi])
 548             failed++;
 549         }
 550     }
 551
 552   if (as4 != t->peek_for)
 553     {
 554       printf ("as4 %u != %u\n", as4, t->peek_for);
 555       failed++;
 556     }
 557
 558   printf ("parsed?: %s\n", ret ? "no" : "yes");
 559
 560   if (ret != t->parses)
 561     failed++;
 562
 563   if (tty)
 564     printf ("%s", (failed > oldfailed) ? VT100_RED "failed!" VT100_RESET
 565                                          : VT100_GREEN "OK" VT100_RESET);
 566   else
 567     printf ("%s", (failed > oldfailed) ? "failed!" : "OK" );
 568
 569   if (failed)
 570     printf (" (%u)", failed);
 571
 572   printf ("\n\n");
 573 }
 574
 575 static struct bgp *bgp;
 576 static as_t asn = 100;
 577
 578 int
 579 main (void)
 580 {
 581   struct peer *peer;
 582   int i, j;
 583
 584   conf_bgp_debug_fsm = -1UL;
 585   conf_bgp_debug_events = -1UL;
 586   conf_bgp_debug_packet = -1UL;
 587   conf_bgp_debug_normal = -1UL;
 588   conf_bgp_debug_as4 = -1UL;
 589   term_bgp_debug_fsm = -1UL;
 590   term_bgp_debug_events = -1UL;
 591   term_bgp_debug_packet = -1UL;
 592   term_bgp_debug_normal = -1UL;
 593   term_bgp_debug_as4 = -1UL;
 594
 595   master = thread_master_create ();
 596   bgp_master_init ();
 597
 598   if (fileno (stdout) >= 0)
 599     tty = isatty (fileno (stdout));
 600
 601   if (bgp_get (&bgp, &asn, NULL))
 602     return -1;
 603
 604   peer = peer_create_accept (bgp);
 605   peer->host = "foo";
 606
 607   for (i = AFI_IP; i < AFI_MAX; i++)
 608     for (j = SAFI_UNICAST; j < SAFI_MAX; j++)
 609       {
 610         peer->afc[i][j] = 1;
 611         peer->afc_adv[i][j] = 1;
 612       }
 613
 614   i = 0;
 615   while (mp_segments[i].name)
 616     parse_test (peer, &mp_segments[i++], CAPABILITY);
 617
 618   /* These tests assume mp_segments tests set at least
 619    * one of the afc_nego's
 620    */
 621   i = 0;
 622   while (test_segments[i].name)
 623     parse_test (peer, &test_segments[i++], CAPABILITY);
 624
 625   i = 0;
 626   while (misc_segments[i].name)
 627     parse_test (peer, &misc_segments[i++], CAPABILITY);
 628
 629   i = 0;
 630   while (opt_params[i].name)
 631     parse_test (peer, &opt_params[i++], OPT_PARAM);
 632
 633   SET_FLAG (peer->cap, PEER_CAP_DYNAMIC_ADV);
 634   peer->status = Established;
 635
 636   i = 0;
 637   while (dynamic_cap_msgs[i].name)
 638     parse_test (peer, &dynamic_cap_msgs[i++], DYNCAP);
 639
 640   printf ("failures: %d\n", failed);
 641   return failed;
 642 }