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