bgpd/bgp_open.c

   1 /* BGP open message handling
   2    Copyright (C) 1998, 1999 Kunihiro Ishiguro
   3
   4 This file is part of GNU Zebra.
   5
   6 GNU Zebra is free software; you can redistribute it and/or modify it
   7 under the terms of the GNU General Public License as published by the
   8 Free Software Foundation; either version 2, or (at your option) any
   9 later version.
  10
  11 GNU Zebra is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18 Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19 02111-1307, USA.  */
  20
  21 #include <zebra.h>
  22
  23 #include "linklist.h"
  24 #include "prefix.h"
  25 #include "stream.h"
  26 #include "thread.h"
  27 #include "log.h"
  28 #include "command.h"
  29 #include "memory.h"
  30 #include "filter.h"
  31
  32 #include "bgpd/bgpd.h"
  33 #include "bgpd/bgp_attr.h"
  34 #include "bgpd/bgp_debug.h"
  35 #include "bgpd/bgp_fsm.h"
  36 #include "bgpd/bgp_packet.h"
  37 #include "bgpd/bgp_open.h"
  38 #include "bgpd/bgp_aspath.h"
  39 #include "bgpd/bgp_vty.h"
  40
  41 /* BGP-4 Multiprotocol Extentions lead us to the complex world. We can
  42    negotiate remote peer supports extentions or not. But if
  43    remote-peer doesn't supports negotiation process itself.  We would
  44    like to do manual configuration.
  45
  46    So there is many configurable point.  First of all we want set each
  47    peer whether we send capability negotiation to the peer or not.
  48    Next, if we send capability to the peer we want to set my capabilty
  49    inforation at each peer. */
  50
  51 void
  52 bgp_capability_vty_out (struct vty *vty, struct peer *peer)
  53 {
  54   char *pnt;
  55   char *end;
  56   struct capability_mp_data mpc;
  57   struct capability_header *hdr;
  58
  59   pnt = peer->notify.data;
  60   end = pnt + peer->notify.length;
  61
  62   while (pnt < end)
  63     {
  64       if (pnt + sizeof (struct capability_mp_data) + 2 > end)
  65         return;
  66
  67       hdr = (struct capability_header *)pnt;
  68       if (pnt + hdr->length + 2 > end)
  69         return;
  70
  71       memcpy (&mpc, pnt + 2, sizeof(struct capability_mp_data));
  72
  73       if (hdr->code == CAPABILITY_CODE_MP)
  74         {
  75           vty_out (vty, "  Capability error for: Multi protocol ");
  76
  77           switch (ntohs (mpc.afi))
  78             {
  79             case AFI_IP:
  80               vty_out (vty, "AFI IPv4, ");
  81               break;
  82             case AFI_IP6:
  83               vty_out (vty, "AFI IPv6, ");
  84               break;
  85             default:
  86               vty_out (vty, "AFI Unknown %d, ", ntohs (mpc.afi));
  87               break;
  88             }
  89           switch (mpc.safi)
  90             {
  91             case SAFI_UNICAST:
  92               vty_out (vty, "SAFI Unicast");
  93               break;
  94             case SAFI_MULTICAST:
  95               vty_out (vty, "SAFI Multicast");
  96               break;
  97             case SAFI_MPLS_LABELED_VPN:
  98               vty_out (vty, "SAFI MPLS-labeled VPN");
  99               break;
 100             case SAFI_ENCAP:
 101               vty_out (vty, "SAFI ENCAP");
 102               break;
 103             default:
 104               vty_out (vty, "SAFI Unknown %d ", mpc.safi);
 105               break;
 106             }
 107           vty_out (vty, "%s", VTY_NEWLINE);
 108         }
 109       else if (hdr->code >= 128)
 110         vty_out (vty, "  Capability error: vendor specific capability code %d",
 111                  hdr->code);
 112       else
 113         vty_out (vty, "  Capability error: unknown capability code %d",
 114                  hdr->code);
 115
 116       pnt += hdr->length + 2;
 117     }
 118 }
 119
 120 static void
 121 bgp_capability_mp_data (struct stream *s, struct capability_mp_data *mpc)
 122 {
 123   afi_t afi = stream_getw (s);
 124   memcpy(&mpc->afi, &afi, sizeof(mpc->afi));
 125   mpc->reserved = stream_getc (s);
 126   mpc->safi = stream_getc (s);
 127 }
 128
 129 int
 130 bgp_afi_safi_valid_indices (afi_t afi, safi_t *safi)
 131 {
 132   switch (afi)
 133     {
 134     case AFI_IP:
 135     case AFI_IP6:
 136       switch (*safi)
 137         {
 138           /* BGP MPLS-labeled VPN SAFI isn't contigious with others, remap */
 139         case SAFI_MPLS_LABELED_VPN:
 140           *safi = SAFI_MPLS_VPN;
 141         case SAFI_UNICAST:
 142         case SAFI_MULTICAST:
 143         case SAFI_MPLS_VPN:
 144         case SAFI_ENCAP:
 145           return 1;
 146         }
 147     case AFI_ETHER:
 148     default:
 149       break;
 150     }
 151
 152   zlog_debug ("unknown afi/safi (%u/%u)", afi, *safi);
 153
 154   return 0;
 155 }
 156
 157 /* Set negotiated capability value. */
 158 static int
 159 bgp_capability_mp (struct peer *peer, struct capability_header *hdr)
 160 {
 161   struct capability_mp_data mpc;
 162   struct stream *s = BGP_INPUT (peer);
 163
 164   bgp_capability_mp_data (s, &mpc);
 165
 166   if (BGP_DEBUG (normal, NORMAL))
 167     zlog_debug ("%s OPEN has MP_EXT CAP for afi/safi: %u/%u",
 168                peer->host, mpc.afi, mpc.safi);
 169
 170   if (!bgp_afi_safi_valid_indices (mpc.afi, &mpc.safi))
 171     return -1;
 172
 173   /* Now safi remapped, and afi/safi are valid array indices */
 174   peer->afc_recv[mpc.afi][mpc.safi] = 1;
 175
 176   if (peer->afc[mpc.afi][mpc.safi])
 177     peer->afc_nego[mpc.afi][mpc.safi] = 1;
 178   else
 179     return -1;
 180
 181   return 0;
 182 }
 183
 184 static void
 185 bgp_capability_orf_not_support (struct peer *peer, afi_t afi, safi_t safi,
 186                                 u_char type, u_char mode)
 187 {
 188   if (BGP_DEBUG (normal, NORMAL))
 189     zlog_debug ("%s Addr-family %d/%d has ORF type/mode %d/%d not supported",
 190                peer->host, afi, safi, type, mode);
 191 }
 192
 193 static const struct message orf_type_str[] =
 194 {
 195   { ORF_TYPE_PREFIX,            "Prefixlist"            },
 196   { ORF_TYPE_PREFIX_OLD,        "Prefixlist (old)"      },
 197 };
 198 static const int orf_type_str_max = array_size(orf_type_str);
 199
 200 static const struct message orf_mode_str[] =
 201 {
 202   { ORF_MODE_RECEIVE,   "Receive"       },
 203   { ORF_MODE_SEND,      "Send"          },
 204   { ORF_MODE_BOTH,      "Both"          },
 205 };
 206 static const int orf_mode_str_max = array_size(orf_mode_str);
 207
 208 static int
 209 bgp_capability_orf_entry (struct peer *peer, struct capability_header *hdr)
 210 {
 211   struct stream *s = BGP_INPUT (peer);
 212   struct capability_orf_entry entry;
 213   afi_t afi;
 214   safi_t safi;
 215   u_char type;
 216   u_char mode;
 217   u_int16_t sm_cap = 0; /* capability send-mode receive */
 218   u_int16_t rm_cap = 0; /* capability receive-mode receive */
 219   int i;
 220
 221   /* ORF Entry header */
 222   bgp_capability_mp_data (s, &entry.mpc);
 223   entry.num = stream_getc (s);
 224   afi = entry.mpc.afi;
 225   safi = entry.mpc.safi;
 226
 227   if (BGP_DEBUG (normal, NORMAL))
 228     zlog_debug ("%s ORF Cap entry for afi/safi: %u/%u",
 229                 peer->host, entry.mpc.afi, entry.mpc.safi);
 230
 231   /* Check AFI and SAFI. */
 232   if (!bgp_afi_safi_valid_indices (entry.mpc.afi, &safi))
 233     {
 234       zlog_info ("%s Addr-family %d/%d not supported."
 235                  " Ignoring the ORF capability",
 236                  peer->host, entry.mpc.afi, entry.mpc.safi);
 237       return 0;
 238     }
 239
 240   /* validate number field */
 241   if (CAPABILITY_CODE_ORF_LEN + (entry.num * 2) > hdr->length)
 242     {
 243       zlog_info ("%s ORF Capability entry length error,"
 244                  " Cap length %u, num %u",
 245                  peer->host, hdr->length, entry.num);
 246       bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR, BGP_NOTIFY_OPEN_UNSPECIFIC);
 247       return -1;
 248     }
 249
 250   for (i = 0 ; i < entry.num ; i++)
 251     {
 252       type = stream_getc(s);
 253       mode = stream_getc(s);
 254
 255       /* ORF Mode error check */
 256       switch (mode)
 257         {
 258           case ORF_MODE_BOTH:
 259           case ORF_MODE_SEND:
 260           case ORF_MODE_RECEIVE:
 261             break;
 262           default:
 263             bgp_capability_orf_not_support (peer, afi, safi, type, mode);
 264             continue;
 265         }
 266       /* ORF Type and afi/safi error checks */
 267       /* capcode versus type */
 268       switch (hdr->code)
 269         {
 270           case CAPABILITY_CODE_ORF:
 271             switch (type)
 272               {
 273                 case ORF_TYPE_PREFIX:
 274                   break;
 275                 default:
 276                   bgp_capability_orf_not_support (peer, afi, safi, type, mode);
 277                   continue;
 278               }
 279             break;
 280           case CAPABILITY_CODE_ORF_OLD:
 281             switch (type)
 282               {
 283                 case ORF_TYPE_PREFIX_OLD:
 284                   break;
 285                 default:
 286                   bgp_capability_orf_not_support (peer, afi, safi, type, mode);
 287                   continue;
 288               }
 289             break;
 290           default:
 291             bgp_capability_orf_not_support (peer, afi, safi, type, mode);
 292             continue;
 293         }
 294
 295       /* AFI vs SAFI */
 296       if (!((afi == AFI_IP && safi == SAFI_UNICAST)
 297             || (afi == AFI_IP && safi == SAFI_MULTICAST)
 298             || (afi == AFI_IP6 && safi == SAFI_UNICAST)))
 299         {
 300           bgp_capability_orf_not_support (peer, afi, safi, type, mode);
 301           continue;
 302         }
 303
 304       if (BGP_DEBUG (normal, NORMAL))
 305         zlog_debug ("%s OPEN has %s ORF capability"
 306                     " as %s for afi/safi: %d/%d",
 307                     peer->host, LOOKUP (orf_type_str, type),
 308                     LOOKUP (orf_mode_str, mode),
 309                     entry.mpc.afi, safi);
 310
 311       if (hdr->code == CAPABILITY_CODE_ORF)
 312         {
 313           sm_cap = PEER_CAP_ORF_PREFIX_SM_RCV;
 314           rm_cap = PEER_CAP_ORF_PREFIX_RM_RCV;
 315         }
 316       else if (hdr->code == CAPABILITY_CODE_ORF_OLD)
 317         {
 318           sm_cap = PEER_CAP_ORF_PREFIX_SM_OLD_RCV;
 319           rm_cap = PEER_CAP_ORF_PREFIX_RM_OLD_RCV;
 320         }
 321       else
 322         {
 323           bgp_capability_orf_not_support (peer, afi, safi, type, mode);
 324           continue;
 325         }
 326
 327       switch (mode)
 328         {
 329           case ORF_MODE_BOTH:
 330             SET_FLAG (peer->af_cap[afi][safi], sm_cap);
 331             SET_FLAG (peer->af_cap[afi][safi], rm_cap);
 332             break;
 333           case ORF_MODE_SEND:
 334             SET_FLAG (peer->af_cap[afi][safi], sm_cap);
 335             break;
 336           case ORF_MODE_RECEIVE:
 337             SET_FLAG (peer->af_cap[afi][safi], rm_cap);
 338             break;
 339         }
 340     }
 341   return 0;
 342 }
 343
 344 static int
 345 bgp_capability_restart (struct peer *peer, struct capability_header *caphdr)
 346 {
 347   struct stream *s = BGP_INPUT (peer);
 348   u_int16_t restart_flag_time;
 349   size_t end = stream_get_getp (s) + caphdr->length;
 350
 351   SET_FLAG (peer->cap, PEER_CAP_RESTART_RCV);
 352   restart_flag_time = stream_getw(s);
 353   if (CHECK_FLAG (restart_flag_time, RESTART_R_BIT))
 354     SET_FLAG (peer->cap, PEER_CAP_RESTART_BIT_RCV);
 355
 356   UNSET_FLAG (restart_flag_time, 0xF000);
 357   peer->v_gr_restart = restart_flag_time;
 358
 359   if (BGP_DEBUG (normal, NORMAL))
 360     {
 361       zlog_debug ("%s OPEN has Graceful Restart capability", peer->host);
 362       zlog_debug ("%s Peer has%srestarted. Restart Time : %d",
 363                   peer->host,
 364                   CHECK_FLAG (peer->cap, PEER_CAP_RESTART_BIT_RCV) ? " "
 365                                                                    : " not ",
 366                   peer->v_gr_restart);
 367     }
 368
 369   while (stream_get_getp (s) + 4 <= end)
 370     {
 371       afi_t afi = stream_getw (s);
 372       safi_t safi = stream_getc (s);
 373       u_char flag = stream_getc (s);
 374
 375       if (!bgp_afi_safi_valid_indices (afi, &safi))
 376         {
 377           if (BGP_DEBUG (normal, NORMAL))
 378             zlog_debug ("%s Addr-family %d/%d(afi/safi) not supported."
 379                         " Ignore the Graceful Restart capability",
 380                         peer->host, afi, safi);
 381         }
 382       else if (!peer->afc[afi][safi])
 383         {
 384           if (BGP_DEBUG (normal, NORMAL))
 385             zlog_debug ("%s Addr-family %d/%d(afi/safi) not enabled."
 386                         " Ignore the Graceful Restart capability",
 387                         peer->host, afi, safi);
 388         }
 389       else
 390         {
 391           if (BGP_DEBUG (normal, NORMAL))
 392             zlog_debug ("%s Address family %s is%spreserved", peer->host,
 393                         afi_safi_print (afi, safi),
 394                         CHECK_FLAG (peer->af_cap[afi][safi],
 395                                     PEER_CAP_RESTART_AF_PRESERVE_RCV)
 396                         ? " " : " not ");
 397
 398           SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_RESTART_AF_RCV);
 399           if (CHECK_FLAG (flag, RESTART_F_BIT))
 400             SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_RESTART_AF_PRESERVE_RCV);
 401
 402         }
 403     }
 404   return 0;
 405 }
 406
 407 static as_t
 408 bgp_capability_as4 (struct peer *peer, struct capability_header *hdr)
 409 {
 410   SET_FLAG (peer->cap, PEER_CAP_AS4_RCV);
 411
 412   if (hdr->length != CAPABILITY_CODE_AS4_LEN)
 413     {
 414       zlog_err ("%s AS4 capability has incorrect data length %d",
 415                 peer->host, hdr->length);
 416       return 0;
 417     }
 418
 419   as_t as4 = stream_getl (BGP_INPUT(peer));
 420
 421   if (BGP_DEBUG (as4, AS4))
 422     zlog_debug ("%s [AS4] about to set cap PEER_CAP_AS4_RCV, got as4 %u",
 423                 peer->host, as4);
 424   return as4;
 425 }
 426
 427 static const struct message capcode_str[] =
 428 {
 429   { CAPABILITY_CODE_MP,                 "MultiProtocol Extensions"      },
 430   { CAPABILITY_CODE_REFRESH,            "Route Refresh"                 },
 431   { CAPABILITY_CODE_ORF,                "Cooperative Route Filtering"   },
 432   { CAPABILITY_CODE_RESTART,            "Graceful Restart"              },
 433   { CAPABILITY_CODE_AS4,                "4-octet AS number"             },
 434   { CAPABILITY_CODE_DYNAMIC,            "Dynamic"                       },
 435   { CAPABILITY_CODE_REFRESH_OLD,        "Route Refresh (Old)"           },
 436   { CAPABILITY_CODE_ORF_OLD,            "ORF (Old)"                     },
 437 };
 438 static const int capcode_str_max = array_size(capcode_str);
 439
 440 /* Minimum sizes for length field of each cap (so not inc. the header) */
 441 static const size_t cap_minsizes[] =
 442 {
 443   [CAPABILITY_CODE_MP]          = CAPABILITY_CODE_MP_LEN,
 444   [CAPABILITY_CODE_REFRESH]     = CAPABILITY_CODE_REFRESH_LEN,
 445   [CAPABILITY_CODE_ORF]         = CAPABILITY_CODE_ORF_LEN,
 446   [CAPABILITY_CODE_RESTART]     = CAPABILITY_CODE_RESTART_LEN,
 447   [CAPABILITY_CODE_AS4]         = CAPABILITY_CODE_AS4_LEN,
 448   [CAPABILITY_CODE_DYNAMIC]     = CAPABILITY_CODE_DYNAMIC_LEN,
 449   [CAPABILITY_CODE_REFRESH_OLD] = CAPABILITY_CODE_REFRESH_LEN,
 450   [CAPABILITY_CODE_ORF_OLD]     = CAPABILITY_CODE_ORF_LEN,
 451 };
 452
 453 /* value the capability must be a multiple of.
 454  * 0-data capabilities won't be checked against this.
 455  * Other capabilities whose data doesn't fall on convenient boundaries for this
 456  * table should be set to 1.
 457  */
 458 static const size_t cap_modsizes[] =
 459 {
 460   [CAPABILITY_CODE_MP]          = 4,
 461   [CAPABILITY_CODE_REFRESH]     = 1,
 462   [CAPABILITY_CODE_ORF]         = 1,
 463   [CAPABILITY_CODE_RESTART]     = 1,
 464   [CAPABILITY_CODE_AS4]         = 4,
 465   [CAPABILITY_CODE_DYNAMIC]     = 1,
 466   [CAPABILITY_CODE_REFRESH_OLD] = 1,
 467   [CAPABILITY_CODE_ORF_OLD]     = 1,
 468 };
 469
 470 /**
 471  * Parse given capability.
 472  * XXX: This is reading into a stream, but not using stream API
 473  *
 474  * @param[out] mp_capability Set to 1 on return iff one or more Multiprotocol
 475  *                           capabilities were encountered.
 476  */
 477 static int
 478 bgp_capability_parse (struct peer *peer, size_t length, int *mp_capability,
 479                       u_char **error)
 480 {
 481   int ret;
 482   struct stream *s = BGP_INPUT (peer);
 483   size_t end = stream_get_getp (s) + length;
 484
 485   assert (STREAM_READABLE (s) >= length);
 486
 487   while (stream_get_getp (s) < end)
 488     {
 489       size_t start;
 490       u_char *sp = stream_pnt (s);
 491       struct capability_header caphdr;
 492
 493       /* We need at least capability code and capability length. */
 494       if (stream_get_getp(s) + 2 > end)
 495         {
 496           zlog_info ("%s Capability length error (< header)", peer->host);
 497           bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR, BGP_NOTIFY_OPEN_UNSPECIFIC);
 498           return -1;
 499         }
 500
 501       caphdr.code = stream_getc (s);
 502       caphdr.length = stream_getc (s);
 503       start = stream_get_getp (s);
 504
 505       /* Capability length check sanity check. */
 506       if (start + caphdr.length > end)
 507         {
 508           zlog_info ("%s Capability length error (< length)", peer->host);
 509           bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR, BGP_NOTIFY_OPEN_UNSPECIFIC);
 510           return -1;
 511         }
 512
 513       if (BGP_DEBUG (normal, NORMAL))
 514         zlog_debug ("%s OPEN has %s capability (%u), length %u",
 515                    peer->host,
 516                    LOOKUP (capcode_str, caphdr.code),
 517                    caphdr.code, caphdr.length);
 518
 519       /* Length sanity check, type-specific, for known capabilities */
 520       switch (caphdr.code)
 521         {
 522           case CAPABILITY_CODE_MP:
 523           case CAPABILITY_CODE_REFRESH:
 524           case CAPABILITY_CODE_REFRESH_OLD:
 525           case CAPABILITY_CODE_ORF:
 526           case CAPABILITY_CODE_ORF_OLD:
 527           case CAPABILITY_CODE_RESTART:
 528           case CAPABILITY_CODE_AS4:
 529           case CAPABILITY_CODE_DYNAMIC:
 530               /* Check length. */
 531               if (caphdr.length < cap_minsizes[caphdr.code])
 532                 {
 533                   zlog_info ("%s %s Capability length error: got %u,"
 534                              " expected at least %u",
 535                              peer->host,
 536                              LOOKUP (capcode_str, caphdr.code),
 537                              caphdr.length,
 538                              (unsigned) cap_minsizes[caphdr.code]);
 539                   bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
 540                                   BGP_NOTIFY_OPEN_UNSPECIFIC);
 541                   return -1;
 542                 }
 543               if (caphdr.length
 544                   && caphdr.length % cap_modsizes[caphdr.code] != 0)
 545                 {
 546                   zlog_info ("%s %s Capability length error: got %u,"
 547                              " expected a multiple of %u",
 548                              peer->host,
 549                              LOOKUP (capcode_str, caphdr.code),
 550                              caphdr.length,
 551                              (unsigned) cap_modsizes[caphdr.code]);
 552                   bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
 553                                          BGP_NOTIFY_OPEN_UNSPECIFIC);
 554                   return -1;
 555                 }
 556           /* we deliberately ignore unknown codes, see below */
 557           default:
 558             break;
 559         }
 560
 561       switch (caphdr.code)
 562         {
 563           case CAPABILITY_CODE_MP:
 564             {
 565               *mp_capability = 1;
 566
 567               /* Ignore capability when override-capability is set. */
 568               if (! CHECK_FLAG (peer->flags, PEER_FLAG_OVERRIDE_CAPABILITY))
 569                 {
 570                   /* Set negotiated value. */
 571                   ret = bgp_capability_mp (peer, &caphdr);
 572
 573                   /* Unsupported Capability. */
 574                   if (ret < 0)
 575                     {
 576                       /* Store return data. */
 577                       memcpy (*error, sp, caphdr.length + 2);
 578                       *error += caphdr.length + 2;
 579                     }
 580                 }
 581             }
 582             break;
 583           case CAPABILITY_CODE_REFRESH:
 584           case CAPABILITY_CODE_REFRESH_OLD:
 585             {
 586               /* BGP refresh capability */
 587               if (caphdr.code == CAPABILITY_CODE_REFRESH_OLD)
 588                 SET_FLAG (peer->cap, PEER_CAP_REFRESH_OLD_RCV);
 589               else
 590                 SET_FLAG (peer->cap, PEER_CAP_REFRESH_NEW_RCV);
 591             }
 592             break;
 593           case CAPABILITY_CODE_ORF:
 594           case CAPABILITY_CODE_ORF_OLD:
 595             if (bgp_capability_orf_entry (peer, &caphdr))
 596               return -1;
 597             break;
 598           case CAPABILITY_CODE_RESTART:
 599             if (bgp_capability_restart (peer, &caphdr))
 600               return -1;
 601             break;
 602           case CAPABILITY_CODE_DYNAMIC:
 603             SET_FLAG (peer->cap, PEER_CAP_DYNAMIC_RCV);
 604             break;
 605           case CAPABILITY_CODE_AS4:
 606               /* Already handled as a special-case parsing of the capabilities
 607                * at the beginning of OPEN processing. So we care not a jot
 608                * for the value really, only error case.
 609                */
 610               if (!bgp_capability_as4 (peer, &caphdr))
 611                 return -1;
 612               break;
 613           default:
 614             if (caphdr.code > 128)
 615               {
 616                 /* We don't send Notification for unknown vendor specific
 617                    capabilities.  It seems reasonable for now...  */
 618                 zlog_warn ("%s Vendor specific capability %d",
 619                            peer->host, caphdr.code);
 620               }
 621             else
 622               {
 623                 zlog_warn ("%s unrecognized capability code: %d - ignored",
 624                            peer->host, caphdr.code);
 625                 memcpy (*error, sp, caphdr.length + 2);
 626                 *error += caphdr.length + 2;
 627               }
 628           }
 629       if (stream_get_getp(s) != (start + caphdr.length))
 630         {
 631           if (stream_get_getp(s) > (start + caphdr.length))
 632             zlog_warn ("%s Cap-parser for %s read past cap-length, %u!",
 633                        peer->host, LOOKUP (capcode_str, caphdr.code),
 634                        caphdr.length);
 635           stream_set_getp (s, start + caphdr.length);
 636         }
 637     }
 638   return 0;
 639 }
 640
 641 static int
 642 bgp_auth_parse (struct peer *peer, size_t length)
 643 {
 644   bgp_notify_send (peer,
 645                    BGP_NOTIFY_OPEN_ERR,
 646                    BGP_NOTIFY_OPEN_AUTH_FAILURE);
 647   return -1;
 648 }
 649
 650 static int
 651 strict_capability_same (struct peer *peer)
 652 {
 653   int i, j;
 654
 655   for (i = AFI_IP; i < AFI_MAX; i++)
 656     for (j = SAFI_UNICAST; j < SAFI_MAX; j++)
 657       if (peer->afc[i][j] != peer->afc_nego[i][j])
 658         return 0;
 659   return 1;
 660 }
 661
 662 /* peek into option, stores ASN to *as4 if the AS4 capability was found.
 663  * Returns  0 if no as4 found, as4cap value otherwise.
 664  */
 665 as_t
 666 peek_for_as4_capability (struct peer *peer, u_char length)
 667 {
 668   struct stream *s = BGP_INPUT (peer);
 669   size_t orig_getp = stream_get_getp (s);
 670   size_t end = orig_getp + length;
 671   as_t as4 = 0;
 672
 673   /* The full capability parser will better flag the error.. */
 674   if (STREAM_READABLE(s) < length)
 675     return 0;
 676
 677   if (BGP_DEBUG (as4, AS4))
 678     zlog_info ("%s [AS4] rcv OPEN w/ OPTION parameter len: %u,"
 679                 " peeking for as4",
 680                 peer->host, length);
 681   /* the error cases we DONT handle, we ONLY try to read as4 out of
 682    * correctly formatted options.
 683    */
 684   while (stream_get_getp(s) < end)
 685     {
 686       u_char opt_type;
 687       u_char opt_length;
 688
 689       /* Check the length. */
 690       if (stream_get_getp (s) + 2 > end)
 691         goto end;
 692
 693       /* Fetch option type and length. */
 694       opt_type = stream_getc (s);
 695       opt_length = stream_getc (s);
 696
 697       /* Option length check. */
 698       if (stream_get_getp (s) + opt_length > end)
 699         goto end;
 700
 701       if (opt_type == BGP_OPEN_OPT_CAP)
 702         {
 703           unsigned long capd_start = stream_get_getp (s);
 704           unsigned long capd_end = capd_start + opt_length;
 705
 706           assert (capd_end <= end);
 707
 708           while (stream_get_getp (s) < capd_end)
 709             {
 710               struct capability_header hdr;
 711
 712               if (stream_get_getp (s) + 2 > capd_end)
 713                 goto end;
 714
 715               hdr.code = stream_getc (s);
 716               hdr.length = stream_getc (s);
 717
 718               if ((stream_get_getp(s) +  hdr.length) > capd_end)
 719                 goto end;
 720
 721               if (hdr.code == CAPABILITY_CODE_AS4)
 722                 {
 723                   if (BGP_DEBUG (as4, AS4))
 724                     zlog_info ("[AS4] found AS4 capability, about to parse");
 725                   as4 = bgp_capability_as4 (peer, &hdr);
 726
 727                   goto end;
 728                 }
 729               stream_forward_getp (s, hdr.length);
 730             }
 731         }
 732     }
 733
 734 end:
 735   stream_set_getp (s, orig_getp);
 736   return as4;
 737 }
 738
 739 /**
 740  * Parse open option.
 741  *
 742  * @param[out] mp_capability @see bgp_capability_parse() for semantics.
 743  */
 744 int
 745 bgp_open_option_parse (struct peer *peer, u_char length, int *mp_capability)
 746 {
 747   int ret;
 748   u_char *error;
 749   u_char error_data[BGP_MAX_PACKET_SIZE];
 750   struct stream *s = BGP_INPUT(peer);
 751   size_t end = stream_get_getp (s) + length;
 752
 753   ret = 0;
 754   error = error_data;
 755
 756   if (BGP_DEBUG (normal, NORMAL))
 757     zlog_debug ("%s rcv OPEN w/ OPTION parameter len: %u",
 758                peer->host, length);
 759
 760   while (stream_get_getp(s) < end)
 761     {
 762       u_char opt_type;
 763       u_char opt_length;
 764
 765       /* Must have at least an OPEN option header */
 766       if (STREAM_READABLE(s) < 2)
 767         {
 768           zlog_info ("%s Option length error", peer->host);
 769           bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
 770                                  BGP_NOTIFY_OPEN_UNSPECIFIC);
 771           return -1;
 772         }
 773
 774       /* Fetch option type and length. */
 775       opt_type = stream_getc (s);
 776       opt_length = stream_getc (s);
 777
 778       /* Option length check. */
 779       if (STREAM_READABLE (s) < opt_length)
 780         {
 781           zlog_info ("%s Option length error", peer->host);
 782           bgp_notify_send (peer, BGP_NOTIFY_OPEN_ERR,
 783                                  BGP_NOTIFY_OPEN_UNSPECIFIC);
 784           return -1;
 785         }
 786
 787       if (BGP_DEBUG (normal, NORMAL))
 788         zlog_debug ("%s rcvd OPEN w/ optional parameter type %u (%s) len %u",
 789                    peer->host, opt_type,
 790                    opt_type == BGP_OPEN_OPT_AUTH ? "Authentication" :
 791                    opt_type == BGP_OPEN_OPT_CAP ? "Capability" : "Unknown",
 792                    opt_length);
 793
 794       switch (opt_type)
 795         {
 796         case BGP_OPEN_OPT_AUTH:
 797           ret = bgp_auth_parse (peer, opt_length);
 798           break;
 799         case BGP_OPEN_OPT_CAP:
 800           ret = bgp_capability_parse (peer, opt_length, mp_capability, &error);
 801           break;
 802         default:
 803           bgp_notify_send (peer,
 804                            BGP_NOTIFY_OPEN_ERR,
 805                            BGP_NOTIFY_OPEN_UNSUP_PARAM);
 806           ret = -1;
 807           break;
 808         }
 809
 810       /* Parse error.  To accumulate all unsupported capability codes,
 811          bgp_capability_parse does not return -1 when encounter
 812          unsupported capability code.  To detect that, please check
 813          error and erro_data pointer, like below.  */
 814       if (ret < 0)
 815         return -1;
 816     }
 817
 818   /* All OPEN option is parsed.  Check capability when strict compare
 819      flag is enabled.*/
 820   if (CHECK_FLAG (peer->flags, PEER_FLAG_STRICT_CAP_MATCH))
 821     {
 822       /* If Unsupported Capability exists. */
 823       if (error != error_data)
 824         {
 825           bgp_notify_send_with_data (peer,
 826                                      BGP_NOTIFY_OPEN_ERR,
 827                                      BGP_NOTIFY_OPEN_UNSUP_CAPBL,
 828                                      error_data, error - error_data);
 829           return -1;
 830         }
 831
 832       /* Check local capability does not negotiated with remote
 833          peer. */
 834       if (! strict_capability_same (peer))
 835         {
 836           bgp_notify_send (peer,
 837                            BGP_NOTIFY_OPEN_ERR,
 838                            BGP_NOTIFY_OPEN_UNSUP_CAPBL);
 839           return -1;
 840         }
 841     }
 842
 843   /* Check there are no common AFI/SAFIs and send Unsupported Capability
 844      error. */
 845   if (*mp_capability &&
 846       ! CHECK_FLAG (peer->flags, PEER_FLAG_OVERRIDE_CAPABILITY))
 847     {
 848       if (! peer->afc_nego[AFI_IP][SAFI_UNICAST]
 849           && ! peer->afc_nego[AFI_IP][SAFI_MULTICAST]
 850           && ! peer->afc_nego[AFI_IP][SAFI_MPLS_VPN]
 851           && ! peer->afc_nego[AFI_IP][SAFI_ENCAP]
 852           && ! peer->afc_nego[AFI_IP6][SAFI_UNICAST]
 853           && ! peer->afc_nego[AFI_IP6][SAFI_MULTICAST]
 854           && ! peer->afc_nego[AFI_IP6][SAFI_MPLS_VPN]
 855           && ! peer->afc_nego[AFI_IP6][SAFI_ENCAP])
 856         {
 857           plog_err (peer->log, "%s [Error] Configured AFI/SAFIs do not "
 858                     "overlap with received MP capabilities",
 859                     peer->host);
 860
 861           if (error != error_data)
 862
 863             bgp_notify_send_with_data (peer,
 864                                        BGP_NOTIFY_OPEN_ERR,
 865                                        BGP_NOTIFY_OPEN_UNSUP_CAPBL,
 866                                        error_data, error - error_data);
 867           else
 868             bgp_notify_send (peer,
 869                              BGP_NOTIFY_OPEN_ERR,
 870                              BGP_NOTIFY_OPEN_UNSUP_CAPBL);
 871           return -1;
 872         }
 873     }
 874   return 0;
 875 }
 876
 877 static void
 878 bgp_open_capability_orf (struct stream *s, struct peer *peer,
 879                          afi_t afi, safi_t safi, u_char code)
 880 {
 881   u_char cap_len;
 882   u_char orf_len;
 883   unsigned long capp;
 884   unsigned long orfp;
 885   unsigned long numberp;
 886   int number_of_orfs = 0;
 887
 888   if (safi == SAFI_MPLS_VPN)
 889     safi = SAFI_MPLS_LABELED_VPN;
 890
 891   stream_putc (s, BGP_OPEN_OPT_CAP);
 892   capp = stream_get_endp (s);           /* Set Capability Len Pointer */
 893   stream_putc (s, 0);                   /* Capability Length */
 894   stream_putc (s, code);                /* Capability Code */
 895   orfp = stream_get_endp (s);           /* Set ORF Len Pointer */
 896   stream_putc (s, 0);                   /* ORF Length */
 897   stream_putw (s, afi);
 898   stream_putc (s, 0);
 899   stream_putc (s, safi);
 900   numberp = stream_get_endp (s);        /* Set Number Pointer */
 901   stream_putc (s, 0);                   /* Number of ORFs */
 902
 903   /* Address Prefix ORF */
 904   if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
 905       || CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
 906     {
 907       stream_putc (s, (code == CAPABILITY_CODE_ORF ?
 908                    ORF_TYPE_PREFIX : ORF_TYPE_PREFIX_OLD));
 909
 910       if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
 911           && CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
 912         {
 913           SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV);
 914           SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV);
 915           stream_putc (s, ORF_MODE_BOTH);
 916         }
 917       else if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM))
 918         {
 919           SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_SM_ADV);
 920           stream_putc (s, ORF_MODE_SEND);
 921         }
 922       else
 923         {
 924           SET_FLAG (peer->af_cap[afi][safi], PEER_CAP_ORF_PREFIX_RM_ADV);
 925           stream_putc (s, ORF_MODE_RECEIVE);
 926         }
 927       number_of_orfs++;
 928     }
 929
 930   /* Total Number of ORFs. */
 931   stream_putc_at (s, numberp, number_of_orfs);
 932
 933   /* Total ORF Len. */
 934   orf_len = stream_get_endp (s) - orfp - 1;
 935   stream_putc_at (s, orfp, orf_len);
 936
 937   /* Total Capability Len. */
 938   cap_len = stream_get_endp (s) - capp - 1;
 939   stream_putc_at (s, capp, cap_len);
 940 }
 941
 942 /* Fill in capability open option to the packet. */
 943 void
 944 bgp_open_capability (struct stream *s, struct peer *peer)
 945 {
 946   u_char len;
 947   unsigned long cp, capp, rcapp;
 948   afi_t afi;
 949   safi_t safi;
 950   as_t local_as;
 951   u_int32_t restart_time;
 952
 953   /* Remember current pointer for Opt Parm Len. */
 954   cp = stream_get_endp (s);
 955
 956   /* Opt Parm Len. */
 957   stream_putc (s, 0);
 958
 959   /* Do not send capability. */
 960   if (! CHECK_FLAG (peer->sflags, PEER_STATUS_CAPABILITY_OPEN)
 961       || CHECK_FLAG (peer->flags, PEER_FLAG_DONT_CAPABILITY))
 962     return;
 963
 964   /* IPv4 unicast. */
 965   if (peer->afc[AFI_IP][SAFI_UNICAST])
 966     {
 967       peer->afc_adv[AFI_IP][SAFI_UNICAST] = 1;
 968       stream_putc (s, BGP_OPEN_OPT_CAP);
 969       stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
 970       stream_putc (s, CAPABILITY_CODE_MP);
 971       stream_putc (s, CAPABILITY_CODE_MP_LEN);
 972       stream_putw (s, AFI_IP);
 973       stream_putc (s, 0);
 974       stream_putc (s, SAFI_UNICAST);
 975     }
 976   /* IPv4 multicast. */
 977   if (peer->afc[AFI_IP][SAFI_MULTICAST])
 978     {
 979       peer->afc_adv[AFI_IP][SAFI_MULTICAST] = 1;
 980       stream_putc (s, BGP_OPEN_OPT_CAP);
 981       stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
 982       stream_putc (s, CAPABILITY_CODE_MP);
 983       stream_putc (s, CAPABILITY_CODE_MP_LEN);
 984       stream_putw (s, AFI_IP);
 985       stream_putc (s, 0);
 986       stream_putc (s, SAFI_MULTICAST);
 987     }
 988   /* IPv4 VPN */
 989   if (peer->afc[AFI_IP][SAFI_MPLS_VPN])
 990     {
 991       peer->afc_adv[AFI_IP][SAFI_MPLS_VPN] = 1;
 992       stream_putc (s, BGP_OPEN_OPT_CAP);
 993       stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
 994       stream_putc (s, CAPABILITY_CODE_MP);
 995       stream_putc (s, CAPABILITY_CODE_MP_LEN);
 996       stream_putw (s, AFI_IP);
 997       stream_putc (s, 0);
 998       stream_putc (s, SAFI_MPLS_LABELED_VPN);
 999     }
1000   /* ENCAP */
1001   if (peer->afc[AFI_IP][SAFI_ENCAP])
1002     {
1003       peer->afc_adv[AFI_IP][SAFI_ENCAP] = 1;
1004       stream_putc (s, BGP_OPEN_OPT_CAP);
1005       stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
1006       stream_putc (s, CAPABILITY_CODE_MP);
1007       stream_putc (s, CAPABILITY_CODE_MP_LEN);
1008       stream_putw (s, AFI_IP);
1009       stream_putc (s, 0);
1010       stream_putc (s, SAFI_ENCAP);
1011     }
1012   /* IPv6 unicast. */
1013   if (peer->afc[AFI_IP6][SAFI_UNICAST])
1014     {
1015       peer->afc_adv[AFI_IP6][SAFI_UNICAST] = 1;
1016       stream_putc (s, BGP_OPEN_OPT_CAP);
1017       stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
1018       stream_putc (s, CAPABILITY_CODE_MP);
1019       stream_putc (s, CAPABILITY_CODE_MP_LEN);
1020       stream_putw (s, AFI_IP6);
1021       stream_putc (s, 0);
1022       stream_putc (s, SAFI_UNICAST);
1023     }
1024   /* IPv6 multicast. */
1025   if (peer->afc[AFI_IP6][SAFI_MULTICAST])
1026     {
1027       peer->afc_adv[AFI_IP6][SAFI_MULTICAST] = 1;
1028       stream_putc (s, BGP_OPEN_OPT_CAP);
1029       stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
1030       stream_putc (s, CAPABILITY_CODE_MP);
1031       stream_putc (s, CAPABILITY_CODE_MP_LEN);
1032       stream_putw (s, AFI_IP6);
1033       stream_putc (s, 0);
1034       stream_putc (s, SAFI_MULTICAST);
1035     }
1036   /* IPv6 VPN. */
1037   if (peer->afc[AFI_IP6][SAFI_MPLS_VPN])
1038     {
1039       peer->afc_adv[AFI_IP6][SAFI_MPLS_VPN] = 1;
1040       stream_putc (s, BGP_OPEN_OPT_CAP);
1041       stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
1042       stream_putc (s, CAPABILITY_CODE_MP);
1043       stream_putc (s, CAPABILITY_CODE_MP_LEN);
1044       stream_putw (s, AFI_IP6);
1045       stream_putc (s, 0);
1046       stream_putc (s, SAFI_MPLS_LABELED_VPN);
1047     }
1048   /* IPv6 ENCAP. */
1049   if (peer->afc[AFI_IP6][SAFI_ENCAP])
1050     {
1051       peer->afc_adv[AFI_IP6][SAFI_ENCAP] = 1;
1052       stream_putc (s, BGP_OPEN_OPT_CAP);
1053       stream_putc (s, CAPABILITY_CODE_MP_LEN + 2);
1054       stream_putc (s, CAPABILITY_CODE_MP);
1055       stream_putc (s, CAPABILITY_CODE_MP_LEN);
1056       stream_putw (s, AFI_IP6);
1057       stream_putc (s, 0);
1058       stream_putc (s, SAFI_ENCAP);
1059     }
1060
1061   /* Route refresh. */
1062   SET_FLAG (peer->cap, PEER_CAP_REFRESH_ADV);
1063   stream_putc (s, BGP_OPEN_OPT_CAP);
1064   stream_putc (s, CAPABILITY_CODE_REFRESH_LEN + 2);
1065   stream_putc (s, CAPABILITY_CODE_REFRESH_OLD);
1066   stream_putc (s, CAPABILITY_CODE_REFRESH_LEN);
1067   stream_putc (s, BGP_OPEN_OPT_CAP);
1068   stream_putc (s, CAPABILITY_CODE_REFRESH_LEN + 2);
1069   stream_putc (s, CAPABILITY_CODE_REFRESH);
1070   stream_putc (s, CAPABILITY_CODE_REFRESH_LEN);
1071
1072   /* AS4 */
1073   SET_FLAG (peer->cap, PEER_CAP_AS4_ADV);
1074   stream_putc (s, BGP_OPEN_OPT_CAP);
1075   stream_putc (s, CAPABILITY_CODE_AS4_LEN + 2);
1076   stream_putc (s, CAPABILITY_CODE_AS4);
1077   stream_putc (s, CAPABILITY_CODE_AS4_LEN);
1078   if ( peer->change_local_as )
1079     local_as = peer->change_local_as;
1080   else
1081     local_as = peer->local_as;
1082   stream_putl (s, local_as );
1083
1084   /* ORF capability. */
1085   for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
1086     for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
1087       if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_SM)
1088           || CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_ORF_PREFIX_RM))
1089         {
1090           bgp_open_capability_orf (s, peer, afi, safi, CAPABILITY_CODE_ORF_OLD);
1091           bgp_open_capability_orf (s, peer, afi, safi, CAPABILITY_CODE_ORF);
1092         }
1093
1094   /* Dynamic capability. */
1095   if (CHECK_FLAG (peer->flags, PEER_FLAG_DYNAMIC_CAPABILITY))
1096     {
1097       SET_FLAG (peer->cap, PEER_CAP_DYNAMIC_ADV);
1098       stream_putc (s, BGP_OPEN_OPT_CAP);
1099       stream_putc (s, CAPABILITY_CODE_DYNAMIC_LEN + 2);
1100       stream_putc (s, CAPABILITY_CODE_DYNAMIC);
1101       stream_putc (s, CAPABILITY_CODE_DYNAMIC_LEN);
1102     }
1103
1104   /* Sending base graceful-restart capability irrespective of the config */
1105   SET_FLAG (peer->cap, PEER_CAP_RESTART_ADV);
1106   stream_putc (s, BGP_OPEN_OPT_CAP);
1107   capp = stream_get_endp (s);           /* Set Capability Len Pointer */
1108   stream_putc (s, 0);                   /* Capability Length */
1109   stream_putc (s, CAPABILITY_CODE_RESTART);
1110   rcapp = stream_get_endp (s);          /* Set Restart Capability Len Pointer */
1111   stream_putc (s, 0);
1112   restart_time = peer->bgp->restart_time;
1113   if (peer->bgp->t_startup)
1114     {
1115       SET_FLAG (restart_time, RESTART_R_BIT);
1116       SET_FLAG (peer->cap, PEER_CAP_RESTART_BIT_ADV);
1117     }
1118   stream_putw (s, restart_time);
1119
1120   /* Send address-family specific graceful-restart capability only when GR config
1121      is present */
1122   if (bgp_flag_check (peer->bgp, BGP_FLAG_GRACEFUL_RESTART))
1123     {
1124       for (afi = AFI_IP ; afi < AFI_MAX ; afi++)
1125         for (safi = SAFI_UNICAST ; safi < SAFI_MAX ; safi++)
1126           if (peer->afc[afi][safi])
1127             {
1128               stream_putw (s, afi);
1129               stream_putc (s, safi);
1130               stream_putc (s, 0); //Forwarding is not retained as of now.
1131             }
1132     }
1133
1134   /* Total Graceful restart capability Len. */
1135   len = stream_get_endp (s) - rcapp - 1;
1136   stream_putc_at (s, rcapp, len);
1137
1138   /* Total Capability Len. */
1139   len = stream_get_endp (s) - capp - 1;
1140   stream_putc_at (s, capp, len);
1141
1142   /* Total Opt Parm Len. */
1143   len = stream_get_endp (s) - cp - 1;
1144   stream_putc_at (s, cp, len);
1145 }