Annotation of embedaddon/quagga/bgpd/bgp_attr.c, revision 1.1
1.1 ! misho 1: /* BGP attributes management routines.
! 2: Copyright (C) 1996, 97, 98, 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 "memory.h"
! 26: #include "vector.h"
! 27: #include "vty.h"
! 28: #include "stream.h"
! 29: #include "log.h"
! 30: #include "hash.h"
! 31: #include "jhash.h"
! 32:
! 33: #include "bgpd/bgpd.h"
! 34: #include "bgpd/bgp_attr.h"
! 35: #include "bgpd/bgp_route.h"
! 36: #include "bgpd/bgp_aspath.h"
! 37: #include "bgpd/bgp_community.h"
! 38: #include "bgpd/bgp_debug.h"
! 39: #include "bgpd/bgp_packet.h"
! 40: #include "bgpd/bgp_ecommunity.h"
! 41:
! 42: /* Attribute strings for logging. */
! 43: static const struct message attr_str [] =
! 44: {
! 45: { BGP_ATTR_ORIGIN, "ORIGIN" },
! 46: { BGP_ATTR_AS_PATH, "AS_PATH" },
! 47: { BGP_ATTR_NEXT_HOP, "NEXT_HOP" },
! 48: { BGP_ATTR_MULTI_EXIT_DISC, "MULTI_EXIT_DISC" },
! 49: { BGP_ATTR_LOCAL_PREF, "LOCAL_PREF" },
! 50: { BGP_ATTR_ATOMIC_AGGREGATE, "ATOMIC_AGGREGATE" },
! 51: { BGP_ATTR_AGGREGATOR, "AGGREGATOR" },
! 52: { BGP_ATTR_COMMUNITIES, "COMMUNITY" },
! 53: { BGP_ATTR_ORIGINATOR_ID, "ORIGINATOR_ID" },
! 54: { BGP_ATTR_CLUSTER_LIST, "CLUSTERLIST" },
! 55: { BGP_ATTR_DPA, "DPA" },
! 56: { BGP_ATTR_ADVERTISER, "ADVERTISER"} ,
! 57: { BGP_ATTR_RCID_PATH, "RCID_PATH" },
! 58: { BGP_ATTR_MP_REACH_NLRI, "MP_REACH_NLRI" },
! 59: { BGP_ATTR_MP_UNREACH_NLRI, "MP_UNREACH_NLRI" },
! 60: { BGP_ATTR_EXT_COMMUNITIES, "EXT_COMMUNITIES" },
! 61: { BGP_ATTR_AS4_PATH, "AS4_PATH" },
! 62: { BGP_ATTR_AS4_AGGREGATOR, "AS4_AGGREGATOR" },
! 63: { BGP_ATTR_AS_PATHLIMIT, "AS_PATHLIMIT" },
! 64: };
! 65: static const int attr_str_max = sizeof(attr_str)/sizeof(attr_str[0]);
! 66:
! 67: static struct hash *cluster_hash;
! 68:
! 69: static void *
! 70: cluster_hash_alloc (void *p)
! 71: {
! 72: struct cluster_list * val = (struct cluster_list *) p;
! 73: struct cluster_list *cluster;
! 74:
! 75: cluster = XMALLOC (MTYPE_CLUSTER, sizeof (struct cluster_list));
! 76: cluster->length = val->length;
! 77:
! 78: if (cluster->length)
! 79: {
! 80: cluster->list = XMALLOC (MTYPE_CLUSTER_VAL, val->length);
! 81: memcpy (cluster->list, val->list, val->length);
! 82: }
! 83: else
! 84: cluster->list = NULL;
! 85:
! 86: cluster->refcnt = 0;
! 87:
! 88: return cluster;
! 89: }
! 90:
! 91: /* Cluster list related functions. */
! 92: static struct cluster_list *
! 93: cluster_parse (struct in_addr * pnt, int length)
! 94: {
! 95: struct cluster_list tmp;
! 96: struct cluster_list *cluster;
! 97:
! 98: tmp.length = length;
! 99: tmp.list = pnt;
! 100:
! 101: cluster = hash_get (cluster_hash, &tmp, cluster_hash_alloc);
! 102: cluster->refcnt++;
! 103: return cluster;
! 104: }
! 105:
! 106: int
! 107: cluster_loop_check (struct cluster_list *cluster, struct in_addr originator)
! 108: {
! 109: int i;
! 110:
! 111: for (i = 0; i < cluster->length / 4; i++)
! 112: if (cluster->list[i].s_addr == originator.s_addr)
! 113: return 1;
! 114: return 0;
! 115: }
! 116:
! 117: static unsigned int
! 118: cluster_hash_key_make (void *p)
! 119: {
! 120: const struct cluster_list *cluster = p;
! 121:
! 122: return jhash(cluster->list, cluster->length, 0);
! 123: }
! 124:
! 125: static int
! 126: cluster_hash_cmp (const void *p1, const void *p2)
! 127: {
! 128: const struct cluster_list * cluster1 = p1;
! 129: const struct cluster_list * cluster2 = p2;
! 130:
! 131: return (cluster1->length == cluster2->length &&
! 132: memcmp (cluster1->list, cluster2->list, cluster1->length) == 0);
! 133: }
! 134:
! 135: static void
! 136: cluster_free (struct cluster_list *cluster)
! 137: {
! 138: if (cluster->list)
! 139: XFREE (MTYPE_CLUSTER_VAL, cluster->list);
! 140: XFREE (MTYPE_CLUSTER, cluster);
! 141: }
! 142:
! 143: #if 0
! 144: static struct cluster_list *
! 145: cluster_dup (struct cluster_list *cluster)
! 146: {
! 147: struct cluster_list *new;
! 148:
! 149: new = XCALLOC (MTYPE_CLUSTER, sizeof (struct cluster_list));
! 150: new->length = cluster->length;
! 151:
! 152: if (cluster->length)
! 153: {
! 154: new->list = XMALLOC (MTYPE_CLUSTER_VAL, cluster->length);
! 155: memcpy (new->list, cluster->list, cluster->length);
! 156: }
! 157: else
! 158: new->list = NULL;
! 159:
! 160: return new;
! 161: }
! 162: #endif
! 163:
! 164: static struct cluster_list *
! 165: cluster_intern (struct cluster_list *cluster)
! 166: {
! 167: struct cluster_list *find;
! 168:
! 169: find = hash_get (cluster_hash, cluster, cluster_hash_alloc);
! 170: find->refcnt++;
! 171:
! 172: return find;
! 173: }
! 174:
! 175: void
! 176: cluster_unintern (struct cluster_list *cluster)
! 177: {
! 178: struct cluster_list *ret;
! 179:
! 180: if (cluster->refcnt)
! 181: cluster->refcnt--;
! 182:
! 183: if (cluster->refcnt == 0)
! 184: {
! 185: ret = hash_release (cluster_hash, cluster);
! 186: cluster_free (cluster);
! 187: }
! 188: }
! 189:
! 190: static void
! 191: cluster_init (void)
! 192: {
! 193: cluster_hash = hash_create (cluster_hash_key_make, cluster_hash_cmp);
! 194: }
! 195:
! 196: static void
! 197: cluster_finish (void)
! 198: {
! 199: hash_free (cluster_hash);
! 200: cluster_hash = NULL;
! 201: }
! 202:
! 203: /* Unknown transit attribute. */
! 204: static struct hash *transit_hash;
! 205:
! 206: static void
! 207: transit_free (struct transit *transit)
! 208: {
! 209: if (transit->val)
! 210: XFREE (MTYPE_TRANSIT_VAL, transit->val);
! 211: XFREE (MTYPE_TRANSIT, transit);
! 212: }
! 213:
! 214:
! 215: static void *
! 216: transit_hash_alloc (void *p)
! 217: {
! 218: /* Transit structure is already allocated. */
! 219: return p;
! 220: }
! 221:
! 222: static struct transit *
! 223: transit_intern (struct transit *transit)
! 224: {
! 225: struct transit *find;
! 226:
! 227: find = hash_get (transit_hash, transit, transit_hash_alloc);
! 228: if (find != transit)
! 229: transit_free (transit);
! 230: find->refcnt++;
! 231:
! 232: return find;
! 233: }
! 234:
! 235: void
! 236: transit_unintern (struct transit *transit)
! 237: {
! 238: struct transit *ret;
! 239:
! 240: if (transit->refcnt)
! 241: transit->refcnt--;
! 242:
! 243: if (transit->refcnt == 0)
! 244: {
! 245: ret = hash_release (transit_hash, transit);
! 246: transit_free (transit);
! 247: }
! 248: }
! 249:
! 250: static unsigned int
! 251: transit_hash_key_make (void *p)
! 252: {
! 253: const struct transit * transit = p;
! 254:
! 255: return jhash(transit->val, transit->length, 0);
! 256: }
! 257:
! 258: static int
! 259: transit_hash_cmp (const void *p1, const void *p2)
! 260: {
! 261: const struct transit * transit1 = p1;
! 262: const struct transit * transit2 = p2;
! 263:
! 264: return (transit1->length == transit2->length &&
! 265: memcmp (transit1->val, transit2->val, transit1->length) == 0);
! 266: }
! 267:
! 268: static void
! 269: transit_init (void)
! 270: {
! 271: transit_hash = hash_create (transit_hash_key_make, transit_hash_cmp);
! 272: }
! 273:
! 274: static void
! 275: transit_finish (void)
! 276: {
! 277: hash_free (transit_hash);
! 278: transit_hash = NULL;
! 279: }
! 280:
! 281: /* Attribute hash routines. */
! 282: static struct hash *attrhash;
! 283:
! 284: static struct attr_extra *
! 285: bgp_attr_extra_new (void)
! 286: {
! 287: return XCALLOC (MTYPE_ATTR_EXTRA, sizeof (struct attr_extra));
! 288: }
! 289:
! 290: void
! 291: bgp_attr_extra_free (struct attr *attr)
! 292: {
! 293: if (attr->extra)
! 294: {
! 295: XFREE (MTYPE_ATTR_EXTRA, attr->extra);
! 296: attr->extra = NULL;
! 297: }
! 298: }
! 299:
! 300: struct attr_extra *
! 301: bgp_attr_extra_get (struct attr *attr)
! 302: {
! 303: if (!attr->extra)
! 304: attr->extra = bgp_attr_extra_new();
! 305: return attr->extra;
! 306: }
! 307:
! 308: /* Shallow copy of an attribute
! 309: * Though, not so shallow that it doesn't copy the contents
! 310: * of the attr_extra pointed to by 'extra'
! 311: */
! 312: void
! 313: bgp_attr_dup (struct attr *new, struct attr *orig)
! 314: {
! 315: *new = *orig;
! 316: if (orig->extra)
! 317: {
! 318: new->extra = bgp_attr_extra_new();
! 319: *new->extra = *orig->extra;
! 320: }
! 321: }
! 322:
! 323: unsigned long int
! 324: attr_count (void)
! 325: {
! 326: return attrhash->count;
! 327: }
! 328:
! 329: unsigned long int
! 330: attr_unknown_count (void)
! 331: {
! 332: return transit_hash->count;
! 333: }
! 334:
! 335: unsigned int
! 336: attrhash_key_make (void *p)
! 337: {
! 338: const struct attr * attr = (struct attr *) p;
! 339: uint32_t key = 0;
! 340: #define MIX(val) key = jhash_1word(val, key)
! 341:
! 342: MIX(attr->origin);
! 343: MIX(attr->nexthop.s_addr);
! 344: MIX(attr->med);
! 345: MIX(attr->local_pref);
! 346:
! 347: key += attr->origin;
! 348: key += attr->nexthop.s_addr;
! 349: key += attr->med;
! 350: key += attr->local_pref;
! 351:
! 352: if (attr->extra)
! 353: {
! 354: MIX(attr->extra->aggregator_as);
! 355: MIX(attr->extra->aggregator_addr.s_addr);
! 356: MIX(attr->extra->weight);
! 357: MIX(attr->extra->mp_nexthop_global_in.s_addr);
! 358: }
! 359:
! 360: if (attr->aspath)
! 361: MIX(aspath_key_make (attr->aspath));
! 362: if (attr->community)
! 363: MIX(community_hash_make (attr->community));
! 364:
! 365: if (attr->extra)
! 366: {
! 367: if (attr->extra->ecommunity)
! 368: MIX(ecommunity_hash_make (attr->extra->ecommunity));
! 369: if (attr->extra->cluster)
! 370: MIX(cluster_hash_key_make (attr->extra->cluster));
! 371: if (attr->extra->transit)
! 372: MIX(transit_hash_key_make (attr->extra->transit));
! 373:
! 374: #ifdef HAVE_IPV6
! 375: MIX(attr->extra->mp_nexthop_len);
! 376: key = jhash(attr->extra->mp_nexthop_global.s6_addr, 16, key);
! 377: key = jhash(attr->extra->mp_nexthop_local.s6_addr, 16, key);
! 378: #endif /* HAVE_IPV6 */
! 379: }
! 380:
! 381: return key;
! 382: }
! 383:
! 384: int
! 385: attrhash_cmp (const void *p1, const void *p2)
! 386: {
! 387: const struct attr * attr1 = p1;
! 388: const struct attr * attr2 = p2;
! 389:
! 390: if (attr1->flag == attr2->flag
! 391: && attr1->origin == attr2->origin
! 392: && attr1->nexthop.s_addr == attr2->nexthop.s_addr
! 393: && attr1->aspath == attr2->aspath
! 394: && attr1->community == attr2->community
! 395: && attr1->med == attr2->med
! 396: && attr1->local_pref == attr2->local_pref)
! 397: {
! 398: const struct attr_extra *ae1 = attr1->extra;
! 399: const struct attr_extra *ae2 = attr2->extra;
! 400:
! 401: if (ae1 && ae2
! 402: && ae1->aggregator_as == ae2->aggregator_as
! 403: && ae1->aggregator_addr.s_addr == ae2->aggregator_addr.s_addr
! 404: && ae1->weight == ae2->weight
! 405: #ifdef HAVE_IPV6
! 406: && ae1->mp_nexthop_len == ae2->mp_nexthop_len
! 407: && IPV6_ADDR_SAME (&ae1->mp_nexthop_global, &ae2->mp_nexthop_global)
! 408: && IPV6_ADDR_SAME (&ae1->mp_nexthop_local, &ae2->mp_nexthop_local)
! 409: #endif /* HAVE_IPV6 */
! 410: && IPV4_ADDR_SAME (&ae1->mp_nexthop_global_in, &ae2->mp_nexthop_global_in)
! 411: && ae1->ecommunity == ae2->ecommunity
! 412: && ae1->cluster == ae2->cluster
! 413: && ae1->transit == ae2->transit)
! 414: return 1;
! 415: else if (ae1 || ae2)
! 416: return 0;
! 417: /* neither attribute has extra attributes, so they're same */
! 418: return 1;
! 419: }
! 420: else
! 421: return 0;
! 422: }
! 423:
! 424: static void
! 425: attrhash_init (void)
! 426: {
! 427: attrhash = hash_create (attrhash_key_make, attrhash_cmp);
! 428: }
! 429:
! 430: static void
! 431: attrhash_finish (void)
! 432: {
! 433: hash_free (attrhash);
! 434: attrhash = NULL;
! 435: }
! 436:
! 437: static void
! 438: attr_show_all_iterator (struct hash_backet *backet, struct vty *vty)
! 439: {
! 440: struct attr *attr = backet->data;
! 441:
! 442: vty_out (vty, "attr[%ld] nexthop %s%s", attr->refcnt,
! 443: inet_ntoa (attr->nexthop), VTY_NEWLINE);
! 444: }
! 445:
! 446: void
! 447: attr_show_all (struct vty *vty)
! 448: {
! 449: hash_iterate (attrhash,
! 450: (void (*)(struct hash_backet *, void *))
! 451: attr_show_all_iterator,
! 452: vty);
! 453: }
! 454:
! 455: static void *
! 456: bgp_attr_hash_alloc (void *p)
! 457: {
! 458: struct attr * val = (struct attr *) p;
! 459: struct attr *attr;
! 460:
! 461: attr = XMALLOC (MTYPE_ATTR, sizeof (struct attr));
! 462: *attr = *val;
! 463: if (val->extra)
! 464: {
! 465: attr->extra = bgp_attr_extra_new ();
! 466: *attr->extra = *val->extra;
! 467: }
! 468: attr->refcnt = 0;
! 469: return attr;
! 470: }
! 471:
! 472: /* Internet argument attribute. */
! 473: struct attr *
! 474: bgp_attr_intern (struct attr *attr)
! 475: {
! 476: struct attr *find;
! 477:
! 478: /* Intern referenced strucutre. */
! 479: if (attr->aspath)
! 480: {
! 481: if (! attr->aspath->refcnt)
! 482: attr->aspath = aspath_intern (attr->aspath);
! 483: else
! 484: attr->aspath->refcnt++;
! 485: }
! 486: if (attr->community)
! 487: {
! 488: if (! attr->community->refcnt)
! 489: attr->community = community_intern (attr->community);
! 490: else
! 491: attr->community->refcnt++;
! 492: }
! 493: if (attr->extra)
! 494: {
! 495: struct attr_extra *attre = attr->extra;
! 496:
! 497: if (attre->ecommunity)
! 498: {
! 499: if (! attre->ecommunity->refcnt)
! 500: attre->ecommunity = ecommunity_intern (attre->ecommunity);
! 501: else
! 502: attre->ecommunity->refcnt++;
! 503:
! 504: }
! 505: if (attre->cluster)
! 506: {
! 507: if (! attre->cluster->refcnt)
! 508: attre->cluster = cluster_intern (attre->cluster);
! 509: else
! 510: attre->cluster->refcnt++;
! 511: }
! 512: if (attre->transit)
! 513: {
! 514: if (! attre->transit->refcnt)
! 515: attre->transit = transit_intern (attre->transit);
! 516: else
! 517: attre->transit->refcnt++;
! 518: }
! 519: }
! 520:
! 521: find = (struct attr *) hash_get (attrhash, attr, bgp_attr_hash_alloc);
! 522: find->refcnt++;
! 523:
! 524: return find;
! 525: }
! 526:
! 527:
! 528: /* Make network statement's attribute. */
! 529: struct attr *
! 530: bgp_attr_default_set (struct attr *attr, u_char origin)
! 531: {
! 532: memset (attr, 0, sizeof (struct attr));
! 533: bgp_attr_extra_get (attr);
! 534:
! 535: attr->origin = origin;
! 536: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
! 537: attr->aspath = aspath_empty ();
! 538: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
! 539: attr->extra->weight = BGP_ATTR_DEFAULT_WEIGHT;
! 540: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
! 541: #ifdef HAVE_IPV6
! 542: attr->extra->mp_nexthop_len = IPV6_MAX_BYTELEN;
! 543: #endif
! 544:
! 545: return attr;
! 546: }
! 547:
! 548:
! 549: /* Make network statement's attribute. */
! 550: struct attr *
! 551: bgp_attr_default_intern (u_char origin)
! 552: {
! 553: struct attr attr;
! 554: struct attr *new;
! 555: struct attr_extra *attre;
! 556:
! 557: memset (&attr, 0, sizeof (struct attr));
! 558: attre = bgp_attr_extra_get (&attr);
! 559:
! 560: bgp_attr_default_set(&attr, origin);
! 561:
! 562: new = bgp_attr_intern (&attr);
! 563: bgp_attr_extra_free (&attr);
! 564:
! 565: aspath_unintern (&new->aspath);
! 566: return new;
! 567: }
! 568:
! 569: struct attr *
! 570: bgp_attr_aggregate_intern (struct bgp *bgp, u_char origin,
! 571: struct aspath *aspath,
! 572: struct community *community, int as_set)
! 573: {
! 574: struct attr attr;
! 575: struct attr *new;
! 576: struct attr_extra *attre;
! 577:
! 578: memset (&attr, 0, sizeof (struct attr));
! 579: attre = bgp_attr_extra_get (&attr);
! 580:
! 581: /* Origin attribute. */
! 582: attr.origin = origin;
! 583: attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
! 584:
! 585: /* AS path attribute. */
! 586: if (aspath)
! 587: attr.aspath = aspath_intern (aspath);
! 588: else
! 589: attr.aspath = aspath_empty ();
! 590: attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
! 591:
! 592: /* Next hop attribute. */
! 593: attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
! 594:
! 595: if (community)
! 596: {
! 597: attr.community = community;
! 598: attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES);
! 599: }
! 600:
! 601: attre->weight = BGP_ATTR_DEFAULT_WEIGHT;
! 602: #ifdef HAVE_IPV6
! 603: attre->mp_nexthop_len = IPV6_MAX_BYTELEN;
! 604: #endif
! 605: if (! as_set)
! 606: attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE);
! 607: attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR);
! 608: if (CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION))
! 609: attre->aggregator_as = bgp->confed_id;
! 610: else
! 611: attre->aggregator_as = bgp->as;
! 612: attre->aggregator_addr = bgp->router_id;
! 613:
! 614: new = bgp_attr_intern (&attr);
! 615: bgp_attr_extra_free (&attr);
! 616:
! 617: aspath_unintern (&new->aspath);
! 618: return new;
! 619: }
! 620:
! 621: /* Unintern just the sub-components of the attr, but not the attr */
! 622: void
! 623: bgp_attr_unintern_sub (struct attr *attr)
! 624: {
! 625: /* aspath refcount shoud be decrement. */
! 626: if (attr->aspath)
! 627: aspath_unintern (&attr->aspath);
! 628: UNSET_FLAG(attr->flag, BGP_ATTR_AS_PATH);
! 629:
! 630: if (attr->community)
! 631: community_unintern (&attr->community);
! 632: UNSET_FLAG(attr->flag, BGP_ATTR_COMMUNITIES);
! 633:
! 634: if (attr->extra)
! 635: {
! 636: if (attr->extra->ecommunity)
! 637: ecommunity_unintern (&attr->extra->ecommunity);
! 638: UNSET_FLAG(attr->flag, BGP_ATTR_EXT_COMMUNITIES);
! 639:
! 640: if (attr->extra->cluster)
! 641: cluster_unintern (attr->extra->cluster);
! 642: UNSET_FLAG(attr->flag, BGP_ATTR_CLUSTER_LIST);
! 643:
! 644: if (attr->extra->transit)
! 645: transit_unintern (attr->extra->transit);
! 646: }
! 647: }
! 648:
! 649: /* Free bgp attribute and aspath. */
! 650: void
! 651: bgp_attr_unintern (struct attr **attr)
! 652: {
! 653: struct attr *ret;
! 654: struct attr tmp;
! 655:
! 656: /* Decrement attribute reference. */
! 657: (*attr)->refcnt--;
! 658:
! 659: tmp = *(*attr);
! 660:
! 661: if ((*attr)->extra)
! 662: {
! 663: tmp.extra = bgp_attr_extra_new ();
! 664: memcpy (tmp.extra, (*attr)->extra, sizeof (struct attr_extra));
! 665: }
! 666:
! 667: /* If reference becomes zero then free attribute object. */
! 668: if ((*attr)->refcnt == 0)
! 669: {
! 670: ret = hash_release (attrhash, *attr);
! 671: assert (ret != NULL);
! 672: bgp_attr_extra_free (*attr);
! 673: XFREE (MTYPE_ATTR, *attr);
! 674: *attr = NULL;
! 675: }
! 676:
! 677: bgp_attr_unintern_sub (&tmp);
! 678: }
! 679:
! 680: void
! 681: bgp_attr_flush (struct attr *attr)
! 682: {
! 683: if (attr->aspath && ! attr->aspath->refcnt)
! 684: aspath_free (attr->aspath);
! 685: if (attr->community && ! attr->community->refcnt)
! 686: community_free (attr->community);
! 687: if (attr->extra)
! 688: {
! 689: struct attr_extra *attre = attr->extra;
! 690:
! 691: if (attre->ecommunity && ! attre->ecommunity->refcnt)
! 692: ecommunity_free (&attre->ecommunity);
! 693: if (attre->cluster && ! attre->cluster->refcnt)
! 694: cluster_free (attre->cluster);
! 695: if (attre->transit && ! attre->transit->refcnt)
! 696: transit_free (attre->transit);
! 697: }
! 698: }
! 699:
! 700: /* Implement draft-scudder-idr-optional-transitive behaviour and
! 701: * avoid resetting sessions for malformed attributes which are
! 702: * are partial/optional and hence where the error likely was not
! 703: * introduced by the sending neighbour.
! 704: */
! 705: static bgp_attr_parse_ret_t
! 706: bgp_attr_malformed (struct peer *peer, u_char type, u_char flag,
! 707: u_char subcode, u_char *startp, bgp_size_t length)
! 708: {
! 709: /* Only relax error handling for eBGP peers */
! 710: if (peer_sort (peer) != BGP_PEER_EBGP)
! 711: {
! 712: bgp_notify_send_with_data (peer, BGP_NOTIFY_UPDATE_ERR, subcode,
! 713: startp, length);
! 714: return BGP_ATTR_PARSE_ERROR;
! 715:
! 716: }
! 717:
! 718: switch (type) {
! 719: /* where an optional attribute is inconsequential, e.g. it does not affect
! 720: * route selection, and can be safely ignored then any such attributes
! 721: * which are malformed should just be ignored and the route processed as
! 722: * normal.
! 723: */
! 724: case BGP_ATTR_AS4_AGGREGATOR:
! 725: case BGP_ATTR_AGGREGATOR:
! 726: case BGP_ATTR_ATOMIC_AGGREGATE:
! 727: return BGP_ATTR_PARSE_PROCEED;
! 728:
! 729: /* Core attributes, particularly ones which may influence route
! 730: * selection should always cause session resets
! 731: */
! 732: case BGP_ATTR_ORIGIN:
! 733: case BGP_ATTR_AS_PATH:
! 734: case BGP_ATTR_NEXT_HOP:
! 735: case BGP_ATTR_MULTI_EXIT_DISC:
! 736: case BGP_ATTR_LOCAL_PREF:
! 737: case BGP_ATTR_COMMUNITIES:
! 738: case BGP_ATTR_ORIGINATOR_ID:
! 739: case BGP_ATTR_CLUSTER_LIST:
! 740: case BGP_ATTR_MP_REACH_NLRI:
! 741: case BGP_ATTR_MP_UNREACH_NLRI:
! 742: case BGP_ATTR_EXT_COMMUNITIES:
! 743: bgp_notify_send_with_data (peer, BGP_NOTIFY_UPDATE_ERR, subcode,
! 744: startp, length);
! 745: return BGP_ATTR_PARSE_ERROR;
! 746: }
! 747:
! 748: /* Partial optional attributes that are malformed should not cause
! 749: * the whole session to be reset. Instead treat it as a withdrawal
! 750: * of the routes, if possible.
! 751: */
! 752: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS)
! 753: && CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL)
! 754: && CHECK_FLAG (flag, BGP_ATTR_FLAG_PARTIAL))
! 755: return BGP_ATTR_PARSE_WITHDRAW;
! 756:
! 757: /* default to reset */
! 758: return BGP_ATTR_PARSE_ERROR;
! 759: }
! 760:
! 761: /* Get origin attribute of the update message. */
! 762: static bgp_attr_parse_ret_t
! 763: bgp_attr_origin (struct peer *peer, bgp_size_t length,
! 764: struct attr *attr, u_char flag, u_char *startp)
! 765: {
! 766: bgp_size_t total;
! 767:
! 768: /* total is entire attribute length include Attribute Flags (1),
! 769: Attribute Type code (1) and Attribute length (1 or 2). */
! 770: total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 771:
! 772: /* If any recognized attribute has Attribute Flags that conflict
! 773: with the Attribute Type Code, then the Error Subcode is set to
! 774: Attribute Flags Error. The Data field contains the erroneous
! 775: attribute (type, length and value). */
! 776: if (flag != BGP_ATTR_FLAG_TRANS)
! 777: {
! 778: zlog (peer->log, LOG_ERR,
! 779: "Origin attribute flag isn't transitive %d", flag);
! 780: return bgp_attr_malformed (peer, BGP_ATTR_ORIGIN, flag,
! 781: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 782: startp, total);
! 783: }
! 784:
! 785: /* If any recognized attribute has Attribute Length that conflicts
! 786: with the expected length (based on the attribute type code), then
! 787: the Error Subcode is set to Attribute Length Error. The Data
! 788: field contains the erroneous attribute (type, length and
! 789: value). */
! 790: if (length != 1)
! 791: {
! 792: zlog (peer->log, LOG_ERR, "Origin attribute length is not one %d",
! 793: length);
! 794: return bgp_attr_malformed (peer, BGP_ATTR_ORIGIN, flag,
! 795: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
! 796: startp, total);
! 797: }
! 798:
! 799: /* Fetch origin attribute. */
! 800: attr->origin = stream_getc (BGP_INPUT (peer));
! 801:
! 802: /* If the ORIGIN attribute has an undefined value, then the Error
! 803: Subcode is set to Invalid Origin Attribute. The Data field
! 804: contains the unrecognized attribute (type, length and value). */
! 805: if ((attr->origin != BGP_ORIGIN_IGP)
! 806: && (attr->origin != BGP_ORIGIN_EGP)
! 807: && (attr->origin != BGP_ORIGIN_INCOMPLETE))
! 808: {
! 809: zlog (peer->log, LOG_ERR, "Origin attribute value is invalid %d",
! 810: attr->origin);
! 811: return bgp_attr_malformed (peer, BGP_ATTR_ORIGIN, flag,
! 812: BGP_NOTIFY_UPDATE_INVAL_ORIGIN,
! 813: startp, total);
! 814: }
! 815:
! 816: /* Set oring attribute flag. */
! 817: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
! 818:
! 819: return 0;
! 820: }
! 821:
! 822: /* Parse AS path information. This function is wrapper of
! 823: aspath_parse. */
! 824: static int
! 825: bgp_attr_aspath (struct peer *peer, bgp_size_t length,
! 826: struct attr *attr, u_char flag, u_char *startp)
! 827: {
! 828: bgp_size_t total;
! 829:
! 830: total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 831:
! 832: /* Flag check. */
! 833: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL)
! 834: || ! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
! 835: {
! 836: zlog (peer->log, LOG_ERR,
! 837: "As-Path attribute flag isn't transitive %d", flag);
! 838: return bgp_attr_malformed (peer, BGP_ATTR_AS_PATH, flag,
! 839: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 840: startp, total);
! 841: }
! 842:
! 843: /*
! 844: * peer with AS4 => will get 4Byte ASnums
! 845: * otherwise, will get 16 Bit
! 846: */
! 847: attr->aspath = aspath_parse (peer->ibuf, length,
! 848: CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV));
! 849:
! 850: /* In case of IBGP, length will be zero. */
! 851: if (! attr->aspath)
! 852: {
! 853: zlog (peer->log, LOG_ERR,
! 854: "Malformed AS path from %s, length is %d",
! 855: peer->host, length);
! 856: return bgp_attr_malformed (peer, BGP_ATTR_AS_PATH, flag,
! 857: BGP_NOTIFY_UPDATE_MAL_AS_PATH,
! 858: NULL, 0);
! 859: }
! 860:
! 861: /* Set aspath attribute flag. */
! 862: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
! 863:
! 864: return BGP_ATTR_PARSE_PROCEED;
! 865: }
! 866:
! 867: static bgp_attr_parse_ret_t
! 868: bgp_attr_aspath_check (struct peer *peer, struct attr *attr, u_char flag)
! 869: {
! 870: /* These checks were part of bgp_attr_aspath, but with
! 871: * as4 we should to check aspath things when
! 872: * aspath synthesizing with as4_path has already taken place.
! 873: * Otherwise we check ASPATH and use the synthesized thing, and that is
! 874: * not right.
! 875: * So do the checks later, i.e. here
! 876: */
! 877: struct bgp *bgp = peer->bgp;
! 878: struct aspath *aspath;
! 879:
! 880: bgp = peer->bgp;
! 881:
! 882: /* Confederation sanity check. */
! 883: if ((peer_sort (peer) == BGP_PEER_CONFED && ! aspath_left_confed_check (attr->aspath)) ||
! 884: (peer_sort (peer) == BGP_PEER_EBGP && aspath_confed_check (attr->aspath)))
! 885: {
! 886: zlog (peer->log, LOG_ERR, "Malformed AS path from %s", peer->host);
! 887: return bgp_attr_malformed (peer, BGP_ATTR_AS_PATH, flag,
! 888: BGP_NOTIFY_UPDATE_MAL_AS_PATH,
! 889: NULL, 0);
! 890: }
! 891:
! 892: /* First AS check for EBGP. */
! 893: if (bgp != NULL && bgp_flag_check (bgp, BGP_FLAG_ENFORCE_FIRST_AS))
! 894: {
! 895: if (peer_sort (peer) == BGP_PEER_EBGP
! 896: && ! aspath_firstas_check (attr->aspath, peer->as))
! 897: {
! 898: zlog (peer->log, LOG_ERR,
! 899: "%s incorrect first AS (must be %u)", peer->host, peer->as);
! 900: return bgp_attr_malformed (peer, BGP_ATTR_AS_PATH, flag,
! 901: BGP_NOTIFY_UPDATE_MAL_AS_PATH,
! 902: NULL, 0);
! 903: }
! 904: }
! 905:
! 906: /* local-as prepend */
! 907: if (peer->change_local_as &&
! 908: ! CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND))
! 909: {
! 910: aspath = aspath_dup (attr->aspath);
! 911: aspath = aspath_add_seq (aspath, peer->change_local_as);
! 912: aspath_unintern (&attr->aspath);
! 913: attr->aspath = aspath_intern (aspath);
! 914: }
! 915:
! 916: return BGP_ATTR_PARSE_PROCEED;
! 917: }
! 918:
! 919: /* Parse AS4 path information. This function is another wrapper of
! 920: aspath_parse. */
! 921: static int
! 922: bgp_attr_as4_path (struct peer *peer, bgp_size_t length,
! 923: struct attr *attr, u_char flag, u_char *startp,
! 924: struct aspath **as4_path)
! 925: {
! 926: bgp_size_t total;
! 927:
! 928: total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 929:
! 930: /* Flag check. */
! 931: if (!CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL)
! 932: || !CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
! 933: {
! 934: zlog (peer->log, LOG_ERR,
! 935: "As4-Path attribute flag isn't optional/transitive %d", flag);
! 936: return bgp_attr_malformed (peer, BGP_ATTR_AS_PATH, flag,
! 937: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 938: startp, total);
! 939: }
! 940:
! 941: *as4_path = aspath_parse (peer->ibuf, length, 1);
! 942:
! 943: /* In case of IBGP, length will be zero. */
! 944: if (!*as4_path)
! 945: {
! 946: zlog (peer->log, LOG_ERR,
! 947: "Malformed AS4 path from %s, length is %d",
! 948: peer->host, length);
! 949: return bgp_attr_malformed (peer, BGP_ATTR_AS4_PATH, flag,
! 950: BGP_NOTIFY_UPDATE_MAL_AS_PATH,
! 951: NULL, 0);
! 952: }
! 953:
! 954: /* Set aspath attribute flag. */
! 955: if (as4_path)
! 956: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS4_PATH);
! 957:
! 958: return BGP_ATTR_PARSE_PROCEED;
! 959: }
! 960:
! 961: /* Nexthop attribute. */
! 962: static bgp_attr_parse_ret_t
! 963: bgp_attr_nexthop (struct peer *peer, bgp_size_t length,
! 964: struct attr *attr, u_char flag, u_char *startp)
! 965: {
! 966: bgp_size_t total;
! 967:
! 968: total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 969:
! 970: /* Flag check. */
! 971: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL)
! 972: || ! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
! 973: {
! 974: zlog (peer->log, LOG_ERR,
! 975: "Origin attribute flag isn't transitive %d", flag);
! 976: return bgp_attr_malformed (peer, BGP_ATTR_NEXT_HOP, flag,
! 977: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 978: startp, total);
! 979: }
! 980:
! 981: /* Check nexthop attribute length. */
! 982: if (length != 4)
! 983: {
! 984: zlog (peer->log, LOG_ERR, "Nexthop attribute length isn't four [%d]",
! 985: length);
! 986:
! 987: return bgp_attr_malformed (peer, BGP_ATTR_NEXT_HOP, flag,
! 988: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
! 989: startp, total);
! 990: }
! 991:
! 992: attr->nexthop.s_addr = stream_get_ipv4 (peer->ibuf);
! 993: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
! 994:
! 995: return BGP_ATTR_PARSE_PROCEED;
! 996: }
! 997:
! 998: /* MED atrribute. */
! 999: static bgp_attr_parse_ret_t
! 1000: bgp_attr_med (struct peer *peer, bgp_size_t length,
! 1001: struct attr *attr, u_char flag, u_char *startp)
! 1002: {
! 1003: bgp_size_t total;
! 1004:
! 1005: total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 1006:
! 1007: /* Flag checks. */
! 1008: if (! CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL))
! 1009: {
! 1010: zlog (peer->log, LOG_ERR,
! 1011: "MULTI_EXIT_DISC attribute must be flagged as \"optional\" (%u)", flag);
! 1012: bgp_notify_send_with_data (peer,
! 1013: BGP_NOTIFY_UPDATE_ERR,
! 1014: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 1015: startp, total);
! 1016: return -1;
! 1017: }
! 1018: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
! 1019: {
! 1020: zlog (peer->log, LOG_ERR,
! 1021: "MULTI_EXIT_DISC attribute must not be flagged as \"transitive\" (%u)", flag);
! 1022: bgp_notify_send_with_data (peer,
! 1023: BGP_NOTIFY_UPDATE_ERR,
! 1024: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 1025: startp, total);
! 1026: return -1;
! 1027: }
! 1028: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_PARTIAL))
! 1029: {
! 1030: zlog (peer->log, LOG_ERR,
! 1031: "MULTI_EXIT_DISC attribute must not be flagged as \"partial\" (%u)", flag);
! 1032: bgp_notify_send_with_data (peer,
! 1033: BGP_NOTIFY_UPDATE_ERR,
! 1034: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 1035: startp, total);
! 1036: return -1;
! 1037: }
! 1038:
! 1039: /* Length check. */
! 1040: if (length != 4)
! 1041: {
! 1042: zlog (peer->log, LOG_ERR,
! 1043: "MED attribute length isn't four [%d]", length);
! 1044:
! 1045: return bgp_attr_malformed (peer, BGP_ATTR_MULTI_EXIT_DISC, flag,
! 1046: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
! 1047: startp, total);
! 1048: }
! 1049:
! 1050: attr->med = stream_getl (peer->ibuf);
! 1051:
! 1052: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC);
! 1053:
! 1054: return BGP_ATTR_PARSE_PROCEED;
! 1055: }
! 1056:
! 1057: /* Local preference attribute. */
! 1058: static bgp_attr_parse_ret_t
! 1059: bgp_attr_local_pref (struct peer *peer, bgp_size_t length,
! 1060: struct attr *attr, u_char flag, u_char *startp)
! 1061: {
! 1062: bgp_size_t total;
! 1063:
! 1064: total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 1065: /* Flag checks. */
! 1066: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL))
! 1067: {
! 1068: zlog (peer->log, LOG_ERR,
! 1069: "LOCAL_PREF attribute must be flagged as \"well-known\" (%u)", flag);
! 1070: bgp_notify_send_with_data (peer,
! 1071: BGP_NOTIFY_UPDATE_ERR,
! 1072: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 1073: startp, total);
! 1074: return -1;
! 1075: }
! 1076: if (! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
! 1077: {
! 1078: zlog (peer->log, LOG_ERR,
! 1079: "LOCAL_PREF attribute must be flagged as \"transitive\" (%u)", flag);
! 1080: bgp_notify_send_with_data (peer,
! 1081: BGP_NOTIFY_UPDATE_ERR,
! 1082: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 1083: startp, total);
! 1084: return -1;
! 1085: }
! 1086:
! 1087: /* If it is contained in an UPDATE message that is received from an
! 1088: external peer, then this attribute MUST be ignored by the
! 1089: receiving speaker. */
! 1090: if (peer_sort (peer) == BGP_PEER_EBGP)
! 1091: {
! 1092: stream_forward_getp (peer->ibuf, length);
! 1093: return BGP_ATTR_PARSE_PROCEED;
! 1094: }
! 1095:
! 1096: if (length == 4)
! 1097: attr->local_pref = stream_getl (peer->ibuf);
! 1098: else
! 1099: attr->local_pref = 0;
! 1100:
! 1101: /* Set atomic aggregate flag. */
! 1102: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF);
! 1103:
! 1104: return BGP_ATTR_PARSE_PROCEED;
! 1105: }
! 1106:
! 1107: /* Atomic aggregate. */
! 1108: static int
! 1109: bgp_attr_atomic (struct peer *peer, bgp_size_t length,
! 1110: struct attr *attr, u_char flag, u_char *startp)
! 1111: {
! 1112: bgp_size_t total;
! 1113:
! 1114: total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 1115: /* Flag checks. */
! 1116: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL))
! 1117: {
! 1118: zlog (peer->log, LOG_ERR,
! 1119: "ATOMIC_AGGREGATE attribute must not be flagged as \"optional\" (%u)", flag);
! 1120: bgp_notify_send_with_data (peer,
! 1121: BGP_NOTIFY_UPDATE_ERR,
! 1122: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 1123: startp, total);
! 1124: return -1;
! 1125: }
! 1126: if (! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
! 1127: {
! 1128: zlog (peer->log, LOG_ERR,
! 1129: "ATOMIC_AGGREGATE attribute must be flagged as \"transitive\" (%u)", flag);
! 1130: bgp_notify_send_with_data (peer,
! 1131: BGP_NOTIFY_UPDATE_ERR,
! 1132: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 1133: startp, total);
! 1134: return -1;
! 1135: }
! 1136: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_PARTIAL))
! 1137: {
! 1138: zlog (peer->log, LOG_ERR,
! 1139: "ATOMIC_AGGREGATE attribute must not be flagged as \"partial\" (%u)", flag);
! 1140: bgp_notify_send_with_data (peer,
! 1141: BGP_NOTIFY_UPDATE_ERR,
! 1142: BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
! 1143: startp, total);
! 1144: return -1;
! 1145: }
! 1146:
! 1147: /* Length check. */
! 1148: if (length != 0)
! 1149: {
! 1150: zlog (peer->log, LOG_ERR, "Bad atomic aggregate length %d", length);
! 1151:
! 1152: return bgp_attr_malformed (peer, BGP_ATTR_ATOMIC_AGGREGATE, flag,
! 1153: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
! 1154: NULL, 0);
! 1155: }
! 1156:
! 1157: /* Set atomic aggregate flag. */
! 1158: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE);
! 1159:
! 1160: return BGP_ATTR_PARSE_PROCEED;
! 1161: }
! 1162:
! 1163: /* Aggregator attribute */
! 1164: static int
! 1165: bgp_attr_aggregator (struct peer *peer, bgp_size_t length,
! 1166: struct attr *attr, u_char flag)
! 1167: {
! 1168: int wantedlen = 6;
! 1169: struct attr_extra *attre = bgp_attr_extra_get (attr);
! 1170:
! 1171: /* peer with AS4 will send 4 Byte AS, peer without will send 2 Byte */
! 1172: if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV))
! 1173: wantedlen = 8;
! 1174:
! 1175: if (length != wantedlen)
! 1176: {
! 1177: zlog (peer->log, LOG_ERR, "Aggregator length is not %d [%d]", wantedlen, length);
! 1178:
! 1179: return bgp_attr_malformed (peer, BGP_ATTR_AGGREGATOR, flag,
! 1180: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
! 1181: NULL, 0);
! 1182: }
! 1183:
! 1184: if ( CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV ) )
! 1185: attre->aggregator_as = stream_getl (peer->ibuf);
! 1186: else
! 1187: attre->aggregator_as = stream_getw (peer->ibuf);
! 1188: attre->aggregator_addr.s_addr = stream_get_ipv4 (peer->ibuf);
! 1189:
! 1190: /* Set atomic aggregate flag. */
! 1191: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR);
! 1192:
! 1193: return BGP_ATTR_PARSE_PROCEED;
! 1194: }
! 1195:
! 1196: /* New Aggregator attribute */
! 1197: static bgp_attr_parse_ret_t
! 1198: bgp_attr_as4_aggregator (struct peer *peer, bgp_size_t length,
! 1199: struct attr *attr, u_char flag,
! 1200: as_t *as4_aggregator_as,
! 1201: struct in_addr *as4_aggregator_addr)
! 1202: {
! 1203: if (length != 8)
! 1204: {
! 1205: zlog (peer->log, LOG_ERR, "New Aggregator length is not 8 [%d]", length);
! 1206: return bgp_attr_malformed (peer, BGP_ATTR_AS4_AGGREGATOR, flag,
! 1207: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
! 1208: NULL, 0);
! 1209: }
! 1210: *as4_aggregator_as = stream_getl (peer->ibuf);
! 1211: as4_aggregator_addr->s_addr = stream_get_ipv4 (peer->ibuf);
! 1212:
! 1213: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS4_AGGREGATOR);
! 1214:
! 1215: return BGP_ATTR_PARSE_PROCEED;
! 1216: }
! 1217:
! 1218: /* Munge Aggregator and New-Aggregator, AS_PATH and NEW_AS_PATH.
! 1219: */
! 1220: static bgp_attr_parse_ret_t
! 1221: bgp_attr_munge_as4_attrs (struct peer *peer, struct attr *attr, u_char flag,
! 1222: struct aspath *as4_path, as_t as4_aggregator,
! 1223: struct in_addr *as4_aggregator_addr)
! 1224: {
! 1225: int ignore_as4_path = 0;
! 1226: struct aspath *newpath;
! 1227: struct attr_extra *attre = attr->extra;
! 1228:
! 1229: if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV))
! 1230: {
! 1231: /* peer can do AS4, so we ignore AS4_PATH and AS4_AGGREGATOR
! 1232: * if given.
! 1233: * It is worth a warning though, because the peer really
! 1234: * should not send them
! 1235: */
! 1236: if (BGP_DEBUG(as4, AS4))
! 1237: {
! 1238: if (attr->flag & (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH)))
! 1239: zlog_debug ("[AS4] %s %s AS4_PATH",
! 1240: peer->host, "AS4 capable peer, yet it sent");
! 1241:
! 1242: if (attr->flag & (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR)))
! 1243: zlog_debug ("[AS4] %s %s AS4_AGGREGATOR",
! 1244: peer->host, "AS4 capable peer, yet it sent");
! 1245: }
! 1246:
! 1247: return BGP_ATTR_PARSE_PROCEED;
! 1248: }
! 1249:
! 1250: if (attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AS4_PATH))
! 1251: && !(attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AS_PATH))))
! 1252: {
! 1253: /* Hu? This is not supposed to happen at all!
! 1254: * got as4_path and no aspath,
! 1255: * This should already
! 1256: * have been handled by 'well known attributes missing'
! 1257: * But... yeah, paranoia
! 1258: * Take this as a "malformed attribute"
! 1259: */
! 1260: zlog (peer->log, LOG_ERR,
! 1261: "%s BGP not AS4 capable peer sent AS4_PATH but"
! 1262: " no AS_PATH, cant do anything here", peer->host);
! 1263: return bgp_attr_malformed (peer, BGP_ATTR_AS_PATH, flag,
! 1264: BGP_NOTIFY_UPDATE_MAL_ATTR,
! 1265: NULL, 0);
! 1266: }
! 1267:
! 1268: /* We have a asn16 peer. First, look for AS4_AGGREGATOR
! 1269: * because that may override AS4_PATH
! 1270: */
! 1271: if (attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AS4_AGGREGATOR) ) )
! 1272: {
! 1273: if (attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR) ) )
! 1274: {
! 1275: assert (attre);
! 1276:
! 1277: /* received both.
! 1278: * if the as_number in aggregator is not AS_TRANS,
! 1279: * then AS4_AGGREGATOR and AS4_PATH shall be ignored
! 1280: * and the Aggregator shall be taken as
! 1281: * info on the aggregating node, and the AS_PATH
! 1282: * shall be taken as the AS_PATH
! 1283: * otherwise
! 1284: * the Aggregator shall be ignored and the
! 1285: * AS4_AGGREGATOR shall be taken as the
! 1286: * Aggregating node and the AS_PATH is to be
! 1287: * constructed "as in all other cases"
! 1288: */
! 1289: if (attre->aggregator_as != BGP_AS_TRANS)
! 1290: {
! 1291: /* ignore */
! 1292: if ( BGP_DEBUG(as4, AS4))
! 1293: zlog_debug ("[AS4] %s BGP not AS4 capable peer"
! 1294: " send AGGREGATOR != AS_TRANS and"
! 1295: " AS4_AGGREGATOR, so ignore"
! 1296: " AS4_AGGREGATOR and AS4_PATH", peer->host);
! 1297: ignore_as4_path = 1;
! 1298: }
! 1299: else
! 1300: {
! 1301: /* "New_aggregator shall be taken as aggregator" */
! 1302: attre->aggregator_as = as4_aggregator;
! 1303: attre->aggregator_addr.s_addr = as4_aggregator_addr->s_addr;
! 1304: }
! 1305: }
! 1306: else
! 1307: {
! 1308: /* We received a AS4_AGGREGATOR but no AGGREGATOR.
! 1309: * That is bogus - but reading the conditions
! 1310: * we have to handle AS4_AGGREGATOR as if it were
! 1311: * AGGREGATOR in that case
! 1312: */
! 1313: if ( BGP_DEBUG(as4, AS4))
! 1314: zlog_debug ("[AS4] %s BGP not AS4 capable peer send"
! 1315: " AS4_AGGREGATOR but no AGGREGATOR, will take"
! 1316: " it as if AGGREGATOR with AS_TRANS had been there", peer->host);
! 1317: (attre = bgp_attr_extra_get (attr))->aggregator_as = as4_aggregator;
! 1318: /* sweep it under the carpet and simulate a "good" AGGREGATOR */
! 1319: attr->flag |= (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR));
! 1320: }
! 1321: }
! 1322:
! 1323: /* need to reconcile NEW_AS_PATH and AS_PATH */
! 1324: if (!ignore_as4_path && (attr->flag & (ATTR_FLAG_BIT( BGP_ATTR_AS4_PATH))))
! 1325: {
! 1326: newpath = aspath_reconcile_as4 (attr->aspath, as4_path);
! 1327: aspath_unintern (&attr->aspath);
! 1328: attr->aspath = aspath_intern (newpath);
! 1329: }
! 1330: return BGP_ATTR_PARSE_PROCEED;
! 1331: }
! 1332:
! 1333: /* Community attribute. */
! 1334: static bgp_attr_parse_ret_t
! 1335: bgp_attr_community (struct peer *peer, bgp_size_t length,
! 1336: struct attr *attr, u_char flag, u_char *startp)
! 1337: {
! 1338: bgp_size_t total
! 1339: = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 1340:
! 1341: if (length == 0)
! 1342: {
! 1343: attr->community = NULL;
! 1344: return BGP_ATTR_PARSE_PROCEED;
! 1345: }
! 1346:
! 1347: attr->community =
! 1348: community_parse ((u_int32_t *)stream_pnt (peer->ibuf), length);
! 1349:
! 1350: /* XXX: fix community_parse to use stream API and remove this */
! 1351: stream_forward_getp (peer->ibuf, length);
! 1352:
! 1353: if (!attr->community)
! 1354: return bgp_attr_malformed (peer, BGP_ATTR_COMMUNITIES, flag,
! 1355: BGP_NOTIFY_UPDATE_OPT_ATTR_ERR,
! 1356: startp, total);
! 1357:
! 1358: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES);
! 1359:
! 1360: return BGP_ATTR_PARSE_PROCEED;
! 1361: }
! 1362:
! 1363: /* Originator ID attribute. */
! 1364: static bgp_attr_parse_ret_t
! 1365: bgp_attr_originator_id (struct peer *peer, bgp_size_t length,
! 1366: struct attr *attr, u_char flag)
! 1367: {
! 1368: if (length != 4)
! 1369: {
! 1370: zlog (peer->log, LOG_ERR, "Bad originator ID length %d", length);
! 1371:
! 1372: return bgp_attr_malformed (peer, BGP_ATTR_ORIGINATOR_ID, flag,
! 1373: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
! 1374: NULL, 0);
! 1375: }
! 1376:
! 1377: (bgp_attr_extra_get (attr))->originator_id.s_addr
! 1378: = stream_get_ipv4 (peer->ibuf);
! 1379:
! 1380: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID);
! 1381:
! 1382: return BGP_ATTR_PARSE_PROCEED;
! 1383: }
! 1384:
! 1385: /* Cluster list attribute. */
! 1386: static bgp_attr_parse_ret_t
! 1387: bgp_attr_cluster_list (struct peer *peer, bgp_size_t length,
! 1388: struct attr *attr, u_char flag)
! 1389: {
! 1390: /* Check length. */
! 1391: if (length % 4)
! 1392: {
! 1393: zlog (peer->log, LOG_ERR, "Bad cluster list length %d", length);
! 1394:
! 1395: return bgp_attr_malformed (peer, BGP_ATTR_CLUSTER_LIST, flag,
! 1396: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
! 1397: NULL, 0);
! 1398: }
! 1399:
! 1400: (bgp_attr_extra_get (attr))->cluster
! 1401: = cluster_parse ((struct in_addr *)stream_pnt (peer->ibuf), length);
! 1402:
! 1403: /* XXX: Fix cluster_parse to use stream API and then remove this */
! 1404: stream_forward_getp (peer->ibuf, length);
! 1405:
! 1406: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST);
! 1407:
! 1408: return BGP_ATTR_PARSE_PROCEED;
! 1409: }
! 1410:
! 1411: /* Multiprotocol reachability information parse. */
! 1412: int
! 1413: bgp_mp_reach_parse (struct peer *peer, bgp_size_t length, struct attr *attr,
! 1414: struct bgp_nlri *mp_update)
! 1415: {
! 1416: afi_t afi;
! 1417: safi_t safi;
! 1418: bgp_size_t nlri_len;
! 1419: size_t start;
! 1420: int ret;
! 1421: struct stream *s;
! 1422: struct attr_extra *attre = bgp_attr_extra_get(attr);
! 1423:
! 1424: /* Set end of packet. */
! 1425: s = BGP_INPUT(peer);
! 1426: start = stream_get_getp(s);
! 1427:
! 1428: /* safe to read statically sized header? */
! 1429: #define BGP_MP_REACH_MIN_SIZE 5
! 1430: #define LEN_LEFT (length - (stream_get_getp(s) - start))
! 1431: if ((length > STREAM_READABLE(s)) || (length < BGP_MP_REACH_MIN_SIZE))
! 1432: {
! 1433: zlog_info ("%s: %s sent invalid length, %lu",
! 1434: __func__, peer->host, (unsigned long)length);
! 1435: return BGP_ATTR_PARSE_ERROR;
! 1436: }
! 1437:
! 1438: /* Load AFI, SAFI. */
! 1439: afi = stream_getw (s);
! 1440: safi = stream_getc (s);
! 1441:
! 1442: /* Get nexthop length. */
! 1443: attre->mp_nexthop_len = stream_getc (s);
! 1444:
! 1445: if (LEN_LEFT < attre->mp_nexthop_len)
! 1446: {
! 1447: zlog_info ("%s: %s, MP nexthop length, %u, goes past end of attribute",
! 1448: __func__, peer->host, attre->mp_nexthop_len);
! 1449: return BGP_ATTR_PARSE_ERROR;
! 1450: }
! 1451:
! 1452: /* Nexthop length check. */
! 1453: switch (attre->mp_nexthop_len)
! 1454: {
! 1455: case 4:
! 1456: stream_get (&attre->mp_nexthop_global_in, s, 4);
! 1457: /* Probably needed for RFC 2283 */
! 1458: if (attr->nexthop.s_addr == 0)
! 1459: memcpy(&attr->nexthop.s_addr, &attre->mp_nexthop_global_in, 4);
! 1460: break;
! 1461: case 12:
! 1462: {
! 1463: u_int32_t rd_high;
! 1464: u_int32_t rd_low;
! 1465:
! 1466: rd_high = stream_getl (s);
! 1467: rd_low = stream_getl (s);
! 1468: stream_get (&attre->mp_nexthop_global_in, s, 4);
! 1469: }
! 1470: break;
! 1471: #ifdef HAVE_IPV6
! 1472: case 16:
! 1473: stream_get (&attre->mp_nexthop_global, s, 16);
! 1474: break;
! 1475: case 32:
! 1476: stream_get (&attre->mp_nexthop_global, s, 16);
! 1477: stream_get (&attre->mp_nexthop_local, s, 16);
! 1478: if (! IN6_IS_ADDR_LINKLOCAL (&attre->mp_nexthop_local))
! 1479: {
! 1480: char buf1[INET6_ADDRSTRLEN];
! 1481: char buf2[INET6_ADDRSTRLEN];
! 1482:
! 1483: if (BGP_DEBUG (update, UPDATE_IN))
! 1484: zlog_debug ("%s got two nexthop %s %s but second one is not a link-local nexthop", peer->host,
! 1485: inet_ntop (AF_INET6, &attre->mp_nexthop_global,
! 1486: buf1, INET6_ADDRSTRLEN),
! 1487: inet_ntop (AF_INET6, &attre->mp_nexthop_local,
! 1488: buf2, INET6_ADDRSTRLEN));
! 1489:
! 1490: attre->mp_nexthop_len = 16;
! 1491: }
! 1492: break;
! 1493: #endif /* HAVE_IPV6 */
! 1494: default:
! 1495: zlog_info ("%s: (%s) Wrong multiprotocol next hop length: %d",
! 1496: __func__, peer->host, attre->mp_nexthop_len);
! 1497: return BGP_ATTR_PARSE_ERROR;
! 1498: }
! 1499:
! 1500: if (!LEN_LEFT)
! 1501: {
! 1502: zlog_info ("%s: (%s) Failed to read SNPA and NLRI(s)",
! 1503: __func__, peer->host);
! 1504: return BGP_ATTR_PARSE_ERROR;
! 1505: }
! 1506:
! 1507: {
! 1508: u_char val;
! 1509: if ((val = stream_getc (s)))
! 1510: zlog_warn ("%s sent non-zero value, %u, for defunct SNPA-length field",
! 1511: peer->host, val);
! 1512: }
! 1513:
! 1514: /* must have nrli_len, what is left of the attribute */
! 1515: nlri_len = LEN_LEFT;
! 1516: if ((!nlri_len) || (nlri_len > STREAM_READABLE(s)))
! 1517: {
! 1518: zlog_info ("%s: (%s) Failed to read NLRI",
! 1519: __func__, peer->host);
! 1520: return BGP_ATTR_PARSE_ERROR;
! 1521: }
! 1522:
! 1523: if (safi != BGP_SAFI_VPNV4)
! 1524: {
! 1525: ret = bgp_nlri_sanity_check (peer, afi, stream_pnt (s), nlri_len);
! 1526: if (ret < 0)
! 1527: {
! 1528: zlog_info ("%s: (%s) NLRI doesn't pass sanity check",
! 1529: __func__, peer->host);
! 1530: return BGP_ATTR_PARSE_ERROR;
! 1531: }
! 1532: }
! 1533:
! 1534: mp_update->afi = afi;
! 1535: mp_update->safi = safi;
! 1536: mp_update->nlri = stream_pnt (s);
! 1537: mp_update->length = nlri_len;
! 1538:
! 1539: stream_forward_getp (s, nlri_len);
! 1540:
! 1541: return BGP_ATTR_PARSE_PROCEED;
! 1542: #undef LEN_LEFT
! 1543: }
! 1544:
! 1545: /* Multiprotocol unreachable parse */
! 1546: int
! 1547: bgp_mp_unreach_parse (struct peer *peer, bgp_size_t length,
! 1548: struct bgp_nlri *mp_withdraw)
! 1549: {
! 1550: struct stream *s;
! 1551: afi_t afi;
! 1552: safi_t safi;
! 1553: u_int16_t withdraw_len;
! 1554: int ret;
! 1555:
! 1556: s = peer->ibuf;
! 1557:
! 1558: #define BGP_MP_UNREACH_MIN_SIZE 3
! 1559: if ((length > STREAM_READABLE(s)) || (length < BGP_MP_UNREACH_MIN_SIZE))
! 1560: return BGP_ATTR_PARSE_ERROR;
! 1561:
! 1562: afi = stream_getw (s);
! 1563: safi = stream_getc (s);
! 1564:
! 1565: withdraw_len = length - BGP_MP_UNREACH_MIN_SIZE;
! 1566:
! 1567: if (safi != BGP_SAFI_VPNV4)
! 1568: {
! 1569: ret = bgp_nlri_sanity_check (peer, afi, stream_pnt (s), withdraw_len);
! 1570: if (ret < 0)
! 1571: return BGP_ATTR_PARSE_ERROR;
! 1572: }
! 1573:
! 1574: mp_withdraw->afi = afi;
! 1575: mp_withdraw->safi = safi;
! 1576: mp_withdraw->nlri = stream_pnt (s);
! 1577: mp_withdraw->length = withdraw_len;
! 1578:
! 1579: stream_forward_getp (s, withdraw_len);
! 1580:
! 1581: return BGP_ATTR_PARSE_PROCEED;
! 1582: }
! 1583:
! 1584: /* Extended Community attribute. */
! 1585: static bgp_attr_parse_ret_t
! 1586: bgp_attr_ext_communities (struct peer *peer, bgp_size_t length,
! 1587: struct attr *attr, u_char flag, u_char *startp)
! 1588: {
! 1589: bgp_size_t total
! 1590: = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 1591:
! 1592: if (length == 0)
! 1593: {
! 1594: if (attr->extra)
! 1595: attr->extra->ecommunity = NULL;
! 1596: /* Empty extcomm doesn't seem to be invalid per se */
! 1597: return BGP_ATTR_PARSE_PROCEED;
! 1598: }
! 1599:
! 1600: (bgp_attr_extra_get (attr))->ecommunity =
! 1601: ecommunity_parse ((u_int8_t *)stream_pnt (peer->ibuf), length);
! 1602: /* XXX: fix ecommunity_parse to use stream API */
! 1603: stream_forward_getp (peer->ibuf, length);
! 1604:
! 1605: if (!attr->extra->ecommunity)
! 1606: return bgp_attr_malformed (peer, BGP_ATTR_EXT_COMMUNITIES,
! 1607: flag, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR,
! 1608: startp, total);
! 1609:
! 1610: attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES);
! 1611:
! 1612: return BGP_ATTR_PARSE_PROCEED;
! 1613: }
! 1614:
! 1615: /* BGP unknown attribute treatment. */
! 1616: static bgp_attr_parse_ret_t
! 1617: bgp_attr_unknown (struct peer *peer, struct attr *attr, u_char flag,
! 1618: u_char type, bgp_size_t length, u_char *startp)
! 1619: {
! 1620: bgp_size_t total;
! 1621: struct transit *transit;
! 1622: struct attr_extra *attre;
! 1623:
! 1624: if (BGP_DEBUG (normal, NORMAL))
! 1625: zlog_debug ("%s Unknown attribute is received (type %d, length %d)",
! 1626: peer->host, type, length);
! 1627:
! 1628: if (BGP_DEBUG (events, EVENTS))
! 1629: zlog (peer->log, LOG_DEBUG,
! 1630: "Unknown attribute type %d length %d is received", type, length);
! 1631:
! 1632: /* Forward read pointer of input stream. */
! 1633: stream_forward_getp (peer->ibuf, length);
! 1634:
! 1635: /* Adjest total length to include type and length. */
! 1636: total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
! 1637:
! 1638: /* If any of the mandatory well-known attributes are not recognized,
! 1639: then the Error Subcode is set to Unrecognized Well-known
! 1640: Attribute. The Data field contains the unrecognized attribute
! 1641: (type, length and value). */
! 1642: if (!CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL))
! 1643: {
! 1644: return bgp_attr_malformed (peer, type, flag,
! 1645: BGP_NOTIFY_UPDATE_UNREC_ATTR,
! 1646: startp, total);
! 1647: }
! 1648:
! 1649: /* Unrecognized non-transitive optional attributes must be quietly
! 1650: ignored and not passed along to other BGP peers. */
! 1651: if (! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
! 1652: return BGP_ATTR_PARSE_PROCEED;
! 1653:
! 1654: /* If a path with recognized transitive optional attribute is
! 1655: accepted and passed along to other BGP peers and the Partial bit
! 1656: in the Attribute Flags octet is set to 1 by some previous AS, it
! 1657: is not set back to 0 by the current AS. */
! 1658: SET_FLAG (*startp, BGP_ATTR_FLAG_PARTIAL);
! 1659:
! 1660: /* Store transitive attribute to the end of attr->transit. */
! 1661: if (! ((attre = bgp_attr_extra_get(attr))->transit) )
! 1662: attre->transit = XCALLOC (MTYPE_TRANSIT, sizeof (struct transit));
! 1663:
! 1664: transit = attre->transit;
! 1665:
! 1666: if (transit->val)
! 1667: transit->val = XREALLOC (MTYPE_TRANSIT_VAL, transit->val,
! 1668: transit->length + total);
! 1669: else
! 1670: transit->val = XMALLOC (MTYPE_TRANSIT_VAL, total);
! 1671:
! 1672: memcpy (transit->val + transit->length, startp, total);
! 1673: transit->length += total;
! 1674:
! 1675: return BGP_ATTR_PARSE_PROCEED;
! 1676: }
! 1677:
! 1678: /* Read attribute of update packet. This function is called from
! 1679: bgp_update() in bgpd.c. */
! 1680: bgp_attr_parse_ret_t
! 1681: bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size,
! 1682: struct bgp_nlri *mp_update, struct bgp_nlri *mp_withdraw)
! 1683: {
! 1684: int ret;
! 1685: u_char flag = 0;
! 1686: u_char type = 0;
! 1687: bgp_size_t length;
! 1688: u_char *startp, *endp;
! 1689: u_char *attr_endp;
! 1690: u_char seen[BGP_ATTR_BITMAP_SIZE];
! 1691: /* we need the as4_path only until we have synthesized the as_path with it */
! 1692: /* same goes for as4_aggregator */
! 1693: struct aspath *as4_path = NULL;
! 1694: as_t as4_aggregator = 0;
! 1695: struct in_addr as4_aggregator_addr = { 0 };
! 1696:
! 1697: /* Initialize bitmap. */
! 1698: memset (seen, 0, BGP_ATTR_BITMAP_SIZE);
! 1699:
! 1700: /* End pointer of BGP attribute. */
! 1701: endp = BGP_INPUT_PNT (peer) + size;
! 1702:
! 1703: /* Get attributes to the end of attribute length. */
! 1704: while (BGP_INPUT_PNT (peer) < endp)
! 1705: {
! 1706: /* Check remaining length check.*/
! 1707: if (endp - BGP_INPUT_PNT (peer) < BGP_ATTR_MIN_LEN)
! 1708: {
! 1709: /* XXX warning: long int format, int arg (arg 5) */
! 1710: zlog (peer->log, LOG_WARNING,
! 1711: "%s: error BGP attribute length %lu is smaller than min len",
! 1712: peer->host,
! 1713: (unsigned long) (endp - STREAM_PNT (BGP_INPUT (peer))));
! 1714:
! 1715: bgp_notify_send (peer,
! 1716: BGP_NOTIFY_UPDATE_ERR,
! 1717: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
! 1718: return BGP_ATTR_PARSE_ERROR;
! 1719: }
! 1720:
! 1721: /* Fetch attribute flag and type. */
! 1722: startp = BGP_INPUT_PNT (peer);
! 1723: flag = stream_getc (BGP_INPUT (peer));
! 1724: type = stream_getc (BGP_INPUT (peer));
! 1725:
! 1726: /* Check whether Extended-Length applies and is in bounds */
! 1727: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN)
! 1728: && ((endp - startp) < (BGP_ATTR_MIN_LEN + 1)))
! 1729: {
! 1730: zlog (peer->log, LOG_WARNING,
! 1731: "%s: Extended length set, but just %lu bytes of attr header",
! 1732: peer->host,
! 1733: (unsigned long) (endp - STREAM_PNT (BGP_INPUT (peer))));
! 1734:
! 1735: bgp_notify_send (peer,
! 1736: BGP_NOTIFY_UPDATE_ERR,
! 1737: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
! 1738: return BGP_ATTR_PARSE_ERROR;
! 1739: }
! 1740:
! 1741: /* Check extended attribue length bit. */
! 1742: if (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN))
! 1743: length = stream_getw (BGP_INPUT (peer));
! 1744: else
! 1745: length = stream_getc (BGP_INPUT (peer));
! 1746:
! 1747: /* If any attribute appears more than once in the UPDATE
! 1748: message, then the Error Subcode is set to Malformed Attribute
! 1749: List. */
! 1750:
! 1751: if (CHECK_BITMAP (seen, type))
! 1752: {
! 1753: zlog (peer->log, LOG_WARNING,
! 1754: "%s: error BGP attribute type %d appears twice in a message",
! 1755: peer->host, type);
! 1756:
! 1757: bgp_notify_send (peer,
! 1758: BGP_NOTIFY_UPDATE_ERR,
! 1759: BGP_NOTIFY_UPDATE_MAL_ATTR);
! 1760: return BGP_ATTR_PARSE_ERROR;
! 1761: }
! 1762:
! 1763: /* Set type to bitmap to check duplicate attribute. `type' is
! 1764: unsigned char so it never overflow bitmap range. */
! 1765:
! 1766: SET_BITMAP (seen, type);
! 1767:
! 1768: /* Overflow check. */
! 1769: attr_endp = BGP_INPUT_PNT (peer) + length;
! 1770:
! 1771: if (attr_endp > endp)
! 1772: {
! 1773: zlog (peer->log, LOG_WARNING,
! 1774: "%s: BGP type %d length %d is too large, attribute total length is %d. attr_endp is %p. endp is %p", peer->host, type, length, size, attr_endp, endp);
! 1775: bgp_notify_send (peer,
! 1776: BGP_NOTIFY_UPDATE_ERR,
! 1777: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
! 1778: return BGP_ATTR_PARSE_ERROR;
! 1779: }
! 1780:
! 1781: /* OK check attribute and store it's value. */
! 1782: switch (type)
! 1783: {
! 1784: case BGP_ATTR_ORIGIN:
! 1785: ret = bgp_attr_origin (peer, length, attr, flag, startp);
! 1786: break;
! 1787: case BGP_ATTR_AS_PATH:
! 1788: ret = bgp_attr_aspath (peer, length, attr, flag, startp);
! 1789: break;
! 1790: case BGP_ATTR_AS4_PATH:
! 1791: ret = bgp_attr_as4_path (peer, length, attr, flag, startp, &as4_path);
! 1792: break;
! 1793: case BGP_ATTR_NEXT_HOP:
! 1794: ret = bgp_attr_nexthop (peer, length, attr, flag, startp);
! 1795: break;
! 1796: case BGP_ATTR_MULTI_EXIT_DISC:
! 1797: ret = bgp_attr_med (peer, length, attr, flag, startp);
! 1798: break;
! 1799: case BGP_ATTR_LOCAL_PREF:
! 1800: ret = bgp_attr_local_pref (peer, length, attr, flag, startp);
! 1801: break;
! 1802: case BGP_ATTR_ATOMIC_AGGREGATE:
! 1803: ret = bgp_attr_atomic (peer, length, attr, flag, startp);
! 1804: break;
! 1805: case BGP_ATTR_AGGREGATOR:
! 1806: ret = bgp_attr_aggregator (peer, length, attr, flag);
! 1807: break;
! 1808: case BGP_ATTR_AS4_AGGREGATOR:
! 1809: ret = bgp_attr_as4_aggregator (peer, length, attr, flag,
! 1810: &as4_aggregator,
! 1811: &as4_aggregator_addr);
! 1812: break;
! 1813: case BGP_ATTR_COMMUNITIES:
! 1814: ret = bgp_attr_community (peer, length, attr, flag, startp);
! 1815: break;
! 1816: case BGP_ATTR_ORIGINATOR_ID:
! 1817: ret = bgp_attr_originator_id (peer, length, attr, flag);
! 1818: break;
! 1819: case BGP_ATTR_CLUSTER_LIST:
! 1820: ret = bgp_attr_cluster_list (peer, length, attr, flag);
! 1821: break;
! 1822: case BGP_ATTR_MP_REACH_NLRI:
! 1823: ret = bgp_mp_reach_parse (peer, length, attr, mp_update);
! 1824: break;
! 1825: case BGP_ATTR_MP_UNREACH_NLRI:
! 1826: ret = bgp_mp_unreach_parse (peer, length, mp_withdraw);
! 1827: break;
! 1828: case BGP_ATTR_EXT_COMMUNITIES:
! 1829: ret = bgp_attr_ext_communities (peer, length, attr, flag, startp);
! 1830: break;
! 1831: default:
! 1832: ret = bgp_attr_unknown (peer, attr, flag, type, length, startp);
! 1833: break;
! 1834: }
! 1835:
! 1836: /* If hard error occured immediately return to the caller. */
! 1837: if (ret == BGP_ATTR_PARSE_ERROR)
! 1838: {
! 1839: zlog (peer->log, LOG_WARNING,
! 1840: "%s: Attribute %s, parse error",
! 1841: peer->host,
! 1842: LOOKUP (attr_str, type));
! 1843: bgp_notify_send (peer,
! 1844: BGP_NOTIFY_UPDATE_ERR,
! 1845: BGP_NOTIFY_UPDATE_MAL_ATTR);
! 1846: if (as4_path)
! 1847: aspath_unintern (&as4_path);
! 1848: return ret;
! 1849: }
! 1850: if (ret == BGP_ATTR_PARSE_WITHDRAW)
! 1851: {
! 1852:
! 1853: zlog (peer->log, LOG_WARNING,
! 1854: "%s: Attribute %s, parse error - treating as withdrawal",
! 1855: peer->host,
! 1856: LOOKUP (attr_str, type));
! 1857: if (as4_path)
! 1858: aspath_unintern (&as4_path);
! 1859: return ret;
! 1860: }
! 1861:
! 1862: /* Check the fetched length. */
! 1863: if (BGP_INPUT_PNT (peer) != attr_endp)
! 1864: {
! 1865: zlog (peer->log, LOG_WARNING,
! 1866: "%s: BGP attribute %s, fetch error",
! 1867: peer->host, LOOKUP (attr_str, type));
! 1868: bgp_notify_send (peer,
! 1869: BGP_NOTIFY_UPDATE_ERR,
! 1870: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
! 1871: if (as4_path)
! 1872: aspath_unintern (&as4_path);
! 1873: return BGP_ATTR_PARSE_ERROR;
! 1874: }
! 1875: }
! 1876:
! 1877: /* Check final read pointer is same as end pointer. */
! 1878: if (BGP_INPUT_PNT (peer) != endp)
! 1879: {
! 1880: zlog (peer->log, LOG_WARNING,
! 1881: "%s: BGP attribute %s, length mismatch",
! 1882: peer->host, LOOKUP (attr_str, type));
! 1883: bgp_notify_send (peer,
! 1884: BGP_NOTIFY_UPDATE_ERR,
! 1885: BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
! 1886: if (as4_path)
! 1887: aspath_unintern (&as4_path);
! 1888: return BGP_ATTR_PARSE_ERROR;
! 1889: }
! 1890:
! 1891: /*
! 1892: * At this place we can see whether we got AS4_PATH and/or
! 1893: * AS4_AGGREGATOR from a 16Bit peer and act accordingly.
! 1894: * We can not do this before we've read all attributes because
! 1895: * the as4 handling does not say whether AS4_PATH has to be sent
! 1896: * after AS_PATH or not - and when AS4_AGGREGATOR will be send
! 1897: * in relationship to AGGREGATOR.
! 1898: * So, to be defensive, we are not relying on any order and read
! 1899: * all attributes first, including these 32bit ones, and now,
! 1900: * afterwards, we look what and if something is to be done for as4.
! 1901: */
! 1902: if (bgp_attr_munge_as4_attrs (peer, attr, flag, as4_path,
! 1903: as4_aggregator, &as4_aggregator_addr))
! 1904: {
! 1905: if (as4_path)
! 1906: aspath_unintern (&as4_path);
! 1907: return BGP_ATTR_PARSE_ERROR;
! 1908: }
! 1909:
! 1910: /* At this stage, we have done all fiddling with as4, and the
! 1911: * resulting info is in attr->aggregator resp. attr->aspath
! 1912: * so we can chuck as4_aggregator and as4_path alltogether in
! 1913: * order to save memory
! 1914: */
! 1915: if (as4_path)
! 1916: {
! 1917: aspath_unintern (&as4_path); /* unintern - it is in the hash */
! 1918: /* The flag that we got this is still there, but that does not
! 1919: * do any trouble
! 1920: */
! 1921: }
! 1922: /*
! 1923: * The "rest" of the code does nothing with as4_aggregator.
! 1924: * there is no memory attached specifically which is not part
! 1925: * of the attr.
! 1926: * so ignoring just means do nothing.
! 1927: */
! 1928: /*
! 1929: * Finally do the checks on the aspath we did not do yet
! 1930: * because we waited for a potentially synthesized aspath.
! 1931: */
! 1932: if (attr->flag & (ATTR_FLAG_BIT(BGP_ATTR_AS_PATH)))
! 1933: {
! 1934: ret = bgp_attr_aspath_check (peer, attr, flag);
! 1935: if (ret != BGP_ATTR_PARSE_PROCEED)
! 1936: return ret;
! 1937: }
! 1938:
! 1939: /* Finally intern unknown attribute. */
! 1940: if (attr->extra && attr->extra->transit)
! 1941: attr->extra->transit = transit_intern (attr->extra->transit);
! 1942:
! 1943: return BGP_ATTR_PARSE_PROCEED;
! 1944: }
! 1945:
! 1946: /* Well-known attribute check. */
! 1947: int
! 1948: bgp_attr_check (struct peer *peer, struct attr *attr)
! 1949: {
! 1950: u_char type = 0;
! 1951:
! 1952: if (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ORIGIN)))
! 1953: type = BGP_ATTR_ORIGIN;
! 1954:
! 1955: if (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH)))
! 1956: type = BGP_ATTR_AS_PATH;
! 1957:
! 1958: if (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP)))
! 1959: type = BGP_ATTR_NEXT_HOP;
! 1960:
! 1961: if (peer_sort (peer) == BGP_PEER_IBGP
! 1962: && ! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF)))
! 1963: type = BGP_ATTR_LOCAL_PREF;
! 1964:
! 1965: if (type)
! 1966: {
! 1967: zlog (peer->log, LOG_WARNING,
! 1968: "%s Missing well-known attribute %d.",
! 1969: peer->host, type);
! 1970: bgp_notify_send_with_data (peer,
! 1971: BGP_NOTIFY_UPDATE_ERR,
! 1972: BGP_NOTIFY_UPDATE_MISS_ATTR,
! 1973: &type, 1);
! 1974: return BGP_ATTR_PARSE_ERROR;
! 1975: }
! 1976: return BGP_ATTR_PARSE_PROCEED;
! 1977: }
! 1978:
! 1979: int stream_put_prefix (struct stream *, struct prefix *);
! 1980:
! 1981: /* Make attribute packet. */
! 1982: bgp_size_t
! 1983: bgp_packet_attribute (struct bgp *bgp, struct peer *peer,
! 1984: struct stream *s, struct attr *attr, struct prefix *p,
! 1985: afi_t afi, safi_t safi, struct peer *from,
! 1986: struct prefix_rd *prd, u_char *tag)
! 1987: {
! 1988: size_t cp;
! 1989: size_t aspath_sizep;
! 1990: struct aspath *aspath;
! 1991: int send_as4_path = 0;
! 1992: int send_as4_aggregator = 0;
! 1993: int use32bit = (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV)) ? 1 : 0;
! 1994:
! 1995: if (! bgp)
! 1996: bgp = bgp_get_default ();
! 1997:
! 1998: /* Remember current pointer. */
! 1999: cp = stream_get_endp (s);
! 2000:
! 2001: /* Origin attribute. */
! 2002: stream_putc (s, BGP_ATTR_FLAG_TRANS);
! 2003: stream_putc (s, BGP_ATTR_ORIGIN);
! 2004: stream_putc (s, 1);
! 2005: stream_putc (s, attr->origin);
! 2006:
! 2007: /* AS path attribute. */
! 2008:
! 2009: /* If remote-peer is EBGP */
! 2010: if (peer_sort (peer) == BGP_PEER_EBGP
! 2011: && (! CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)
! 2012: || attr->aspath->segments == NULL)
! 2013: && (! CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT)))
! 2014: {
! 2015: aspath = aspath_dup (attr->aspath);
! 2016:
! 2017: if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
! 2018: {
! 2019: /* Strip the confed info, and then stuff our path CONFED_ID
! 2020: on the front */
! 2021: aspath = aspath_delete_confed_seq (aspath);
! 2022: aspath = aspath_add_seq (aspath, bgp->confed_id);
! 2023: }
! 2024: else
! 2025: {
! 2026: aspath = aspath_add_seq (aspath, peer->local_as);
! 2027: if (peer->change_local_as)
! 2028: aspath = aspath_add_seq (aspath, peer->change_local_as);
! 2029: }
! 2030: }
! 2031: else if (peer_sort (peer) == BGP_PEER_CONFED)
! 2032: {
! 2033: /* A confed member, so we need to do the AS_CONFED_SEQUENCE thing */
! 2034: aspath = aspath_dup (attr->aspath);
! 2035: aspath = aspath_add_confed_seq (aspath, peer->local_as);
! 2036: }
! 2037: else
! 2038: aspath = attr->aspath;
! 2039:
! 2040: /* If peer is not AS4 capable, then:
! 2041: * - send the created AS_PATH out as AS4_PATH (optional, transitive),
! 2042: * but ensure that no AS_CONFED_SEQUENCE and AS_CONFED_SET path segment
! 2043: * types are in it (i.e. exclude them if they are there)
! 2044: * AND do this only if there is at least one asnum > 65535 in the path!
! 2045: * - send an AS_PATH out, but put 16Bit ASnums in it, not 32bit, and change
! 2046: * all ASnums > 65535 to BGP_AS_TRANS
! 2047: */
! 2048:
! 2049: stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
! 2050: stream_putc (s, BGP_ATTR_AS_PATH);
! 2051: aspath_sizep = stream_get_endp (s);
! 2052: stream_putw (s, 0);
! 2053: stream_putw_at (s, aspath_sizep, aspath_put (s, aspath, use32bit));
! 2054:
! 2055: /* OLD session may need NEW_AS_PATH sent, if there are 4-byte ASNs
! 2056: * in the path
! 2057: */
! 2058: if (!use32bit && aspath_has_as4 (aspath))
! 2059: send_as4_path = 1; /* we'll do this later, at the correct place */
! 2060:
! 2061: /* Nexthop attribute. */
! 2062: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP) && afi == AFI_IP)
! 2063: {
! 2064: stream_putc (s, BGP_ATTR_FLAG_TRANS);
! 2065: stream_putc (s, BGP_ATTR_NEXT_HOP);
! 2066: stream_putc (s, 4);
! 2067: if (safi == SAFI_MPLS_VPN)
! 2068: {
! 2069: if (attr->nexthop.s_addr == 0)
! 2070: stream_put_ipv4 (s, peer->nexthop.v4.s_addr);
! 2071: else
! 2072: stream_put_ipv4 (s, attr->nexthop.s_addr);
! 2073: }
! 2074: else
! 2075: stream_put_ipv4 (s, attr->nexthop.s_addr);
! 2076: }
! 2077:
! 2078: /* MED attribute. */
! 2079: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC))
! 2080: {
! 2081: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
! 2082: stream_putc (s, BGP_ATTR_MULTI_EXIT_DISC);
! 2083: stream_putc (s, 4);
! 2084: stream_putl (s, attr->med);
! 2085: }
! 2086:
! 2087: /* Local preference. */
! 2088: if (peer_sort (peer) == BGP_PEER_IBGP ||
! 2089: peer_sort (peer) == BGP_PEER_CONFED)
! 2090: {
! 2091: stream_putc (s, BGP_ATTR_FLAG_TRANS);
! 2092: stream_putc (s, BGP_ATTR_LOCAL_PREF);
! 2093: stream_putc (s, 4);
! 2094: stream_putl (s, attr->local_pref);
! 2095: }
! 2096:
! 2097: /* Atomic aggregate. */
! 2098: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE))
! 2099: {
! 2100: stream_putc (s, BGP_ATTR_FLAG_TRANS);
! 2101: stream_putc (s, BGP_ATTR_ATOMIC_AGGREGATE);
! 2102: stream_putc (s, 0);
! 2103: }
! 2104:
! 2105: /* Aggregator. */
! 2106: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR))
! 2107: {
! 2108: assert (attr->extra);
! 2109:
! 2110: /* Common to BGP_ATTR_AGGREGATOR, regardless of ASN size */
! 2111: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
! 2112: stream_putc (s, BGP_ATTR_AGGREGATOR);
! 2113:
! 2114: if (use32bit)
! 2115: {
! 2116: /* AS4 capable peer */
! 2117: stream_putc (s, 8);
! 2118: stream_putl (s, attr->extra->aggregator_as);
! 2119: }
! 2120: else
! 2121: {
! 2122: /* 2-byte AS peer */
! 2123: stream_putc (s, 6);
! 2124:
! 2125: /* Is ASN representable in 2-bytes? Or must AS_TRANS be used? */
! 2126: if ( attr->extra->aggregator_as > 65535 )
! 2127: {
! 2128: stream_putw (s, BGP_AS_TRANS);
! 2129:
! 2130: /* we have to send AS4_AGGREGATOR, too.
! 2131: * we'll do that later in order to send attributes in ascending
! 2132: * order.
! 2133: */
! 2134: send_as4_aggregator = 1;
! 2135: }
! 2136: else
! 2137: stream_putw (s, (u_int16_t) attr->extra->aggregator_as);
! 2138: }
! 2139: stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
! 2140: }
! 2141:
! 2142: /* Community attribute. */
! 2143: if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
! 2144: && (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES)))
! 2145: {
! 2146: if (attr->community->size * 4 > 255)
! 2147: {
! 2148: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
! 2149: stream_putc (s, BGP_ATTR_COMMUNITIES);
! 2150: stream_putw (s, attr->community->size * 4);
! 2151: }
! 2152: else
! 2153: {
! 2154: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
! 2155: stream_putc (s, BGP_ATTR_COMMUNITIES);
! 2156: stream_putc (s, attr->community->size * 4);
! 2157: }
! 2158: stream_put (s, attr->community->val, attr->community->size * 4);
! 2159: }
! 2160:
! 2161: /* Route Reflector. */
! 2162: if (peer_sort (peer) == BGP_PEER_IBGP
! 2163: && from
! 2164: && peer_sort (from) == BGP_PEER_IBGP)
! 2165: {
! 2166: /* Originator ID. */
! 2167: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
! 2168: stream_putc (s, BGP_ATTR_ORIGINATOR_ID);
! 2169: stream_putc (s, 4);
! 2170:
! 2171: if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID))
! 2172: stream_put_in_addr (s, &attr->extra->originator_id);
! 2173: else
! 2174: stream_put_in_addr (s, &from->remote_id);
! 2175:
! 2176: /* Cluster list. */
! 2177: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
! 2178: stream_putc (s, BGP_ATTR_CLUSTER_LIST);
! 2179:
! 2180: if (attr->extra && attr->extra->cluster)
! 2181: {
! 2182: stream_putc (s, attr->extra->cluster->length + 4);
! 2183: /* If this peer configuration's parent BGP has cluster_id. */
! 2184: if (bgp->config & BGP_CONFIG_CLUSTER_ID)
! 2185: stream_put_in_addr (s, &bgp->cluster_id);
! 2186: else
! 2187: stream_put_in_addr (s, &bgp->router_id);
! 2188: stream_put (s, attr->extra->cluster->list,
! 2189: attr->extra->cluster->length);
! 2190: }
! 2191: else
! 2192: {
! 2193: stream_putc (s, 4);
! 2194: /* If this peer configuration's parent BGP has cluster_id. */
! 2195: if (bgp->config & BGP_CONFIG_CLUSTER_ID)
! 2196: stream_put_in_addr (s, &bgp->cluster_id);
! 2197: else
! 2198: stream_put_in_addr (s, &bgp->router_id);
! 2199: }
! 2200: }
! 2201:
! 2202: #ifdef HAVE_IPV6
! 2203: /* If p is IPv6 address put it into attribute. */
! 2204: if (p->family == AF_INET6)
! 2205: {
! 2206: unsigned long sizep;
! 2207: struct attr_extra *attre = attr->extra;
! 2208:
! 2209: assert (attr->extra);
! 2210:
! 2211: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
! 2212: stream_putc (s, BGP_ATTR_MP_REACH_NLRI);
! 2213: sizep = stream_get_endp (s);
! 2214: stream_putc (s, 0); /* Marker: Attribute length. */
! 2215: stream_putw (s, AFI_IP6); /* AFI */
! 2216: stream_putc (s, safi); /* SAFI */
! 2217:
! 2218: stream_putc (s, attre->mp_nexthop_len);
! 2219:
! 2220: if (attre->mp_nexthop_len == 16)
! 2221: stream_put (s, &attre->mp_nexthop_global, 16);
! 2222: else if (attre->mp_nexthop_len == 32)
! 2223: {
! 2224: stream_put (s, &attre->mp_nexthop_global, 16);
! 2225: stream_put (s, &attre->mp_nexthop_local, 16);
! 2226: }
! 2227:
! 2228: /* SNPA */
! 2229: stream_putc (s, 0);
! 2230:
! 2231: /* Prefix write. */
! 2232: stream_put_prefix (s, p);
! 2233:
! 2234: /* Set MP attribute length. */
! 2235: stream_putc_at (s, sizep, (stream_get_endp (s) - sizep) - 1);
! 2236: }
! 2237: #endif /* HAVE_IPV6 */
! 2238:
! 2239: if (p->family == AF_INET && safi == SAFI_MULTICAST)
! 2240: {
! 2241: unsigned long sizep;
! 2242:
! 2243: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
! 2244: stream_putc (s, BGP_ATTR_MP_REACH_NLRI);
! 2245: sizep = stream_get_endp (s);
! 2246: stream_putc (s, 0); /* Marker: Attribute Length. */
! 2247: stream_putw (s, AFI_IP); /* AFI */
! 2248: stream_putc (s, SAFI_MULTICAST); /* SAFI */
! 2249:
! 2250: stream_putc (s, 4);
! 2251: stream_put_ipv4 (s, attr->nexthop.s_addr);
! 2252:
! 2253: /* SNPA */
! 2254: stream_putc (s, 0);
! 2255:
! 2256: /* Prefix write. */
! 2257: stream_put_prefix (s, p);
! 2258:
! 2259: /* Set MP attribute length. */
! 2260: stream_putc_at (s, sizep, (stream_get_endp (s) - sizep) - 1);
! 2261: }
! 2262:
! 2263: if (p->family == AF_INET && safi == SAFI_MPLS_VPN)
! 2264: {
! 2265: unsigned long sizep;
! 2266:
! 2267: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
! 2268: stream_putc (s, BGP_ATTR_MP_REACH_NLRI);
! 2269: sizep = stream_get_endp (s);
! 2270: stream_putc (s, 0); /* Length of this attribute. */
! 2271: stream_putw (s, AFI_IP); /* AFI */
! 2272: stream_putc (s, BGP_SAFI_VPNV4); /* SAFI */
! 2273:
! 2274: stream_putc (s, 12);
! 2275: stream_putl (s, 0);
! 2276: stream_putl (s, 0);
! 2277: stream_put (s, &attr->extra->mp_nexthop_global_in, 4);
! 2278:
! 2279: /* SNPA */
! 2280: stream_putc (s, 0);
! 2281:
! 2282: /* Tag, RD, Prefix write. */
! 2283: stream_putc (s, p->prefixlen + 88);
! 2284: stream_put (s, tag, 3);
! 2285: stream_put (s, prd->val, 8);
! 2286: stream_put (s, &p->u.prefix, PSIZE (p->prefixlen));
! 2287:
! 2288: /* Set MP attribute length. */
! 2289: stream_putc_at (s, sizep, (stream_get_endp (s) - sizep) - 1);
! 2290: }
! 2291:
! 2292: /* Extended Communities attribute. */
! 2293: if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY)
! 2294: && (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES)))
! 2295: {
! 2296: struct attr_extra *attre = attr->extra;
! 2297:
! 2298: assert (attre);
! 2299:
! 2300: if (peer_sort (peer) == BGP_PEER_IBGP
! 2301: || peer_sort (peer) == BGP_PEER_CONFED)
! 2302: {
! 2303: if (attre->ecommunity->size * 8 > 255)
! 2304: {
! 2305: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
! 2306: stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
! 2307: stream_putw (s, attre->ecommunity->size * 8);
! 2308: }
! 2309: else
! 2310: {
! 2311: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
! 2312: stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
! 2313: stream_putc (s, attre->ecommunity->size * 8);
! 2314: }
! 2315: stream_put (s, attre->ecommunity->val, attre->ecommunity->size * 8);
! 2316: }
! 2317: else
! 2318: {
! 2319: u_int8_t *pnt;
! 2320: int tbit;
! 2321: int ecom_tr_size = 0;
! 2322: int i;
! 2323:
! 2324: for (i = 0; i < attre->ecommunity->size; i++)
! 2325: {
! 2326: pnt = attre->ecommunity->val + (i * 8);
! 2327: tbit = *pnt;
! 2328:
! 2329: if (CHECK_FLAG (tbit, ECOMMUNITY_FLAG_NON_TRANSITIVE))
! 2330: continue;
! 2331:
! 2332: ecom_tr_size++;
! 2333: }
! 2334:
! 2335: if (ecom_tr_size)
! 2336: {
! 2337: if (ecom_tr_size * 8 > 255)
! 2338: {
! 2339: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
! 2340: stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
! 2341: stream_putw (s, ecom_tr_size * 8);
! 2342: }
! 2343: else
! 2344: {
! 2345: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
! 2346: stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
! 2347: stream_putc (s, ecom_tr_size * 8);
! 2348: }
! 2349:
! 2350: for (i = 0; i < attre->ecommunity->size; i++)
! 2351: {
! 2352: pnt = attre->ecommunity->val + (i * 8);
! 2353: tbit = *pnt;
! 2354:
! 2355: if (CHECK_FLAG (tbit, ECOMMUNITY_FLAG_NON_TRANSITIVE))
! 2356: continue;
! 2357:
! 2358: stream_put (s, pnt, 8);
! 2359: }
! 2360: }
! 2361: }
! 2362: }
! 2363:
! 2364: if ( send_as4_path )
! 2365: {
! 2366: /* If the peer is NOT As4 capable, AND */
! 2367: /* there are ASnums > 65535 in path THEN
! 2368: * give out AS4_PATH */
! 2369:
! 2370: /* Get rid of all AS_CONFED_SEQUENCE and AS_CONFED_SET
! 2371: * path segments!
! 2372: * Hm, I wonder... confederation things *should* only be at
! 2373: * the beginning of an aspath, right? Then we should use
! 2374: * aspath_delete_confed_seq for this, because it is already
! 2375: * there! (JK)
! 2376: * Folks, talk to me: what is reasonable here!?
! 2377: */
! 2378: aspath = aspath_delete_confed_seq (aspath);
! 2379:
! 2380: stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_EXTLEN);
! 2381: stream_putc (s, BGP_ATTR_AS4_PATH);
! 2382: aspath_sizep = stream_get_endp (s);
! 2383: stream_putw (s, 0);
! 2384: stream_putw_at (s, aspath_sizep, aspath_put (s, aspath, 1));
! 2385: }
! 2386:
! 2387: if (aspath != attr->aspath)
! 2388: aspath_free (aspath);
! 2389:
! 2390: if ( send_as4_aggregator )
! 2391: {
! 2392: assert (attr->extra);
! 2393:
! 2394: /* send AS4_AGGREGATOR, at this place */
! 2395: /* this section of code moved here in order to ensure the correct
! 2396: * *ascending* order of attributes
! 2397: */
! 2398: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
! 2399: stream_putc (s, BGP_ATTR_AS4_AGGREGATOR);
! 2400: stream_putc (s, 8);
! 2401: stream_putl (s, attr->extra->aggregator_as);
! 2402: stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
! 2403: }
! 2404:
! 2405: /* Unknown transit attribute. */
! 2406: if (attr->extra && attr->extra->transit)
! 2407: stream_put (s, attr->extra->transit->val, attr->extra->transit->length);
! 2408:
! 2409: /* Return total size of attribute. */
! 2410: return stream_get_endp (s) - cp;
! 2411: }
! 2412:
! 2413: bgp_size_t
! 2414: bgp_packet_withdraw (struct peer *peer, struct stream *s, struct prefix *p,
! 2415: afi_t afi, safi_t safi, struct prefix_rd *prd,
! 2416: u_char *tag)
! 2417: {
! 2418: unsigned long cp;
! 2419: unsigned long attrlen_pnt;
! 2420: bgp_size_t size;
! 2421:
! 2422: cp = stream_get_endp (s);
! 2423:
! 2424: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
! 2425: stream_putc (s, BGP_ATTR_MP_UNREACH_NLRI);
! 2426:
! 2427: attrlen_pnt = stream_get_endp (s);
! 2428: stream_putc (s, 0); /* Length of this attribute. */
! 2429:
! 2430: stream_putw (s, family2afi (p->family));
! 2431:
! 2432: if (safi == SAFI_MPLS_VPN)
! 2433: {
! 2434: /* SAFI */
! 2435: stream_putc (s, BGP_SAFI_VPNV4);
! 2436:
! 2437: /* prefix. */
! 2438: stream_putc (s, p->prefixlen + 88);
! 2439: stream_put (s, tag, 3);
! 2440: stream_put (s, prd->val, 8);
! 2441: stream_put (s, &p->u.prefix, PSIZE (p->prefixlen));
! 2442: }
! 2443: else
! 2444: {
! 2445: /* SAFI */
! 2446: stream_putc (s, safi);
! 2447:
! 2448: /* prefix */
! 2449: stream_put_prefix (s, p);
! 2450: }
! 2451:
! 2452: /* Set MP attribute length. */
! 2453: size = stream_get_endp (s) - attrlen_pnt - 1;
! 2454: stream_putc_at (s, attrlen_pnt, size);
! 2455:
! 2456: return stream_get_endp (s) - cp;
! 2457: }
! 2458:
! 2459: /* Initialization of attribute. */
! 2460: void
! 2461: bgp_attr_init (void)
! 2462: {
! 2463: aspath_init ();
! 2464: attrhash_init ();
! 2465: community_init ();
! 2466: ecommunity_init ();
! 2467: cluster_init ();
! 2468: transit_init ();
! 2469: }
! 2470:
! 2471: void
! 2472: bgp_attr_finish (void)
! 2473: {
! 2474: aspath_finish ();
! 2475: attrhash_finish ();
! 2476: community_finish ();
! 2477: ecommunity_finish ();
! 2478: cluster_finish ();
! 2479: transit_finish ();
! 2480: }
! 2481:
! 2482: /* Make attribute packet. */
! 2483: void
! 2484: bgp_dump_routes_attr (struct stream *s, struct attr *attr,
! 2485: struct prefix *prefix)
! 2486: {
! 2487: unsigned long cp;
! 2488: unsigned long len;
! 2489: size_t aspath_lenp;
! 2490: struct aspath *aspath;
! 2491:
! 2492: /* Remember current pointer. */
! 2493: cp = stream_get_endp (s);
! 2494:
! 2495: /* Place holder of length. */
! 2496: stream_putw (s, 0);
! 2497:
! 2498: /* Origin attribute. */
! 2499: stream_putc (s, BGP_ATTR_FLAG_TRANS);
! 2500: stream_putc (s, BGP_ATTR_ORIGIN);
! 2501: stream_putc (s, 1);
! 2502: stream_putc (s, attr->origin);
! 2503:
! 2504: aspath = attr->aspath;
! 2505:
! 2506: stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
! 2507: stream_putc (s, BGP_ATTR_AS_PATH);
! 2508: aspath_lenp = stream_get_endp (s);
! 2509: stream_putw (s, 0);
! 2510:
! 2511: stream_putw_at (s, aspath_lenp, aspath_put (s, aspath, 1));
! 2512:
! 2513: /* Nexthop attribute. */
! 2514: /* If it's an IPv6 prefix, don't dump the IPv4 nexthop to save space */
! 2515: if(prefix != NULL
! 2516: #ifdef HAVE_IPV6
! 2517: && prefix->family != AF_INET6
! 2518: #endif /* HAVE_IPV6 */
! 2519: )
! 2520: {
! 2521: stream_putc (s, BGP_ATTR_FLAG_TRANS);
! 2522: stream_putc (s, BGP_ATTR_NEXT_HOP);
! 2523: stream_putc (s, 4);
! 2524: stream_put_ipv4 (s, attr->nexthop.s_addr);
! 2525: }
! 2526:
! 2527: /* MED attribute. */
! 2528: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC))
! 2529: {
! 2530: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
! 2531: stream_putc (s, BGP_ATTR_MULTI_EXIT_DISC);
! 2532: stream_putc (s, 4);
! 2533: stream_putl (s, attr->med);
! 2534: }
! 2535:
! 2536: /* Local preference. */
! 2537: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF))
! 2538: {
! 2539: stream_putc (s, BGP_ATTR_FLAG_TRANS);
! 2540: stream_putc (s, BGP_ATTR_LOCAL_PREF);
! 2541: stream_putc (s, 4);
! 2542: stream_putl (s, attr->local_pref);
! 2543: }
! 2544:
! 2545: /* Atomic aggregate. */
! 2546: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE))
! 2547: {
! 2548: stream_putc (s, BGP_ATTR_FLAG_TRANS);
! 2549: stream_putc (s, BGP_ATTR_ATOMIC_AGGREGATE);
! 2550: stream_putc (s, 0);
! 2551: }
! 2552:
! 2553: /* Aggregator. */
! 2554: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR))
! 2555: {
! 2556: assert (attr->extra);
! 2557: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
! 2558: stream_putc (s, BGP_ATTR_AGGREGATOR);
! 2559: stream_putc (s, 8);
! 2560: stream_putl (s, attr->extra->aggregator_as);
! 2561: stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
! 2562: }
! 2563:
! 2564: /* Community attribute. */
! 2565: if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES))
! 2566: {
! 2567: if (attr->community->size * 4 > 255)
! 2568: {
! 2569: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
! 2570: stream_putc (s, BGP_ATTR_COMMUNITIES);
! 2571: stream_putw (s, attr->community->size * 4);
! 2572: }
! 2573: else
! 2574: {
! 2575: stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
! 2576: stream_putc (s, BGP_ATTR_COMMUNITIES);
! 2577: stream_putc (s, attr->community->size * 4);
! 2578: }
! 2579: stream_put (s, attr->community->val, attr->community->size * 4);
! 2580: }
! 2581:
! 2582: #ifdef HAVE_IPV6
! 2583: /* Add a MP_NLRI attribute to dump the IPv6 next hop */
! 2584: if (prefix != NULL && prefix->family == AF_INET6 && attr->extra &&
! 2585: (attr->extra->mp_nexthop_len == 16 || attr->extra->mp_nexthop_len == 32) )
! 2586: {
! 2587: int sizep;
! 2588: struct attr_extra *attre = attr->extra;
! 2589:
! 2590: stream_putc(s, BGP_ATTR_FLAG_OPTIONAL);
! 2591: stream_putc(s, BGP_ATTR_MP_REACH_NLRI);
! 2592: sizep = stream_get_endp (s);
! 2593:
! 2594: /* MP header */
! 2595: stream_putc (s, 0); /* Marker: Attribute length. */
! 2596: stream_putw(s, AFI_IP6); /* AFI */
! 2597: stream_putc(s, SAFI_UNICAST); /* SAFI */
! 2598:
! 2599: /* Next hop */
! 2600: stream_putc(s, attre->mp_nexthop_len);
! 2601: stream_put(s, &attre->mp_nexthop_global, 16);
! 2602: if (attre->mp_nexthop_len == 32)
! 2603: stream_put(s, &attre->mp_nexthop_local, 16);
! 2604:
! 2605: /* SNPA */
! 2606: stream_putc(s, 0);
! 2607:
! 2608: /* Prefix */
! 2609: stream_put_prefix(s, prefix);
! 2610:
! 2611: /* Set MP attribute length. */
! 2612: stream_putc_at (s, sizep, (stream_get_endp (s) - sizep) - 1);
! 2613: }
! 2614: #endif /* HAVE_IPV6 */
! 2615:
! 2616: /* Return total size of attribute. */
! 2617: len = stream_get_endp (s) - cp - 2;
! 2618: stream_putw_at (s, cp, len);
! 2619: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to bgp_attr.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