Annotation of embedaddon/bird2/proto/bgp/attrs.c, revision 1.1
1.1 ! misho 1: /*
! 2: * BIRD -- BGP Attributes
! 3: *
! 4: * (c) 2000 Martin Mares <mj@ucw.cz>
! 5: * (c) 2008--2016 Ondrej Zajicek <santiago@crfreenet.org>
! 6: * (c) 2008--2016 CZ.NIC z.s.p.o.
! 7: *
! 8: * Can be freely distributed and used under the terms of the GNU GPL.
! 9: */
! 10:
! 11: #undef LOCAL_DEBUG
! 12:
! 13: #include <stdlib.h>
! 14:
! 15: #include "nest/bird.h"
! 16: #include "nest/iface.h"
! 17: #include "nest/protocol.h"
! 18: #include "nest/route.h"
! 19: #include "nest/attrs.h"
! 20: #include "conf/conf.h"
! 21: #include "lib/resource.h"
! 22: #include "lib/string.h"
! 23: #include "lib/unaligned.h"
! 24:
! 25: #include "bgp.h"
! 26:
! 27: /*
! 28: * UPDATE message error handling
! 29: *
! 30: * All checks from RFC 4271 6.3 are done as specified with these exceptions:
! 31: * - The semantic check of an IP address from NEXT_HOP attribute is missing.
! 32: * - Checks of some optional attribute values are missing.
! 33: * - Syntactic and semantic checks of NLRIs (done in DECODE_PREFIX())
! 34: * are probably inadequate.
! 35: *
! 36: * Loop detection based on AS_PATH causes updates to be withdrawn. RFC
! 37: * 4271 does not explicitly specify the behavior in that case.
! 38: *
! 39: * Loop detection related to route reflection (based on ORIGINATOR_ID
! 40: * and CLUSTER_LIST) causes updates to be withdrawn. RFC 4456 8
! 41: * specifies that such updates should be ignored, but that is generally
! 42: * a bad idea.
! 43: *
! 44: * BGP attribute table has several hooks:
! 45: *
! 46: * export - Hook that validates and normalizes attribute during export phase.
! 47: * Receives eattr, may modify it (e.g., sort community lists for canonical
! 48: * representation), UNSET() it (e.g., skip empty lists), or WITHDRAW() it if
! 49: * necessary. May assume that eattr has value valid w.r.t. its type, but may be
! 50: * invalid w.r.t. BGP constraints. Optional.
! 51: *
! 52: * encode - Hook that converts internal representation to external one during
! 53: * packet writing. Receives eattr and puts it in the buffer (including attribute
! 54: * header). Returns number of bytes, or -1 if not enough space. May assume that
! 55: * eattr has value valid w.r.t. its type and validated by export hook. Mandatory
! 56: * for all known attributes that exist internally after export phase (i.e., all
! 57: * except pseudoattributes MP_(UN)REACH_NLRI).
! 58: *
! 59: * decode - Hook that converts external representation to internal one during
! 60: * packet parsing. Receives attribute data in buffer, validates it and adds
! 61: * attribute to ea_list. If data are invalid, steps DISCARD(), WITHDRAW() or
! 62: * bgp_parse_error() may be used to escape. Mandatory for all known attributes.
! 63: *
! 64: * format - Optional hook that converts eattr to textual representation.
! 65: */
! 66:
! 67:
! 68: struct bgp_attr_desc {
! 69: const char *name;
! 70: uint type;
! 71: uint flags;
! 72: void (*export)(struct bgp_export_state *s, eattr *a);
! 73: int (*encode)(struct bgp_write_state *s, eattr *a, byte *buf, uint size);
! 74: void (*decode)(struct bgp_parse_state *s, uint code, uint flags, byte *data, uint len, ea_list **to);
! 75: void (*format)(eattr *ea, byte *buf, uint size);
! 76: };
! 77:
! 78: static const struct bgp_attr_desc bgp_attr_table[];
! 79:
! 80: static inline int bgp_attr_known(uint code);
! 81:
! 82: eattr *
! 83: bgp_set_attr(ea_list **attrs, struct linpool *pool, uint code, uint flags, uintptr_t val)
! 84: {
! 85: ASSERT(bgp_attr_known(code));
! 86:
! 87: return ea_set_attr(
! 88: attrs,
! 89: pool,
! 90: EA_CODE(PROTOCOL_BGP, code),
! 91: flags,
! 92: bgp_attr_table[code].type,
! 93: val
! 94: );
! 95: }
! 96:
! 97:
! 98:
! 99: #define REPORT(msg, args...) \
! 100: ({ log(L_REMOTE "%s: " msg, s->proto->p.name, ## args); })
! 101:
! 102: #define DISCARD(msg, args...) \
! 103: ({ REPORT(msg, ## args); return; })
! 104:
! 105: #define WITHDRAW(msg, args...) \
! 106: ({ REPORT(msg, ## args); s->err_withdraw = 1; return; })
! 107:
! 108: #define UNSET(a) \
! 109: ({ a->type = EAF_TYPE_UNDEF; return; })
! 110:
! 111: #define NEW_BGP "Discarding %s attribute received from AS4-aware neighbor"
! 112: #define BAD_EBGP "Discarding %s attribute received from EBGP neighbor"
! 113: #define BAD_LENGTH "Malformed %s attribute - invalid length (%u)"
! 114: #define BAD_VALUE "Malformed %s attribute - invalid value (%u)"
! 115: #define NO_MANDATORY "Missing mandatory %s attribute"
! 116:
! 117:
! 118: static inline int
! 119: bgp_put_attr_hdr3(byte *buf, uint code, uint flags, uint len)
! 120: {
! 121: *buf++ = flags;
! 122: *buf++ = code;
! 123: *buf++ = len;
! 124: return 3;
! 125: }
! 126:
! 127: static inline int
! 128: bgp_put_attr_hdr4(byte *buf, uint code, uint flags, uint len)
! 129: {
! 130: *buf++ = flags | BAF_EXT_LEN;
! 131: *buf++ = code;
! 132: put_u16(buf, len);
! 133: return 4;
! 134: }
! 135:
! 136: static inline int
! 137: bgp_put_attr_hdr(byte *buf, uint code, uint flags, uint len)
! 138: {
! 139: if (len < 256)
! 140: return bgp_put_attr_hdr3(buf, code, flags, len);
! 141: else
! 142: return bgp_put_attr_hdr4(buf, code, flags, len);
! 143: }
! 144:
! 145: static int
! 146: bgp_encode_u8(struct bgp_write_state *s UNUSED, eattr *a, byte *buf, uint size)
! 147: {
! 148: if (size < (3+1))
! 149: return -1;
! 150:
! 151: bgp_put_attr_hdr3(buf, EA_ID(a->id), a->flags, 1);
! 152: buf[3] = a->u.data;
! 153:
! 154: return 3+1;
! 155: }
! 156:
! 157: static int
! 158: bgp_encode_u32(struct bgp_write_state *s UNUSED, eattr *a, byte *buf, uint size)
! 159: {
! 160: if (size < (3+4))
! 161: return -1;
! 162:
! 163: bgp_put_attr_hdr3(buf, EA_ID(a->id), a->flags, 4);
! 164: put_u32(buf+3, a->u.data);
! 165:
! 166: return 3+4;
! 167: }
! 168:
! 169: static int
! 170: bgp_encode_u32s(struct bgp_write_state *s UNUSED, eattr *a, byte *buf, uint size)
! 171: {
! 172: uint len = a->u.ptr->length;
! 173:
! 174: if (size < (4+len))
! 175: return -1;
! 176:
! 177: uint hdr = bgp_put_attr_hdr(buf, EA_ID(a->id), a->flags, len);
! 178: put_u32s(buf + hdr, (u32 *) a->u.ptr->data, len / 4);
! 179:
! 180: return hdr + len;
! 181: }
! 182:
! 183: static int
! 184: bgp_put_attr(byte *buf, uint size, uint code, uint flags, const byte *data, uint len)
! 185: {
! 186: if (size < (4+len))
! 187: return -1;
! 188:
! 189: uint hdr = bgp_put_attr_hdr(buf, code, flags, len);
! 190: memcpy(buf + hdr, data, len);
! 191:
! 192: return hdr + len;
! 193: }
! 194:
! 195: static int
! 196: bgp_encode_raw(struct bgp_write_state *s UNUSED, eattr *a, byte *buf, uint size)
! 197: {
! 198: return bgp_put_attr(buf, size, EA_ID(a->id), a->flags, a->u.ptr->data, a->u.ptr->length);
! 199: }
! 200:
! 201:
! 202: /*
! 203: * AIGP handling
! 204: */
! 205:
! 206: static int
! 207: bgp_aigp_valid(byte *data, uint len, char *err, uint elen)
! 208: {
! 209: byte *pos = data;
! 210: char *err_dsc = NULL;
! 211: uint err_val = 0;
! 212:
! 213: #define BAD(DSC,VAL) ({ err_dsc = DSC; err_val = VAL; goto bad; })
! 214: while (len)
! 215: {
! 216: if (len < 3)
! 217: BAD("TLV framing error", len);
! 218:
! 219: /* Process one TLV */
! 220: uint ptype = pos[0];
! 221: uint plen = get_u16(pos + 1);
! 222:
! 223: if (len < plen)
! 224: BAD("TLV framing error", plen);
! 225:
! 226: if (plen < 3)
! 227: BAD("Bad TLV length", plen);
! 228:
! 229: if ((ptype == BGP_AIGP_METRIC) && (plen != 11))
! 230: BAD("Bad AIGP TLV length", plen);
! 231:
! 232: ADVANCE(pos, len, plen);
! 233: }
! 234: #undef BAD
! 235:
! 236: return 1;
! 237:
! 238: bad:
! 239: if (err)
! 240: if (bsnprintf(err, elen, "%s (%u) at %d", err_dsc, err_val, (int) (pos - data)) < 0)
! 241: err[0] = 0;
! 242:
! 243: return 0;
! 244: }
! 245:
! 246: static const byte *
! 247: bgp_aigp_get_tlv(const struct adata *ad, uint type)
! 248: {
! 249: if (!ad)
! 250: return NULL;
! 251:
! 252: uint len = ad->length;
! 253: const byte *pos = ad->data;
! 254:
! 255: while (len)
! 256: {
! 257: uint ptype = pos[0];
! 258: uint plen = get_u16(pos + 1);
! 259:
! 260: if (ptype == type)
! 261: return pos;
! 262:
! 263: ADVANCE(pos, len, plen);
! 264: }
! 265:
! 266: return NULL;
! 267: }
! 268:
! 269: static const struct adata *
! 270: bgp_aigp_set_tlv(struct linpool *pool, const struct adata *ad, uint type, byte *data, uint dlen)
! 271: {
! 272: uint len = ad ? ad->length : 0;
! 273: const byte *pos = ad ? ad->data : NULL;
! 274: struct adata *res = lp_alloc_adata(pool, len + 3 + dlen);
! 275: byte *dst = res->data;
! 276: byte *tlv = NULL;
! 277: int del = 0;
! 278:
! 279: while (len)
! 280: {
! 281: uint ptype = pos[0];
! 282: uint plen = get_u16(pos + 1);
! 283:
! 284: /* Find position for new TLV */
! 285: if ((ptype >= type) && !tlv)
! 286: {
! 287: tlv = dst;
! 288: dst += 3 + dlen;
! 289: }
! 290:
! 291: /* Skip first matching TLV, copy others */
! 292: if ((ptype == type) && !del)
! 293: del = 1;
! 294: else
! 295: {
! 296: memcpy(dst, pos, plen);
! 297: dst += plen;
! 298: }
! 299:
! 300: ADVANCE(pos, len, plen);
! 301: }
! 302:
! 303: if (!tlv)
! 304: {
! 305: tlv = dst;
! 306: dst += 3 + dlen;
! 307: }
! 308:
! 309: /* Store the TLD */
! 310: put_u8(tlv + 0, type);
! 311: put_u16(tlv + 1, 3 + dlen);
! 312: memcpy(tlv + 3, data, dlen);
! 313:
! 314: /* Update length */
! 315: res->length = dst - res->data;
! 316:
! 317: return res;
! 318: }
! 319:
! 320: static u64 UNUSED
! 321: bgp_aigp_get_metric(const struct adata *ad, u64 def)
! 322: {
! 323: const byte *b = bgp_aigp_get_tlv(ad, BGP_AIGP_METRIC);
! 324: return b ? get_u64(b + 3) : def;
! 325: }
! 326:
! 327: static const struct adata *
! 328: bgp_aigp_set_metric(struct linpool *pool, const struct adata *ad, u64 metric)
! 329: {
! 330: byte data[8];
! 331: put_u64(data, metric);
! 332: return bgp_aigp_set_tlv(pool, ad, BGP_AIGP_METRIC, data, 8);
! 333: }
! 334:
! 335: int
! 336: bgp_total_aigp_metric_(rte *e, u64 *metric, const struct adata **ad)
! 337: {
! 338: eattr *a = ea_find(e->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AIGP));
! 339: if (!a)
! 340: return 0;
! 341:
! 342: const byte *b = bgp_aigp_get_tlv(a->u.ptr, BGP_AIGP_METRIC);
! 343: if (!b)
! 344: return 0;
! 345:
! 346: u64 aigp = get_u64(b + 3);
! 347: u64 step = e->attrs->igp_metric;
! 348:
! 349: if (!rte_resolvable(e) || (step >= IGP_METRIC_UNKNOWN))
! 350: step = BGP_AIGP_MAX;
! 351:
! 352: if (!step)
! 353: step = 1;
! 354:
! 355: *ad = a->u.ptr;
! 356: *metric = aigp + step;
! 357: if (*metric < aigp)
! 358: *metric = BGP_AIGP_MAX;
! 359:
! 360: return 1;
! 361: }
! 362:
! 363: static inline int
! 364: bgp_init_aigp_metric(rte *e, u64 *metric, const struct adata **ad)
! 365: {
! 366: if (e->attrs->source == RTS_BGP)
! 367: return 0;
! 368:
! 369: *metric = rt_get_igp_metric(e);
! 370: *ad = NULL;
! 371: return *metric < IGP_METRIC_UNKNOWN;
! 372: }
! 373:
! 374:
! 375: /*
! 376: * Attribute hooks
! 377: */
! 378:
! 379: static void
! 380: bgp_export_origin(struct bgp_export_state *s, eattr *a)
! 381: {
! 382: if (a->u.data > 2)
! 383: WITHDRAW(BAD_VALUE, "ORIGIN", a->u.data);
! 384: }
! 385:
! 386: static void
! 387: bgp_decode_origin(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 388: {
! 389: if (len != 1)
! 390: WITHDRAW(BAD_LENGTH, "ORIGIN", len);
! 391:
! 392: if (data[0] > 2)
! 393: WITHDRAW(BAD_VALUE, "ORIGIN", data[0]);
! 394:
! 395: bgp_set_attr_u32(to, s->pool, BA_ORIGIN, flags, data[0]);
! 396: }
! 397:
! 398: static void
! 399: bgp_format_origin(eattr *a, byte *buf, uint size UNUSED)
! 400: {
! 401: static const char *bgp_origin_names[] = { "IGP", "EGP", "Incomplete" };
! 402:
! 403: bsprintf(buf, (a->u.data <= 2) ? bgp_origin_names[a->u.data] : "?");
! 404: }
! 405:
! 406:
! 407: static int
! 408: bgp_encode_as_path(struct bgp_write_state *s, eattr *a, byte *buf, uint size)
! 409: {
! 410: const byte *data = a->u.ptr->data;
! 411: uint len = a->u.ptr->length;
! 412:
! 413: if (!s->as4_session)
! 414: {
! 415: /* Prepare 16-bit AS_PATH (from 32-bit one) in a temporary buffer */
! 416: byte *dst = alloca(len);
! 417: len = as_path_32to16(dst, data, len);
! 418: data = dst;
! 419: }
! 420:
! 421: return bgp_put_attr(buf, size, BA_AS_PATH, a->flags, data, len);
! 422: }
! 423:
! 424: static void
! 425: bgp_decode_as_path(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 426: {
! 427: struct bgp_proto *p = s->proto;
! 428: int as_length = s->as4_session ? 4 : 2;
! 429: int as_confed = p->cf->confederation && p->is_interior;
! 430: char err[128];
! 431:
! 432: if (!as_path_valid(data, len, as_length, as_confed, err, sizeof(err)))
! 433: WITHDRAW("Malformed AS_PATH attribute - %s", err);
! 434:
! 435: /* In some circumstances check for initial AS_CONFED_SEQUENCE; RFC 5065 5.0 */
! 436: if (p->is_interior && !p->is_internal &&
! 437: ((len < 2) || (data[0] != AS_PATH_CONFED_SEQUENCE)))
! 438: WITHDRAW("Malformed AS_PATH attribute - %s", "missing initial AS_CONFED_SEQUENCE");
! 439:
! 440: if (!s->as4_session)
! 441: {
! 442: /* Prepare 32-bit AS_PATH (from 16-bit one) in a temporary buffer */
! 443: byte *src = data;
! 444: data = alloca(2*len);
! 445: len = as_path_16to32(data, src, len);
! 446: }
! 447:
! 448: bgp_set_attr_data(to, s->pool, BA_AS_PATH, flags, data, len);
! 449: }
! 450:
! 451:
! 452: static int
! 453: bgp_encode_next_hop(struct bgp_write_state *s, eattr *a, byte *buf, uint size)
! 454: {
! 455: /*
! 456: * The NEXT_HOP attribute is used only in traditional (IPv4) BGP. In MP-BGP,
! 457: * the next hop is encoded as a part of the MP_REACH_NLRI attribute, so we
! 458: * store it and encode it later by AFI-specific hooks.
! 459: */
! 460:
! 461: if (!s->mp_reach)
! 462: {
! 463: // ASSERT(a->u.ptr->length == sizeof(ip_addr));
! 464:
! 465: /* FIXME: skip IPv6 next hops for IPv4 routes during MRT dump */
! 466: ip_addr *addr = (void *) a->u.ptr->data;
! 467: if ((a->u.ptr->length != sizeof(ip_addr)) || !ipa_is_ip4(*addr))
! 468: return 0;
! 469:
! 470: if (size < (3+4))
! 471: return -1;
! 472:
! 473: bgp_put_attr_hdr3(buf, BA_NEXT_HOP, a->flags, 4);
! 474: put_ip4(buf+3, ipa_to_ip4(*addr));
! 475:
! 476: return 3+4;
! 477: }
! 478: else
! 479: {
! 480: s->mp_next_hop = a;
! 481: return 0;
! 482: }
! 483: }
! 484:
! 485: static void
! 486: bgp_decode_next_hop(struct bgp_parse_state *s, uint code UNUSED, uint flags UNUSED, byte *data, uint len, ea_list **to UNUSED)
! 487: {
! 488: if (len != 4)
! 489: WITHDRAW(BAD_LENGTH, "NEXT_HOP", len);
! 490:
! 491: /* Semantic checks are done later */
! 492: s->ip_next_hop_len = len;
! 493: s->ip_next_hop_data = data;
! 494: }
! 495:
! 496: /* TODO: This function should use AF-specific hook */
! 497: static void
! 498: bgp_format_next_hop(eattr *a, byte *buf, uint size UNUSED)
! 499: {
! 500: ip_addr *nh = (void *) a->u.ptr->data;
! 501: uint len = a->u.ptr->length;
! 502:
! 503: ASSERT((len == 16) || (len == 32));
! 504:
! 505: /* in IPv6, we may have two addresses in NEXT HOP */
! 506: if ((len == 16) || ipa_zero(nh[1]))
! 507: bsprintf(buf, "%I", nh[0]);
! 508: else
! 509: bsprintf(buf, "%I %I", nh[0], nh[1]);
! 510: }
! 511:
! 512:
! 513: static void
! 514: bgp_decode_med(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 515: {
! 516: if (len != 4)
! 517: WITHDRAW(BAD_LENGTH, "MULTI_EXIT_DISC", len);
! 518:
! 519: u32 val = get_u32(data);
! 520: bgp_set_attr_u32(to, s->pool, BA_MULTI_EXIT_DISC, flags, val);
! 521: }
! 522:
! 523:
! 524: static void
! 525: bgp_export_local_pref(struct bgp_export_state *s, eattr *a)
! 526: {
! 527: if (!s->proto->is_interior && !s->proto->cf->allow_local_pref)
! 528: UNSET(a);
! 529: }
! 530:
! 531: static void
! 532: bgp_decode_local_pref(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 533: {
! 534: if (!s->proto->is_interior && !s->proto->cf->allow_local_pref)
! 535: DISCARD(BAD_EBGP, "LOCAL_PREF");
! 536:
! 537: if (len != 4)
! 538: WITHDRAW(BAD_LENGTH, "LOCAL_PREF", len);
! 539:
! 540: u32 val = get_u32(data);
! 541: bgp_set_attr_u32(to, s->pool, BA_LOCAL_PREF, flags, val);
! 542: }
! 543:
! 544:
! 545: static void
! 546: bgp_decode_atomic_aggr(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data UNUSED, uint len, ea_list **to)
! 547: {
! 548: if (len != 0)
! 549: DISCARD(BAD_LENGTH, "ATOMIC_AGGR", len);
! 550:
! 551: bgp_set_attr_data(to, s->pool, BA_ATOMIC_AGGR, flags, NULL, 0);
! 552: }
! 553:
! 554: static int
! 555: bgp_encode_aggregator(struct bgp_write_state *s, eattr *a, byte *buf, uint size)
! 556: {
! 557: const byte *data = a->u.ptr->data;
! 558: uint len = a->u.ptr->length;
! 559:
! 560: if (!s->as4_session)
! 561: {
! 562: /* Prepare 16-bit AGGREGATOR (from 32-bit one) in a temporary buffer */
! 563: byte *dst = alloca(6);
! 564: len = aggregator_32to16(dst, data);
! 565: }
! 566:
! 567: return bgp_put_attr(buf, size, BA_AGGREGATOR, a->flags, data, len);
! 568: }
! 569:
! 570: static void
! 571: bgp_decode_aggregator(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 572: {
! 573: if (len != (s->as4_session ? 8 : 6))
! 574: DISCARD(BAD_LENGTH, "AGGREGATOR", len);
! 575:
! 576: if (!s->as4_session)
! 577: {
! 578: /* Prepare 32-bit AGGREGATOR (from 16-bit one) in a temporary buffer */
! 579: byte *src = data;
! 580: data = alloca(8);
! 581: len = aggregator_16to32(data, src);
! 582: }
! 583:
! 584: bgp_set_attr_data(to, s->pool, BA_AGGREGATOR, flags, data, len);
! 585: }
! 586:
! 587: static void
! 588: bgp_format_aggregator(eattr *a, byte *buf, uint size UNUSED)
! 589: {
! 590: const byte *data = a->u.ptr->data;
! 591:
! 592: bsprintf(buf, "%I4 AS%u", get_ip4(data+4), get_u32(data+0));
! 593: }
! 594:
! 595:
! 596: static void
! 597: bgp_export_community(struct bgp_export_state *s, eattr *a)
! 598: {
! 599: if (a->u.ptr->length == 0)
! 600: UNSET(a);
! 601:
! 602: a->u.ptr = int_set_sort(s->pool, a->u.ptr);
! 603: }
! 604:
! 605: static void
! 606: bgp_decode_community(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 607: {
! 608: if (!len || (len % 4))
! 609: WITHDRAW(BAD_LENGTH, "COMMUNITY", len);
! 610:
! 611: struct adata *ad = lp_alloc_adata(s->pool, len);
! 612: get_u32s(data, (u32 *) ad->data, len / 4);
! 613: bgp_set_attr_ptr(to, s->pool, BA_COMMUNITY, flags, ad);
! 614: }
! 615:
! 616:
! 617: static void
! 618: bgp_export_originator_id(struct bgp_export_state *s, eattr *a)
! 619: {
! 620: if (!s->proto->is_internal)
! 621: UNSET(a);
! 622: }
! 623:
! 624: static void
! 625: bgp_decode_originator_id(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 626: {
! 627: if (!s->proto->is_internal)
! 628: DISCARD(BAD_EBGP, "ORIGINATOR_ID");
! 629:
! 630: if (len != 4)
! 631: WITHDRAW(BAD_LENGTH, "ORIGINATOR_ID", len);
! 632:
! 633: u32 val = get_u32(data);
! 634: bgp_set_attr_u32(to, s->pool, BA_ORIGINATOR_ID, flags, val);
! 635: }
! 636:
! 637:
! 638: static void
! 639: bgp_export_cluster_list(struct bgp_export_state *s UNUSED, eattr *a)
! 640: {
! 641: if (!s->proto->is_internal)
! 642: UNSET(a);
! 643:
! 644: if (a->u.ptr->length == 0)
! 645: UNSET(a);
! 646: }
! 647:
! 648: static void
! 649: bgp_decode_cluster_list(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 650: {
! 651: if (!s->proto->is_internal)
! 652: DISCARD(BAD_EBGP, "CLUSTER_LIST");
! 653:
! 654: if (!len || (len % 4))
! 655: WITHDRAW(BAD_LENGTH, "CLUSTER_LIST", len);
! 656:
! 657: struct adata *ad = lp_alloc_adata(s->pool, len);
! 658: get_u32s(data, (u32 *) ad->data, len / 4);
! 659: bgp_set_attr_ptr(to, s->pool, BA_CLUSTER_LIST, flags, ad);
! 660: }
! 661:
! 662: static void
! 663: bgp_format_cluster_list(eattr *a, byte *buf, uint size)
! 664: {
! 665: /* Truncates cluster lists larger than buflen, probably not a problem */
! 666: int_set_format(a->u.ptr, 0, -1, buf, size);
! 667: }
! 668:
! 669:
! 670: static inline u32
! 671: get_af3(byte *buf)
! 672: {
! 673: return (get_u16(buf) << 16) | buf[2];
! 674: }
! 675:
! 676: static void
! 677: bgp_decode_mp_reach_nlri(struct bgp_parse_state *s, uint code UNUSED, uint flags UNUSED, byte *data, uint len, ea_list **to UNUSED)
! 678: {
! 679: /*
! 680: * 2 B MP_REACH_NLRI data - Address Family Identifier
! 681: * 1 B MP_REACH_NLRI data - Subsequent Address Family Identifier
! 682: * 1 B MP_REACH_NLRI data - Length of Next Hop Network Address
! 683: * var MP_REACH_NLRI data - Network Address of Next Hop
! 684: * 1 B MP_REACH_NLRI data - Reserved (zero)
! 685: * var MP_REACH_NLRI data - Network Layer Reachability Information
! 686: */
! 687:
! 688: if ((len < 5) || (len < (5 + (uint) data[3])))
! 689: bgp_parse_error(s, 9);
! 690:
! 691: s->mp_reach_af = get_af3(data);
! 692: s->mp_next_hop_len = data[3];
! 693: s->mp_next_hop_data = data + 4;
! 694: s->mp_reach_len = len - 5 - s->mp_next_hop_len;
! 695: s->mp_reach_nlri = data + 5 + s->mp_next_hop_len;
! 696: }
! 697:
! 698:
! 699: static void
! 700: bgp_decode_mp_unreach_nlri(struct bgp_parse_state *s, uint code UNUSED, uint flags UNUSED, byte *data, uint len, ea_list **to UNUSED)
! 701: {
! 702: /*
! 703: * 2 B MP_UNREACH_NLRI data - Address Family Identifier
! 704: * 1 B MP_UNREACH_NLRI data - Subsequent Address Family Identifier
! 705: * var MP_UNREACH_NLRI data - Network Layer Reachability Information
! 706: */
! 707:
! 708: if (len < 3)
! 709: bgp_parse_error(s, 9);
! 710:
! 711: s->mp_unreach_af = get_af3(data);
! 712: s->mp_unreach_len = len - 3;
! 713: s->mp_unreach_nlri = data + 3;
! 714: }
! 715:
! 716:
! 717: static void
! 718: bgp_export_ext_community(struct bgp_export_state *s, eattr *a)
! 719: {
! 720: struct adata *ad = ec_set_del_nontrans(s->pool, a->u.ptr);
! 721:
! 722: if (ad->length == 0)
! 723: UNSET(a);
! 724:
! 725: ec_set_sort_x(ad);
! 726: a->u.ptr = ad;
! 727: }
! 728:
! 729: static void
! 730: bgp_decode_ext_community(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 731: {
! 732: if (!len || (len % 8))
! 733: WITHDRAW(BAD_LENGTH, "EXT_COMMUNITY", len);
! 734:
! 735: struct adata *ad = lp_alloc_adata(s->pool, len);
! 736: get_u32s(data, (u32 *) ad->data, len / 4);
! 737: bgp_set_attr_ptr(to, s->pool, BA_EXT_COMMUNITY, flags, ad);
! 738: }
! 739:
! 740:
! 741: static void
! 742: bgp_decode_as4_aggregator(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 743: {
! 744: if (s->as4_session)
! 745: DISCARD(NEW_BGP, "AS4_AGGREGATOR");
! 746:
! 747: if (len != 8)
! 748: DISCARD(BAD_LENGTH, "AS4_AGGREGATOR", len);
! 749:
! 750: bgp_set_attr_data(to, s->pool, BA_AS4_AGGREGATOR, flags, data, len);
! 751: }
! 752:
! 753: static void
! 754: bgp_decode_as4_path(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 755: {
! 756: char err[128];
! 757:
! 758: if (s->as4_session)
! 759: DISCARD(NEW_BGP, "AS4_PATH");
! 760:
! 761: if (len < 6)
! 762: DISCARD(BAD_LENGTH, "AS4_PATH", len);
! 763:
! 764: if (!as_path_valid(data, len, 4, 1, err, sizeof(err)))
! 765: DISCARD("Malformed AS4_PATH attribute - %s", err);
! 766:
! 767: struct adata *a = lp_alloc_adata(s->pool, len);
! 768: memcpy(a->data, data, len);
! 769:
! 770: /* AS_CONFED* segments are invalid in AS4_PATH; RFC 6793 6 */
! 771: if (as_path_contains_confed(a))
! 772: {
! 773: REPORT("Discarding AS_CONFED* segment from AS4_PATH attribute");
! 774: a = as_path_strip_confed(s->pool, a);
! 775: }
! 776:
! 777: bgp_set_attr_ptr(to, s->pool, BA_AS4_PATH, flags, a);
! 778: }
! 779:
! 780:
! 781: static void
! 782: bgp_export_aigp(struct bgp_export_state *s, eattr *a)
! 783: {
! 784: if (!s->channel->cf->aigp)
! 785: UNSET(a);
! 786: }
! 787:
! 788: static void
! 789: bgp_decode_aigp(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 790: {
! 791: char err[128];
! 792:
! 793: /* Acceptability test postponed to bgp_finish_attrs() */
! 794:
! 795: if ((flags ^ bgp_attr_table[BA_AIGP].flags) & (BAF_OPTIONAL | BAF_TRANSITIVE))
! 796: DISCARD("Malformed AIGP attribute - conflicting flags (%02x)", flags);
! 797:
! 798: if (!bgp_aigp_valid(data, len, err, sizeof(err)))
! 799: DISCARD("Malformed AIGP attribute - %s", err);
! 800:
! 801: bgp_set_attr_data(to, s->pool, BA_AIGP, flags, data, len);
! 802: }
! 803:
! 804: static void
! 805: bgp_format_aigp(eattr *a, byte *buf, uint size UNUSED)
! 806: {
! 807: const byte *b = bgp_aigp_get_tlv(a->u.ptr, BGP_AIGP_METRIC);
! 808:
! 809: if (!b)
! 810: bsprintf(buf, "?");
! 811: else
! 812: bsprintf(buf, "%lu", get_u64(b + 3));
! 813: }
! 814:
! 815:
! 816: static void
! 817: bgp_export_large_community(struct bgp_export_state *s, eattr *a)
! 818: {
! 819: if (a->u.ptr->length == 0)
! 820: UNSET(a);
! 821:
! 822: a->u.ptr = lc_set_sort(s->pool, a->u.ptr);
! 823: }
! 824:
! 825: static void
! 826: bgp_decode_large_community(struct bgp_parse_state *s, uint code UNUSED, uint flags, byte *data, uint len, ea_list **to)
! 827: {
! 828: if (!len || (len % 12))
! 829: WITHDRAW(BAD_LENGTH, "LARGE_COMMUNITY", len);
! 830:
! 831: struct adata *ad = lp_alloc_adata(s->pool, len);
! 832: get_u32s(data, (u32 *) ad->data, len / 4);
! 833: bgp_set_attr_ptr(to, s->pool, BA_LARGE_COMMUNITY, flags, ad);
! 834: }
! 835:
! 836: static void
! 837: bgp_export_mpls_label_stack(struct bgp_export_state *s, eattr *a)
! 838: {
! 839: net_addr *n = s->route->net->n.addr;
! 840: u32 *labels = (u32 *) a->u.ptr->data;
! 841: uint lnum = a->u.ptr->length / 4;
! 842:
! 843: /* Perhaps we should just ignore it? */
! 844: if (!s->mpls)
! 845: WITHDRAW("Unexpected MPLS stack");
! 846:
! 847: /* Empty MPLS stack is not allowed */
! 848: if (!lnum)
! 849: WITHDRAW("Malformed MPLS stack - empty");
! 850:
! 851: /* This is ugly, but we must ensure that labels fit into NLRI field */
! 852: if ((24*lnum + (net_is_vpn(n) ? 64 : 0) + net_pxlen(n)) > 255)
! 853: WITHDRAW("Malformed MPLS stack - too many labels (%u)", lnum);
! 854:
! 855: for (uint i = 0; i < lnum; i++)
! 856: {
! 857: if (labels[i] > 0xfffff)
! 858: WITHDRAW("Malformed MPLS stack - invalid label (%u)", labels[i]);
! 859:
! 860: /* TODO: Check for special-purpose label values? */
! 861: }
! 862: }
! 863:
! 864: static int
! 865: bgp_encode_mpls_label_stack(struct bgp_write_state *s, eattr *a, byte *buf UNUSED, uint size UNUSED)
! 866: {
! 867: /*
! 868: * MPLS labels are encoded as a part of the NLRI in MP_REACH_NLRI attribute,
! 869: * so we store MPLS_LABEL_STACK and encode it later by AFI-specific hooks.
! 870: */
! 871:
! 872: s->mpls_labels = a->u.ptr;
! 873: return 0;
! 874: }
! 875:
! 876: static void
! 877: bgp_decode_mpls_label_stack(struct bgp_parse_state *s, uint code UNUSED, uint flags UNUSED, byte *data UNUSED, uint len UNUSED, ea_list **to UNUSED)
! 878: {
! 879: DISCARD("Discarding received attribute #0");
! 880: }
! 881:
! 882: static void
! 883: bgp_format_mpls_label_stack(eattr *a, byte *buf, uint size)
! 884: {
! 885: u32 *labels = (u32 *) a->u.ptr->data;
! 886: uint lnum = a->u.ptr->length / 4;
! 887: char *pos = buf;
! 888:
! 889: for (uint i = 0; i < lnum; i++)
! 890: {
! 891: if (size < 20)
! 892: {
! 893: bsprintf(pos, "...");
! 894: return;
! 895: }
! 896:
! 897: uint l = bsprintf(pos, "%d/", labels[i]);
! 898: ADVANCE(pos, size, l);
! 899: }
! 900:
! 901: /* Clear last slash or terminate empty string */
! 902: pos[lnum ? -1 : 0] = 0;
! 903: }
! 904:
! 905: static inline void
! 906: bgp_decode_unknown(struct bgp_parse_state *s, uint code, uint flags, byte *data, uint len, ea_list **to)
! 907: {
! 908: /* Cannot use bgp_set_attr_data() as it works on known attributes only */
! 909: ea_set_attr_data(to, s->pool, EA_CODE(PROTOCOL_BGP, code), flags, EAF_TYPE_OPAQUE, data, len);
! 910: }
! 911:
! 912:
! 913: /*
! 914: * Attribute table
! 915: */
! 916:
! 917: static const struct bgp_attr_desc bgp_attr_table[] = {
! 918: [BA_ORIGIN] = {
! 919: .name = "origin",
! 920: .type = EAF_TYPE_INT,
! 921: .flags = BAF_TRANSITIVE,
! 922: .export = bgp_export_origin,
! 923: .encode = bgp_encode_u8,
! 924: .decode = bgp_decode_origin,
! 925: .format = bgp_format_origin,
! 926: },
! 927: [BA_AS_PATH] = {
! 928: .name = "as_path",
! 929: .type = EAF_TYPE_AS_PATH,
! 930: .flags = BAF_TRANSITIVE,
! 931: .encode = bgp_encode_as_path,
! 932: .decode = bgp_decode_as_path,
! 933: },
! 934: [BA_NEXT_HOP] = {
! 935: .name = "next_hop",
! 936: .type = EAF_TYPE_IP_ADDRESS,
! 937: .flags = BAF_TRANSITIVE,
! 938: .encode = bgp_encode_next_hop,
! 939: .decode = bgp_decode_next_hop,
! 940: .format = bgp_format_next_hop,
! 941: },
! 942: [BA_MULTI_EXIT_DISC] = {
! 943: .name = "med",
! 944: .type = EAF_TYPE_INT,
! 945: .flags = BAF_OPTIONAL,
! 946: .encode = bgp_encode_u32,
! 947: .decode = bgp_decode_med,
! 948: },
! 949: [BA_LOCAL_PREF] = {
! 950: .name = "local_pref",
! 951: .type = EAF_TYPE_INT,
! 952: .flags = BAF_TRANSITIVE,
! 953: .export = bgp_export_local_pref,
! 954: .encode = bgp_encode_u32,
! 955: .decode = bgp_decode_local_pref,
! 956: },
! 957: [BA_ATOMIC_AGGR] = {
! 958: .name = "atomic_aggr",
! 959: .type = EAF_TYPE_OPAQUE,
! 960: .flags = BAF_TRANSITIVE,
! 961: .encode = bgp_encode_raw,
! 962: .decode = bgp_decode_atomic_aggr,
! 963: },
! 964: [BA_AGGREGATOR] = {
! 965: .name = "aggregator",
! 966: .type = EAF_TYPE_OPAQUE,
! 967: .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
! 968: .encode = bgp_encode_aggregator,
! 969: .decode = bgp_decode_aggregator,
! 970: .format = bgp_format_aggregator,
! 971: },
! 972: [BA_COMMUNITY] = {
! 973: .name = "community",
! 974: .type = EAF_TYPE_INT_SET,
! 975: .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
! 976: .export = bgp_export_community,
! 977: .encode = bgp_encode_u32s,
! 978: .decode = bgp_decode_community,
! 979: },
! 980: [BA_ORIGINATOR_ID] = {
! 981: .name = "originator_id",
! 982: .type = EAF_TYPE_ROUTER_ID,
! 983: .flags = BAF_OPTIONAL,
! 984: .export = bgp_export_originator_id,
! 985: .encode = bgp_encode_u32,
! 986: .decode = bgp_decode_originator_id,
! 987: },
! 988: [BA_CLUSTER_LIST] = {
! 989: .name = "cluster_list",
! 990: .type = EAF_TYPE_INT_SET,
! 991: .flags = BAF_OPTIONAL,
! 992: .export = bgp_export_cluster_list,
! 993: .encode = bgp_encode_u32s,
! 994: .decode = bgp_decode_cluster_list,
! 995: .format = bgp_format_cluster_list,
! 996: },
! 997: [BA_MP_REACH_NLRI] = {
! 998: .name = "mp_reach_nlri",
! 999: .type = EAF_TYPE_OPAQUE,
! 1000: .flags = BAF_OPTIONAL,
! 1001: .decode = bgp_decode_mp_reach_nlri,
! 1002: },
! 1003: [BA_MP_UNREACH_NLRI] = {
! 1004: .name = "mp_unreach_nlri",
! 1005: .type = EAF_TYPE_OPAQUE,
! 1006: .flags = BAF_OPTIONAL,
! 1007: .decode = bgp_decode_mp_unreach_nlri,
! 1008: },
! 1009: [BA_EXT_COMMUNITY] = {
! 1010: .name = "ext_community",
! 1011: .type = EAF_TYPE_EC_SET,
! 1012: .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
! 1013: .export = bgp_export_ext_community,
! 1014: .encode = bgp_encode_u32s,
! 1015: .decode = bgp_decode_ext_community,
! 1016: },
! 1017: [BA_AS4_PATH] = {
! 1018: .name = "as4_path",
! 1019: .type = EAF_TYPE_AS_PATH,
! 1020: .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
! 1021: .encode = bgp_encode_raw,
! 1022: .decode = bgp_decode_as4_path,
! 1023: },
! 1024: [BA_AS4_AGGREGATOR] = {
! 1025: .name = "as4_aggregator",
! 1026: .type = EAF_TYPE_OPAQUE,
! 1027: .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
! 1028: .encode = bgp_encode_raw,
! 1029: .decode = bgp_decode_as4_aggregator,
! 1030: .format = bgp_format_aggregator,
! 1031: },
! 1032: [BA_AIGP] = {
! 1033: .name = "aigp",
! 1034: .type = EAF_TYPE_OPAQUE,
! 1035: .flags = BAF_OPTIONAL | BAF_DECODE_FLAGS,
! 1036: .export = bgp_export_aigp,
! 1037: .encode = bgp_encode_raw,
! 1038: .decode = bgp_decode_aigp,
! 1039: .format = bgp_format_aigp,
! 1040: },
! 1041: [BA_LARGE_COMMUNITY] = {
! 1042: .name = "large_community",
! 1043: .type = EAF_TYPE_LC_SET,
! 1044: .flags = BAF_OPTIONAL | BAF_TRANSITIVE,
! 1045: .export = bgp_export_large_community,
! 1046: .encode = bgp_encode_u32s,
! 1047: .decode = bgp_decode_large_community,
! 1048: },
! 1049: [BA_MPLS_LABEL_STACK] = {
! 1050: .name = "mpls_label_stack",
! 1051: .type = EAF_TYPE_INT_SET,
! 1052: .export = bgp_export_mpls_label_stack,
! 1053: .encode = bgp_encode_mpls_label_stack,
! 1054: .decode = bgp_decode_mpls_label_stack,
! 1055: .format = bgp_format_mpls_label_stack,
! 1056: },
! 1057: };
! 1058:
! 1059: static inline int
! 1060: bgp_attr_known(uint code)
! 1061: {
! 1062: return (code < ARRAY_SIZE(bgp_attr_table)) && bgp_attr_table[code].name;
! 1063: }
! 1064:
! 1065:
! 1066: /*
! 1067: * Attribute export
! 1068: */
! 1069:
! 1070: static inline void
! 1071: bgp_export_attr(struct bgp_export_state *s, eattr *a, ea_list *to)
! 1072: {
! 1073: if (EA_PROTO(a->id) != PROTOCOL_BGP)
! 1074: return;
! 1075:
! 1076: uint code = EA_ID(a->id);
! 1077:
! 1078: if (bgp_attr_known(code))
! 1079: {
! 1080: const struct bgp_attr_desc *desc = &bgp_attr_table[code];
! 1081:
! 1082: /* The flags might have been zero if the attr was added by filters */
! 1083: a->flags = (a->flags & BAF_PARTIAL) | desc->flags;
! 1084:
! 1085: /* Set partial bit if new opt-trans attribute is attached to non-local route */
! 1086: if ((s->src != NULL) && (a->type & EAF_ORIGINATED) &&
! 1087: (a->flags & BAF_OPTIONAL) && (a->flags & BAF_TRANSITIVE))
! 1088: a->flags |= BAF_PARTIAL;
! 1089:
! 1090: /* Call specific hook */
! 1091: CALL(desc->export, s, a);
! 1092:
! 1093: /* Attribute might become undefined in hook */
! 1094: if ((a->type & EAF_TYPE_MASK) == EAF_TYPE_UNDEF)
! 1095: return;
! 1096: }
! 1097: else
! 1098: {
! 1099: /* Don't re-export unknown non-transitive attributes */
! 1100: if (!(a->flags & BAF_TRANSITIVE))
! 1101: return;
! 1102:
! 1103: a->flags |= BAF_PARTIAL;
! 1104: }
! 1105:
! 1106: /* Append updated attribute */
! 1107: to->attrs[to->count++] = *a;
! 1108: }
! 1109:
! 1110: /**
! 1111: * bgp_export_attrs - export BGP attributes
! 1112: * @s: BGP export state
! 1113: * @attrs: a list of extended attributes
! 1114: *
! 1115: * The bgp_export_attrs() function takes a list of attributes and merges it to
! 1116: * one newly allocated and sorted segment. Attributes are validated and
! 1117: * normalized by type-specific export hooks and attribute flags are updated.
! 1118: * Some attributes may be eliminated (e.g. unknown non-tranitive attributes, or
! 1119: * empty community sets).
! 1120: *
! 1121: * Result: one sorted attribute list segment, or NULL if attributes are unsuitable.
! 1122: */
! 1123: static inline ea_list *
! 1124: bgp_export_attrs(struct bgp_export_state *s, ea_list *attrs)
! 1125: {
! 1126: /* Merge the attribute list */
! 1127: ea_list *new = lp_alloc(s->pool, ea_scan(attrs));
! 1128: ea_merge(attrs, new);
! 1129: ea_sort(new);
! 1130:
! 1131: uint i, count;
! 1132: count = new->count;
! 1133: new->count = 0;
! 1134:
! 1135: /* Export each attribute */
! 1136: for (i = 0; i < count; i++)
! 1137: bgp_export_attr(s, &new->attrs[i], new);
! 1138:
! 1139: if (s->err_withdraw)
! 1140: return NULL;
! 1141:
! 1142: return new;
! 1143: }
! 1144:
! 1145:
! 1146: /*
! 1147: * Attribute encoding
! 1148: */
! 1149:
! 1150: static inline int
! 1151: bgp_encode_attr(struct bgp_write_state *s, eattr *a, byte *buf, uint size)
! 1152: {
! 1153: ASSERT(EA_PROTO(a->id) == PROTOCOL_BGP);
! 1154:
! 1155: uint code = EA_ID(a->id);
! 1156:
! 1157: if (bgp_attr_known(code))
! 1158: return bgp_attr_table[code].encode(s, a, buf, size);
! 1159: else
! 1160: return bgp_encode_raw(s, a, buf, size);
! 1161: }
! 1162:
! 1163: /**
! 1164: * bgp_encode_attrs - encode BGP attributes
! 1165: * @s: BGP write state
! 1166: * @attrs: a list of extended attributes
! 1167: * @buf: buffer
! 1168: * @end: buffer end
! 1169: *
! 1170: * The bgp_encode_attrs() function takes a list of extended attributes
! 1171: * and converts it to its BGP representation (a part of an Update message).
! 1172: * BGP write state may be fake when called from MRT protocol.
! 1173: *
! 1174: * Result: Length of the attribute block generated or -1 if not enough space.
! 1175: */
! 1176: int
! 1177: bgp_encode_attrs(struct bgp_write_state *s, ea_list *attrs, byte *buf, byte *end)
! 1178: {
! 1179: byte *pos = buf;
! 1180: int i, len;
! 1181:
! 1182: for (i = 0; i < attrs->count; i++)
! 1183: {
! 1184: len = bgp_encode_attr(s, &attrs->attrs[i], pos, end - pos);
! 1185:
! 1186: if (len < 0)
! 1187: return -1;
! 1188:
! 1189: pos += len;
! 1190: }
! 1191:
! 1192: return pos - buf;
! 1193: }
! 1194:
! 1195:
! 1196: /*
! 1197: * Attribute decoding
! 1198: */
! 1199:
! 1200: static void bgp_process_as4_attrs(ea_list **attrs, struct linpool *pool);
! 1201:
! 1202: static inline int
! 1203: bgp_as_path_loopy(struct bgp_proto *p, ea_list *attrs, u32 asn)
! 1204: {
! 1205: eattr *e = bgp_find_attr(attrs, BA_AS_PATH);
! 1206: int num = p->cf->allow_local_as + 1;
! 1207: return (e && (num > 0) && as_path_contains(e->u.ptr, asn, num));
! 1208: }
! 1209:
! 1210: static inline int
! 1211: bgp_originator_id_loopy(struct bgp_proto *p, ea_list *attrs)
! 1212: {
! 1213: eattr *e = bgp_find_attr(attrs, BA_ORIGINATOR_ID);
! 1214: return (e && (e->u.data == p->local_id));
! 1215: }
! 1216:
! 1217: static inline int
! 1218: bgp_cluster_list_loopy(struct bgp_proto *p, ea_list *attrs)
! 1219: {
! 1220: eattr *e = bgp_find_attr(attrs, BA_CLUSTER_LIST);
! 1221: return (e && int_set_contains(e->u.ptr, p->rr_cluster_id));
! 1222: }
! 1223:
! 1224: static inline void
! 1225: bgp_decode_attr(struct bgp_parse_state *s, uint code, uint flags, byte *data, uint len, ea_list **to)
! 1226: {
! 1227: /* Handle duplicate attributes; RFC 7606 3 (g) */
! 1228: if (BIT32_TEST(s->attrs_seen, code))
! 1229: {
! 1230: if ((code == BA_MP_REACH_NLRI) || (code == BA_MP_UNREACH_NLRI))
! 1231: bgp_parse_error(s, 1);
! 1232: else
! 1233: DISCARD("Discarding duplicate attribute (code %u)", code);
! 1234: }
! 1235: BIT32_SET(s->attrs_seen, code);
! 1236:
! 1237: if (bgp_attr_known(code))
! 1238: {
! 1239: const struct bgp_attr_desc *desc = &bgp_attr_table[code];
! 1240:
! 1241: /* Handle conflicting flags; RFC 7606 3 (c) */
! 1242: if (((flags ^ desc->flags) & (BAF_OPTIONAL | BAF_TRANSITIVE)) &&
! 1243: !(desc->flags & BAF_DECODE_FLAGS))
! 1244: WITHDRAW("Malformed %s attribute - conflicting flags (%02x)", desc->name, flags);
! 1245:
! 1246: desc->decode(s, code, flags, data, len, to);
! 1247: }
! 1248: else /* Unknown attribute */
! 1249: {
! 1250: if (!(flags & BAF_OPTIONAL))
! 1251: WITHDRAW("Unknown attribute (code %u) - conflicting flags (%02x)", code, flags);
! 1252:
! 1253: bgp_decode_unknown(s, code, flags, data, len, to);
! 1254: }
! 1255: }
! 1256:
! 1257: /**
! 1258: * bgp_decode_attrs - check and decode BGP attributes
! 1259: * @s: BGP parse state
! 1260: * @data: start of attribute block
! 1261: * @len: length of attribute block
! 1262: *
! 1263: * This function takes a BGP attribute block (a part of an Update message), checks
! 1264: * its consistency and converts it to a list of BIRD route attributes represented
! 1265: * by an (uncached) &rta.
! 1266: */
! 1267: ea_list *
! 1268: bgp_decode_attrs(struct bgp_parse_state *s, byte *data, uint len)
! 1269: {
! 1270: struct bgp_proto *p = s->proto;
! 1271: ea_list *attrs = NULL;
! 1272: uint code, flags, alen;
! 1273: byte *pos = data;
! 1274:
! 1275: /* Parse the attributes */
! 1276: while (len)
! 1277: {
! 1278: alen = 0;
! 1279:
! 1280: /* Read attribute type */
! 1281: if (len < 2)
! 1282: goto framing_error;
! 1283: flags = pos[0];
! 1284: code = pos[1];
! 1285: ADVANCE(pos, len, 2);
! 1286:
! 1287: /* Read attribute length */
! 1288: if (flags & BAF_EXT_LEN)
! 1289: {
! 1290: if (len < 2)
! 1291: goto framing_error;
! 1292: alen = get_u16(pos);
! 1293: ADVANCE(pos, len, 2);
! 1294: }
! 1295: else
! 1296: {
! 1297: if (len < 1)
! 1298: goto framing_error;
! 1299: alen = *pos;
! 1300: ADVANCE(pos, len, 1);
! 1301: }
! 1302:
! 1303: if (alen > len)
! 1304: goto framing_error;
! 1305:
! 1306: DBG("Attr %02x %02x %u\n", code, flags, alen);
! 1307:
! 1308: bgp_decode_attr(s, code, flags, pos, alen, &attrs);
! 1309: ADVANCE(pos, len, alen);
! 1310: }
! 1311:
! 1312: if (s->err_withdraw)
! 1313: goto withdraw;
! 1314:
! 1315: /* If there is no reachability NLRI, we are finished */
! 1316: if (!s->ip_reach_len && !s->mp_reach_len)
! 1317: return NULL;
! 1318:
! 1319:
! 1320: /* Handle missing mandatory attributes; RFC 7606 3 (d) */
! 1321: if (!BIT32_TEST(s->attrs_seen, BA_ORIGIN))
! 1322: { REPORT(NO_MANDATORY, "ORIGIN"); goto withdraw; }
! 1323:
! 1324: if (!BIT32_TEST(s->attrs_seen, BA_AS_PATH))
! 1325: { REPORT(NO_MANDATORY, "AS_PATH"); goto withdraw; }
! 1326:
! 1327: if (s->ip_reach_len && !BIT32_TEST(s->attrs_seen, BA_NEXT_HOP))
! 1328: { REPORT(NO_MANDATORY, "NEXT_HOP"); goto withdraw; }
! 1329:
! 1330: /* When receiving attributes from non-AS4-aware BGP speaker, we have to
! 1331: reconstruct AS_PATH and AGGREGATOR attributes; RFC 6793 4.2.3 */
! 1332: if (!p->as4_session)
! 1333: bgp_process_as4_attrs(&attrs, s->pool);
! 1334:
! 1335: /* Reject routes with our ASN in AS_PATH attribute */
! 1336: if (bgp_as_path_loopy(p, attrs, p->local_as))
! 1337: goto withdraw;
! 1338:
! 1339: /* Reject routes with our Confederation ID in AS_PATH attribute; RFC 5065 4.0 */
! 1340: if ((p->public_as != p->local_as) && bgp_as_path_loopy(p, attrs, p->public_as))
! 1341: goto withdraw;
! 1342:
! 1343: /* Reject routes with our Router ID in ORIGINATOR_ID attribute; RFC 4456 8 */
! 1344: if (p->is_internal && bgp_originator_id_loopy(p, attrs))
! 1345: goto withdraw;
! 1346:
! 1347: /* Reject routes with our Cluster ID in CLUSTER_LIST attribute; RFC 4456 8 */
! 1348: if (p->rr_client && bgp_cluster_list_loopy(p, attrs))
! 1349: goto withdraw;
! 1350:
! 1351: /* If there is no local preference, define one */
! 1352: if (!BIT32_TEST(s->attrs_seen, BA_LOCAL_PREF))
! 1353: bgp_set_attr_u32(&attrs, s->pool, BA_LOCAL_PREF, 0, p->cf->default_local_pref);
! 1354:
! 1355: return attrs;
! 1356:
! 1357:
! 1358: framing_error:
! 1359: /* RFC 7606 4 - handle attribute framing errors */
! 1360: REPORT("Malformed attribute list - framing error (%u/%u) at %d",
! 1361: alen, len, (int) (pos - s->attrs));
! 1362:
! 1363: withdraw:
! 1364: /* RFC 7606 5.2 - handle missing NLRI during errors */
! 1365: if (!s->ip_reach_len && !s->mp_reach_len)
! 1366: bgp_parse_error(s, 1);
! 1367:
! 1368: s->err_withdraw = 1;
! 1369: return NULL;
! 1370: }
! 1371:
! 1372: void
! 1373: bgp_finish_attrs(struct bgp_parse_state *s, rta *a)
! 1374: {
! 1375: /* AIGP test here instead of in bgp_decode_aigp() - we need to know channel */
! 1376: if (BIT32_TEST(s->attrs_seen, BA_AIGP) && !s->channel->cf->aigp)
! 1377: {
! 1378: REPORT("Discarding AIGP attribute received on non-AIGP session");
! 1379: bgp_unset_attr(&a->eattrs, s->pool, BA_AIGP);
! 1380: }
! 1381: }
! 1382:
! 1383:
! 1384: /*
! 1385: * Route bucket hash table
! 1386: */
! 1387:
! 1388: #define RBH_KEY(b) b->eattrs, b->hash
! 1389: #define RBH_NEXT(b) b->next
! 1390: #define RBH_EQ(a1,h1,a2,h2) h1 == h2 && ea_same(a1, a2)
! 1391: #define RBH_FN(a,h) h
! 1392:
! 1393: #define RBH_REHASH bgp_rbh_rehash
! 1394: #define RBH_PARAMS /8, *2, 2, 2, 8, 20
! 1395:
! 1396:
! 1397: HASH_DEFINE_REHASH_FN(RBH, struct bgp_bucket)
! 1398:
! 1399: void
! 1400: bgp_init_bucket_table(struct bgp_channel *c)
! 1401: {
! 1402: HASH_INIT(c->bucket_hash, c->pool, 8);
! 1403:
! 1404: init_list(&c->bucket_queue);
! 1405: c->withdraw_bucket = NULL;
! 1406: }
! 1407:
! 1408: void
! 1409: bgp_free_bucket_table(struct bgp_channel *c)
! 1410: {
! 1411: HASH_FREE(c->bucket_hash);
! 1412:
! 1413: struct bgp_bucket *b;
! 1414: WALK_LIST_FIRST(b, c->bucket_queue)
! 1415: {
! 1416: rem_node(&b->send_node);
! 1417: mb_free(b);
! 1418: }
! 1419:
! 1420: mb_free(c->withdraw_bucket);
! 1421: c->withdraw_bucket = NULL;
! 1422: }
! 1423:
! 1424: static struct bgp_bucket *
! 1425: bgp_get_bucket(struct bgp_channel *c, ea_list *new)
! 1426: {
! 1427: /* Hash and lookup */
! 1428: u32 hash = ea_hash(new);
! 1429: struct bgp_bucket *b = HASH_FIND(c->bucket_hash, RBH, new, hash);
! 1430:
! 1431: if (b)
! 1432: return b;
! 1433:
! 1434: uint ea_size = sizeof(ea_list) + new->count * sizeof(eattr);
! 1435: uint ea_size_aligned = BIRD_ALIGN(ea_size, CPU_STRUCT_ALIGN);
! 1436: uint size = sizeof(struct bgp_bucket) + ea_size_aligned;
! 1437: uint i;
! 1438: byte *dest;
! 1439:
! 1440: /* Gather total size of non-inline attributes */
! 1441: for (i = 0; i < new->count; i++)
! 1442: {
! 1443: eattr *a = &new->attrs[i];
! 1444:
! 1445: if (!(a->type & EAF_EMBEDDED))
! 1446: size += BIRD_ALIGN(sizeof(struct adata) + a->u.ptr->length, CPU_STRUCT_ALIGN);
! 1447: }
! 1448:
! 1449: /* Create the bucket */
! 1450: b = mb_alloc(c->pool, size);
! 1451: init_list(&b->prefixes);
! 1452: b->hash = hash;
! 1453:
! 1454: /* Copy list of extended attributes */
! 1455: memcpy(b->eattrs, new, ea_size);
! 1456: dest = ((byte *) b->eattrs) + ea_size_aligned;
! 1457:
! 1458: /* Copy values of non-inline attributes */
! 1459: for (i = 0; i < new->count; i++)
! 1460: {
! 1461: eattr *a = &b->eattrs->attrs[i];
! 1462:
! 1463: if (!(a->type & EAF_EMBEDDED))
! 1464: {
! 1465: const struct adata *oa = a->u.ptr;
! 1466: struct adata *na = (struct adata *) dest;
! 1467: memcpy(na, oa, sizeof(struct adata) + oa->length);
! 1468: a->u.ptr = na;
! 1469: dest += BIRD_ALIGN(sizeof(struct adata) + na->length, CPU_STRUCT_ALIGN);
! 1470: }
! 1471: }
! 1472:
! 1473: /* Insert the bucket to send queue and bucket hash */
! 1474: add_tail(&c->bucket_queue, &b->send_node);
! 1475: HASH_INSERT2(c->bucket_hash, RBH, c->pool, b);
! 1476:
! 1477: return b;
! 1478: }
! 1479:
! 1480: static struct bgp_bucket *
! 1481: bgp_get_withdraw_bucket(struct bgp_channel *c)
! 1482: {
! 1483: if (!c->withdraw_bucket)
! 1484: {
! 1485: c->withdraw_bucket = mb_allocz(c->pool, sizeof(struct bgp_bucket));
! 1486: init_list(&c->withdraw_bucket->prefixes);
! 1487: }
! 1488:
! 1489: return c->withdraw_bucket;
! 1490: }
! 1491:
! 1492: void
! 1493: bgp_free_bucket(struct bgp_channel *c, struct bgp_bucket *b)
! 1494: {
! 1495: rem_node(&b->send_node);
! 1496: HASH_REMOVE2(c->bucket_hash, RBH, c->pool, b);
! 1497: mb_free(b);
! 1498: }
! 1499:
! 1500: void
! 1501: bgp_defer_bucket(struct bgp_channel *c, struct bgp_bucket *b)
! 1502: {
! 1503: rem_node(&b->send_node);
! 1504: add_tail(&c->bucket_queue, &b->send_node);
! 1505: }
! 1506:
! 1507: void
! 1508: bgp_withdraw_bucket(struct bgp_channel *c, struct bgp_bucket *b)
! 1509: {
! 1510: struct bgp_proto *p = (void *) c->c.proto;
! 1511: struct bgp_bucket *wb = bgp_get_withdraw_bucket(c);
! 1512:
! 1513: log(L_ERR "%s: Attribute list too long", p->p.name);
! 1514: while (!EMPTY_LIST(b->prefixes))
! 1515: {
! 1516: struct bgp_prefix *px = HEAD(b->prefixes);
! 1517:
! 1518: log(L_ERR "%s: - withdrawing %N", p->p.name, &px->net);
! 1519: rem_node(&px->buck_node);
! 1520: add_tail(&wb->prefixes, &px->buck_node);
! 1521: }
! 1522: }
! 1523:
! 1524:
! 1525: /*
! 1526: * Prefix hash table
! 1527: */
! 1528:
! 1529: #define PXH_KEY(px) px->net, px->path_id, px->hash
! 1530: #define PXH_NEXT(px) px->next
! 1531: #define PXH_EQ(n1,i1,h1,n2,i2,h2) h1 == h2 && i1 == i2 && net_equal(n1, n2)
! 1532: #define PXH_FN(n,i,h) h
! 1533:
! 1534: #define PXH_REHASH bgp_pxh_rehash
! 1535: #define PXH_PARAMS /8, *2, 2, 2, 8, 24
! 1536:
! 1537:
! 1538: HASH_DEFINE_REHASH_FN(PXH, struct bgp_prefix)
! 1539:
! 1540: void
! 1541: bgp_init_prefix_table(struct bgp_channel *c)
! 1542: {
! 1543: HASH_INIT(c->prefix_hash, c->pool, 8);
! 1544:
! 1545: uint alen = net_addr_length[c->c.net_type];
! 1546: c->prefix_slab = alen ? sl_new(c->pool, sizeof(struct bgp_prefix) + alen) : NULL;
! 1547: }
! 1548:
! 1549: void
! 1550: bgp_free_prefix_table(struct bgp_channel *c)
! 1551: {
! 1552: HASH_FREE(c->prefix_hash);
! 1553:
! 1554: rfree(c->prefix_slab);
! 1555: c->prefix_slab = NULL;
! 1556: }
! 1557:
! 1558: static struct bgp_prefix *
! 1559: bgp_get_prefix(struct bgp_channel *c, net_addr *net, u32 path_id)
! 1560: {
! 1561: u32 hash = net_hash(net) ^ u32_hash(path_id);
! 1562: struct bgp_prefix *px = HASH_FIND(c->prefix_hash, PXH, net, path_id, hash);
! 1563:
! 1564: if (px)
! 1565: {
! 1566: rem_node(&px->buck_node);
! 1567: return px;
! 1568: }
! 1569:
! 1570: if (c->prefix_slab)
! 1571: px = sl_alloc(c->prefix_slab);
! 1572: else
! 1573: px = mb_alloc(c->pool, sizeof(struct bgp_prefix) + net->length);
! 1574:
! 1575: px->buck_node.next = NULL;
! 1576: px->buck_node.prev = NULL;
! 1577: px->hash = hash;
! 1578: px->path_id = path_id;
! 1579: net_copy(px->net, net);
! 1580:
! 1581: HASH_INSERT2(c->prefix_hash, PXH, c->pool, px);
! 1582:
! 1583: return px;
! 1584: }
! 1585:
! 1586: void
! 1587: bgp_free_prefix(struct bgp_channel *c, struct bgp_prefix *px)
! 1588: {
! 1589: rem_node(&px->buck_node);
! 1590: HASH_REMOVE2(c->prefix_hash, PXH, c->pool, px);
! 1591:
! 1592: if (c->prefix_slab)
! 1593: sl_free(c->prefix_slab, px);
! 1594: else
! 1595: mb_free(px);
! 1596: }
! 1597:
! 1598:
! 1599: /*
! 1600: * BGP protocol glue
! 1601: */
! 1602:
! 1603: int
! 1604: bgp_preexport(struct proto *P, rte **new, struct linpool *pool UNUSED)
! 1605: {
! 1606: rte *e = *new;
! 1607: struct proto *SRC = e->attrs->src->proto;
! 1608: struct bgp_proto *p = (struct bgp_proto *) P;
! 1609: struct bgp_proto *src = (SRC->proto == &proto_bgp) ? (struct bgp_proto *) SRC : NULL;
! 1610:
! 1611: /* Reject our routes */
! 1612: if (src == p)
! 1613: return -1;
! 1614:
! 1615: /* Accept non-BGP routes */
! 1616: if (src == NULL)
! 1617: return 0;
! 1618:
! 1619: /* IBGP route reflection, RFC 4456 */
! 1620: if (p->is_internal && src->is_internal && (p->local_as == src->local_as))
! 1621: {
! 1622: /* Rejected unless configured as route reflector */
! 1623: if (!p->rr_client && !src->rr_client)
! 1624: return -1;
! 1625:
! 1626: /* Generally, this should be handled when path is received, but we check it
! 1627: also here as rr_cluster_id may be undefined or different in src. */
! 1628: if (p->rr_cluster_id && bgp_cluster_list_loopy(p, e->attrs->eattrs))
! 1629: return -1;
! 1630: }
! 1631:
! 1632: /* Handle well-known communities, RFC 1997 */
! 1633: struct eattr *c;
! 1634: if (p->cf->interpret_communities &&
! 1635: (c = ea_find(e->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY))))
! 1636: {
! 1637: const struct adata *d = c->u.ptr;
! 1638:
! 1639: /* Do not export anywhere */
! 1640: if (int_set_contains(d, BGP_COMM_NO_ADVERTISE))
! 1641: return -1;
! 1642:
! 1643: /* Do not export outside of AS (or member-AS) */
! 1644: if (!p->is_internal && int_set_contains(d, BGP_COMM_NO_EXPORT_SUBCONFED))
! 1645: return -1;
! 1646:
! 1647: /* Do not export outside of AS (or confederation) */
! 1648: if (!p->is_interior && int_set_contains(d, BGP_COMM_NO_EXPORT))
! 1649: return -1;
! 1650:
! 1651: /* Do not export LLGR_STALE routes to LLGR-ignorant peers */
! 1652: if (!p->conn->remote_caps->llgr_aware && int_set_contains(d, BGP_COMM_LLGR_STALE))
! 1653: return -1;
! 1654: }
! 1655:
! 1656: return 0;
! 1657: }
! 1658:
! 1659: static ea_list *
! 1660: bgp_update_attrs(struct bgp_proto *p, struct bgp_channel *c, rte *e, ea_list *attrs0, struct linpool *pool)
! 1661: {
! 1662: struct proto *SRC = e->attrs->src->proto;
! 1663: struct bgp_proto *src = (SRC->proto == &proto_bgp) ? (void *) SRC : NULL;
! 1664: struct bgp_export_state s = { .proto = p, .channel = c, .pool = pool, .src = src, .route = e, .mpls = c->desc->mpls };
! 1665: ea_list *attrs = attrs0;
! 1666: eattr *a;
! 1667: const adata *ad;
! 1668:
! 1669: /* ORIGIN attribute - mandatory, attach if missing */
! 1670: if (! bgp_find_attr(attrs0, BA_ORIGIN))
! 1671: bgp_set_attr_u32(&attrs, pool, BA_ORIGIN, 0, src ? ORIGIN_INCOMPLETE : ORIGIN_IGP);
! 1672:
! 1673: /* AS_PATH attribute - mandatory */
! 1674: a = bgp_find_attr(attrs0, BA_AS_PATH);
! 1675: ad = a ? a->u.ptr : &null_adata;
! 1676:
! 1677: /* AS_PATH attribute - strip AS_CONFED* segments outside confederation */
! 1678: if ((!p->cf->confederation || !p->is_interior) && as_path_contains_confed(ad))
! 1679: ad = as_path_strip_confed(pool, ad);
! 1680:
! 1681: /* AS_PATH attribute - keep or prepend ASN */
! 1682: if (p->is_internal || p->rs_client)
! 1683: {
! 1684: /* IBGP or route server -> just ensure there is one */
! 1685: if (!a)
! 1686: bgp_set_attr_ptr(&attrs, pool, BA_AS_PATH, 0, &null_adata);
! 1687: }
! 1688: else if (p->is_interior)
! 1689: {
! 1690: /* Confederation -> prepend ASN as AS_CONFED_SEQUENCE */
! 1691: ad = as_path_prepend2(pool, ad, AS_PATH_CONFED_SEQUENCE, p->public_as);
! 1692: bgp_set_attr_ptr(&attrs, pool, BA_AS_PATH, 0, ad);
! 1693: }
! 1694: else /* Regular EBGP (no RS, no confederation) */
! 1695: {
! 1696: /* Regular EBGP -> prepend ASN as regular sequence */
! 1697: ad = as_path_prepend2(pool, ad, AS_PATH_SEQUENCE, p->public_as);
! 1698: bgp_set_attr_ptr(&attrs, pool, BA_AS_PATH, 0, ad);
! 1699:
! 1700: /* MULTI_EXIT_DESC attribute - accept only if set in export filter */
! 1701: a = bgp_find_attr(attrs0, BA_MULTI_EXIT_DISC);
! 1702: if (a && !(a->type & EAF_FRESH))
! 1703: bgp_unset_attr(&attrs, pool, BA_MULTI_EXIT_DISC);
! 1704: }
! 1705:
! 1706: /* NEXT_HOP attribute - delegated to AF-specific hook */
! 1707: a = bgp_find_attr(attrs0, BA_NEXT_HOP);
! 1708: bgp_update_next_hop(&s, a, &attrs);
! 1709:
! 1710: /* LOCAL_PREF attribute - required for IBGP, attach if missing */
! 1711: if (p->is_interior && ! bgp_find_attr(attrs0, BA_LOCAL_PREF))
! 1712: bgp_set_attr_u32(&attrs, pool, BA_LOCAL_PREF, 0, p->cf->default_local_pref);
! 1713:
! 1714: /* AIGP attribute - accumulate local metric or originate new one */
! 1715: u64 metric;
! 1716: if (s.local_next_hop &&
! 1717: (bgp_total_aigp_metric_(e, &metric, &ad) ||
! 1718: (c->cf->aigp_originate && bgp_init_aigp_metric(e, &metric, &ad))))
! 1719: {
! 1720: ad = bgp_aigp_set_metric(pool, ad, metric);
! 1721: bgp_set_attr_ptr(&attrs, pool, BA_AIGP, 0, ad);
! 1722: }
! 1723:
! 1724: /* IBGP route reflection, RFC 4456 */
! 1725: if (src && src->is_internal && p->is_internal && (src->local_as == p->local_as))
! 1726: {
! 1727: /* ORIGINATOR_ID attribute - attach if not already set */
! 1728: if (! bgp_find_attr(attrs0, BA_ORIGINATOR_ID))
! 1729: bgp_set_attr_u32(&attrs, pool, BA_ORIGINATOR_ID, 0, src->remote_id);
! 1730:
! 1731: /* CLUSTER_LIST attribute - prepend cluster ID */
! 1732: a = bgp_find_attr(attrs0, BA_CLUSTER_LIST);
! 1733: ad = a ? a->u.ptr : NULL;
! 1734:
! 1735: /* Prepend src cluster ID */
! 1736: if (src->rr_cluster_id)
! 1737: ad = int_set_prepend(pool, ad, src->rr_cluster_id);
! 1738:
! 1739: /* Prepend dst cluster ID if src and dst clusters are different */
! 1740: if (p->rr_cluster_id && (src->rr_cluster_id != p->rr_cluster_id))
! 1741: ad = int_set_prepend(pool, ad, p->rr_cluster_id);
! 1742:
! 1743: /* Should be at least one prepended cluster ID */
! 1744: bgp_set_attr_ptr(&attrs, pool, BA_CLUSTER_LIST, 0, ad);
! 1745: }
! 1746:
! 1747: /* AS4_* transition attributes, RFC 6793 4.2.2 */
! 1748: if (! p->as4_session)
! 1749: {
! 1750: a = bgp_find_attr(attrs, BA_AS_PATH);
! 1751: if (a && as_path_contains_as4(a->u.ptr))
! 1752: {
! 1753: bgp_set_attr_ptr(&attrs, pool, BA_AS_PATH, 0, as_path_to_old(pool, a->u.ptr));
! 1754: bgp_set_attr_ptr(&attrs, pool, BA_AS4_PATH, 0, as_path_strip_confed(pool, a->u.ptr));
! 1755: }
! 1756:
! 1757: a = bgp_find_attr(attrs, BA_AGGREGATOR);
! 1758: if (a && aggregator_contains_as4(a->u.ptr))
! 1759: {
! 1760: bgp_set_attr_ptr(&attrs, pool, BA_AGGREGATOR, 0, aggregator_to_old(pool, a->u.ptr));
! 1761: bgp_set_attr_ptr(&attrs, pool, BA_AS4_AGGREGATOR, 0, a->u.ptr);
! 1762: }
! 1763: }
! 1764:
! 1765: /*
! 1766: * Presence of mandatory attributes ORIGIN and AS_PATH is ensured by above
! 1767: * conditions. Presence and validity of quasi-mandatory NEXT_HOP attribute
! 1768: * should be checked in AF-specific hooks.
! 1769: */
! 1770:
! 1771: /* Apply per-attribute export hooks for validatation and normalization */
! 1772: return bgp_export_attrs(&s, attrs);
! 1773: }
! 1774:
! 1775: void
! 1776: bgp_rt_notify(struct proto *P, struct channel *C, net *n, rte *new, rte *old)
! 1777: {
! 1778: struct bgp_proto *p = (void *) P;
! 1779: struct bgp_channel *c = (void *) C;
! 1780: struct bgp_bucket *buck;
! 1781: struct bgp_prefix *px;
! 1782: u32 path;
! 1783:
! 1784: if (new)
! 1785: {
! 1786: struct ea_list *attrs = bgp_update_attrs(p, c, new, new->attrs->eattrs, bgp_linpool2);
! 1787:
! 1788: /* If attributes are invalid, we fail back to withdraw */
! 1789: buck = attrs ? bgp_get_bucket(c, attrs) : bgp_get_withdraw_bucket(c);
! 1790: path = new->attrs->src->global_id;
! 1791:
! 1792: lp_flush(bgp_linpool2);
! 1793: }
! 1794: else
! 1795: {
! 1796: buck = bgp_get_withdraw_bucket(c);
! 1797: path = old->attrs->src->global_id;
! 1798: }
! 1799:
! 1800: px = bgp_get_prefix(c, n->n.addr, c->add_path_tx ? path : 0);
! 1801: add_tail(&buck->prefixes, &px->buck_node);
! 1802:
! 1803: bgp_schedule_packet(p->conn, c, PKT_UPDATE);
! 1804: }
! 1805:
! 1806:
! 1807: static inline u32
! 1808: bgp_get_neighbor(rte *r)
! 1809: {
! 1810: eattr *e = ea_find(r->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
! 1811: u32 as;
! 1812:
! 1813: if (e && as_path_get_first_regular(e->u.ptr, &as))
! 1814: return as;
! 1815:
! 1816: /* If AS_PATH is not defined, we treat rte as locally originated */
! 1817: struct bgp_proto *p = (void *) r->attrs->src->proto;
! 1818: return p->cf->confederation ?: p->local_as;
! 1819: }
! 1820:
! 1821: static inline int
! 1822: rte_stale(rte *r)
! 1823: {
! 1824: if (r->u.bgp.stale < 0)
! 1825: {
! 1826: /* If staleness is unknown, compute and cache it */
! 1827: eattr *a = ea_find(r->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY));
! 1828: r->u.bgp.stale = a && int_set_contains(a->u.ptr, BGP_COMM_LLGR_STALE);
! 1829: }
! 1830:
! 1831: return r->u.bgp.stale;
! 1832: }
! 1833:
! 1834: int
! 1835: bgp_rte_better(rte *new, rte *old)
! 1836: {
! 1837: struct bgp_proto *new_bgp = (struct bgp_proto *) new->attrs->src->proto;
! 1838: struct bgp_proto *old_bgp = (struct bgp_proto *) old->attrs->src->proto;
! 1839: eattr *x, *y;
! 1840: u32 n, o;
! 1841:
! 1842: /* Skip suppressed routes (see bgp_rte_recalculate()) */
! 1843: n = new->u.bgp.suppressed;
! 1844: o = old->u.bgp.suppressed;
! 1845: if (n > o)
! 1846: return 0;
! 1847: if (n < o)
! 1848: return 1;
! 1849:
! 1850: /* RFC 4271 9.1.2.1. Route resolvability test */
! 1851: n = rte_resolvable(new);
! 1852: o = rte_resolvable(old);
! 1853: if (n > o)
! 1854: return 1;
! 1855: if (n < o)
! 1856: return 0;
! 1857:
! 1858: /* LLGR draft - depreference stale routes */
! 1859: n = rte_stale(new);
! 1860: o = rte_stale(old);
! 1861: if (n > o)
! 1862: return 0;
! 1863: if (n < o)
! 1864: return 1;
! 1865:
! 1866: /* Start with local preferences */
! 1867: x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF));
! 1868: y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF));
! 1869: n = x ? x->u.data : new_bgp->cf->default_local_pref;
! 1870: o = y ? y->u.data : old_bgp->cf->default_local_pref;
! 1871: if (n > o)
! 1872: return 1;
! 1873: if (n < o)
! 1874: return 0;
! 1875:
! 1876: /* RFC 7311 4.1 - Apply AIGP metric */
! 1877: u64 n2 = bgp_total_aigp_metric(new);
! 1878: u64 o2 = bgp_total_aigp_metric(old);
! 1879: if (n2 < o2)
! 1880: return 1;
! 1881: if (n2 > o2)
! 1882: return 0;
! 1883:
! 1884: /* RFC 4271 9.1.2.2. a) Use AS path lengths */
! 1885: if (new_bgp->cf->compare_path_lengths || old_bgp->cf->compare_path_lengths)
! 1886: {
! 1887: x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
! 1888: y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
! 1889: n = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
! 1890: o = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
! 1891: if (n < o)
! 1892: return 1;
! 1893: if (n > o)
! 1894: return 0;
! 1895: }
! 1896:
! 1897: /* RFC 4271 9.1.2.2. b) Use origins */
! 1898: x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
! 1899: y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
! 1900: n = x ? x->u.data : ORIGIN_INCOMPLETE;
! 1901: o = y ? y->u.data : ORIGIN_INCOMPLETE;
! 1902: if (n < o)
! 1903: return 1;
! 1904: if (n > o)
! 1905: return 0;
! 1906:
! 1907: /* RFC 4271 9.1.2.2. c) Compare MED's */
! 1908: /* Proper RFC 4271 path selection cannot be interpreted as finding
! 1909: * the best path in some ordering. It is implemented partially in
! 1910: * bgp_rte_recalculate() when deterministic_med option is
! 1911: * active. Without that option, the behavior is just an
! 1912: * approximation, which in specific situations may lead to
! 1913: * persistent routing loops, because it is nondeterministic - it
! 1914: * depends on the order in which routes appeared. But it is also the
! 1915: * same behavior as used by default in Cisco routers, so it is
! 1916: * probably not a big issue.
! 1917: */
! 1918: if (new_bgp->cf->med_metric || old_bgp->cf->med_metric ||
! 1919: (bgp_get_neighbor(new) == bgp_get_neighbor(old)))
! 1920: {
! 1921: x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC));
! 1922: y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC));
! 1923: n = x ? x->u.data : new_bgp->cf->default_med;
! 1924: o = y ? y->u.data : old_bgp->cf->default_med;
! 1925: if (n < o)
! 1926: return 1;
! 1927: if (n > o)
! 1928: return 0;
! 1929: }
! 1930:
! 1931: /* RFC 4271 9.1.2.2. d) Prefer external peers */
! 1932: if (new_bgp->is_interior > old_bgp->is_interior)
! 1933: return 0;
! 1934: if (new_bgp->is_interior < old_bgp->is_interior)
! 1935: return 1;
! 1936:
! 1937: /* RFC 4271 9.1.2.2. e) Compare IGP metrics */
! 1938: n = new_bgp->cf->igp_metric ? new->attrs->igp_metric : 0;
! 1939: o = old_bgp->cf->igp_metric ? old->attrs->igp_metric : 0;
! 1940: if (n < o)
! 1941: return 1;
! 1942: if (n > o)
! 1943: return 0;
! 1944:
! 1945: /* RFC 4271 9.1.2.2. f) Compare BGP identifiers */
! 1946: /* RFC 4456 9. a) Use ORIGINATOR_ID instead of local neighbor ID */
! 1947: x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID));
! 1948: y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGINATOR_ID));
! 1949: n = x ? x->u.data : new_bgp->remote_id;
! 1950: o = y ? y->u.data : old_bgp->remote_id;
! 1951:
! 1952: /* RFC 5004 - prefer older routes */
! 1953: /* (if both are external and from different peer) */
! 1954: if ((new_bgp->cf->prefer_older || old_bgp->cf->prefer_older) &&
! 1955: !new_bgp->is_internal && n != o)
! 1956: return 0;
! 1957:
! 1958: /* rest of RFC 4271 9.1.2.2. f) */
! 1959: if (n < o)
! 1960: return 1;
! 1961: if (n > o)
! 1962: return 0;
! 1963:
! 1964: /* RFC 4456 9. b) Compare cluster list lengths */
! 1965: x = ea_find(new->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_CLUSTER_LIST));
! 1966: y = ea_find(old->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_CLUSTER_LIST));
! 1967: n = x ? int_set_get_size(x->u.ptr) : 0;
! 1968: o = y ? int_set_get_size(y->u.ptr) : 0;
! 1969: if (n < o)
! 1970: return 1;
! 1971: if (n > o)
! 1972: return 0;
! 1973:
! 1974: /* RFC 4271 9.1.2.2. g) Compare peer IP adresses */
! 1975: return ipa_compare(new_bgp->remote_ip, old_bgp->remote_ip) < 0;
! 1976: }
! 1977:
! 1978:
! 1979: int
! 1980: bgp_rte_mergable(rte *pri, rte *sec)
! 1981: {
! 1982: struct bgp_proto *pri_bgp = (struct bgp_proto *) pri->attrs->src->proto;
! 1983: struct bgp_proto *sec_bgp = (struct bgp_proto *) sec->attrs->src->proto;
! 1984: eattr *x, *y;
! 1985: u32 p, s;
! 1986:
! 1987: /* Skip suppressed routes (see bgp_rte_recalculate()) */
! 1988: if (pri->u.bgp.suppressed != sec->u.bgp.suppressed)
! 1989: return 0;
! 1990:
! 1991: /* RFC 4271 9.1.2.1. Route resolvability test */
! 1992: if (rte_resolvable(pri) != rte_resolvable(sec))
! 1993: return 0;
! 1994:
! 1995: /* LLGR draft - depreference stale routes */
! 1996: if (rte_stale(pri) != rte_stale(sec))
! 1997: return 0;
! 1998:
! 1999: /* Start with local preferences */
! 2000: x = ea_find(pri->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF));
! 2001: y = ea_find(sec->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_LOCAL_PREF));
! 2002: p = x ? x->u.data : pri_bgp->cf->default_local_pref;
! 2003: s = y ? y->u.data : sec_bgp->cf->default_local_pref;
! 2004: if (p != s)
! 2005: return 0;
! 2006:
! 2007: /* RFC 4271 9.1.2.2. a) Use AS path lengths */
! 2008: if (pri_bgp->cf->compare_path_lengths || sec_bgp->cf->compare_path_lengths)
! 2009: {
! 2010: x = ea_find(pri->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
! 2011: y = ea_find(sec->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
! 2012: p = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
! 2013: s = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
! 2014:
! 2015: if (p != s)
! 2016: return 0;
! 2017:
! 2018: // if (DELTA(p, s) > pri_bgp->cf->relax_multipath)
! 2019: // return 0;
! 2020: }
! 2021:
! 2022: /* RFC 4271 9.1.2.2. b) Use origins */
! 2023: x = ea_find(pri->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
! 2024: y = ea_find(sec->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
! 2025: p = x ? x->u.data : ORIGIN_INCOMPLETE;
! 2026: s = y ? y->u.data : ORIGIN_INCOMPLETE;
! 2027: if (p != s)
! 2028: return 0;
! 2029:
! 2030: /* RFC 4271 9.1.2.2. c) Compare MED's */
! 2031: if (pri_bgp->cf->med_metric || sec_bgp->cf->med_metric ||
! 2032: (bgp_get_neighbor(pri) == bgp_get_neighbor(sec)))
! 2033: {
! 2034: x = ea_find(pri->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC));
! 2035: y = ea_find(sec->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_MULTI_EXIT_DISC));
! 2036: p = x ? x->u.data : pri_bgp->cf->default_med;
! 2037: s = y ? y->u.data : sec_bgp->cf->default_med;
! 2038: if (p != s)
! 2039: return 0;
! 2040: }
! 2041:
! 2042: /* RFC 4271 9.1.2.2. d) Prefer external peers */
! 2043: if (pri_bgp->is_interior != sec_bgp->is_interior)
! 2044: return 0;
! 2045:
! 2046: /* RFC 4271 9.1.2.2. e) Compare IGP metrics */
! 2047: p = pri_bgp->cf->igp_metric ? pri->attrs->igp_metric : 0;
! 2048: s = sec_bgp->cf->igp_metric ? sec->attrs->igp_metric : 0;
! 2049: if (p != s)
! 2050: return 0;
! 2051:
! 2052: /* Remaining criteria are ignored */
! 2053:
! 2054: return 1;
! 2055: }
! 2056:
! 2057:
! 2058: static inline int
! 2059: same_group(rte *r, u32 lpref, u32 lasn)
! 2060: {
! 2061: return (r->pref == lpref) && (bgp_get_neighbor(r) == lasn);
! 2062: }
! 2063:
! 2064: static inline int
! 2065: use_deterministic_med(rte *r)
! 2066: {
! 2067: struct proto *P = r->attrs->src->proto;
! 2068: return (P->proto == &proto_bgp) && ((struct bgp_proto *) P)->cf->deterministic_med;
! 2069: }
! 2070:
! 2071: int
! 2072: bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best)
! 2073: {
! 2074: rte *r, *s;
! 2075: rte *key = new ? new : old;
! 2076: u32 lpref = key->pref;
! 2077: u32 lasn = bgp_get_neighbor(key);
! 2078: int old_suppressed = old ? old->u.bgp.suppressed : 0;
! 2079:
! 2080: /*
! 2081: * Proper RFC 4271 path selection is a bit complicated, it cannot be
! 2082: * implemented just by rte_better(), because it is not a linear
! 2083: * ordering. But it can be splitted to two levels, where the lower
! 2084: * level chooses the best routes in each group of routes from the
! 2085: * same neighboring AS and higher level chooses the best route (with
! 2086: * a slightly different ordering) between the best-in-group routes.
! 2087: *
! 2088: * When deterministic_med is disabled, we just ignore this issue and
! 2089: * choose the best route by bgp_rte_better() alone. If enabled, the
! 2090: * lower level of the route selection is done here (for the group
! 2091: * to which the changed route belongs), all routes in group are
! 2092: * marked as suppressed, just chosen best-in-group is not.
! 2093: *
! 2094: * Global best route selection then implements higher level by
! 2095: * choosing between non-suppressed routes (as they are always
! 2096: * preferred over suppressed routes). Routes from BGP protocols
! 2097: * that do not set deterministic_med are just never suppressed. As
! 2098: * they do not participate in the lower level selection, it is OK
! 2099: * that this fn is not called for them.
! 2100: *
! 2101: * The idea is simple, the implementation is more problematic,
! 2102: * mostly because of optimizations in rte_recalculate() that
! 2103: * avoids full recalculation in most cases.
! 2104: *
! 2105: * We can assume that at least one of new, old is non-NULL and both
! 2106: * are from the same protocol with enabled deterministic_med. We
! 2107: * group routes by both neighbor AS (lasn) and preference (lpref),
! 2108: * because bgp_rte_better() does not handle preference itself.
! 2109: */
! 2110:
! 2111: /* If new and old are from different groups, we just process that
! 2112: as two independent events */
! 2113: if (new && old && !same_group(old, lpref, lasn))
! 2114: {
! 2115: int i1, i2;
! 2116: i1 = bgp_rte_recalculate(table, net, NULL, old, old_best);
! 2117: i2 = bgp_rte_recalculate(table, net, new, NULL, old_best);
! 2118: return i1 || i2;
! 2119: }
! 2120:
! 2121: /*
! 2122: * We could find the best-in-group and then make some shortcuts like
! 2123: * in rte_recalculate, but as we would have to walk through all
! 2124: * net->routes just to find it, it is probably not worth. So we
! 2125: * just have one simple fast case that use just the old route.
! 2126: * We also set suppressed flag to avoid using it in bgp_rte_better().
! 2127: */
! 2128:
! 2129: if (new)
! 2130: new->u.bgp.suppressed = 1;
! 2131:
! 2132: if (old)
! 2133: {
! 2134: old->u.bgp.suppressed = 1;
! 2135:
! 2136: /* The fast case - replace not best with worse (or remove not best) */
! 2137: if (old_suppressed && !(new && bgp_rte_better(new, old)))
! 2138: return 0;
! 2139: }
! 2140:
! 2141: /* The default case - find a new best-in-group route */
! 2142: r = new; /* new may not be in the list */
! 2143: for (s=net->routes; rte_is_valid(s); s=s->next)
! 2144: if (use_deterministic_med(s) && same_group(s, lpref, lasn))
! 2145: {
! 2146: s->u.bgp.suppressed = 1;
! 2147: if (!r || bgp_rte_better(s, r))
! 2148: r = s;
! 2149: }
! 2150:
! 2151: /* Simple case - the last route in group disappears */
! 2152: if (!r)
! 2153: return 0;
! 2154:
! 2155: /* Found if new is mergable with best-in-group */
! 2156: if (new && (new != r) && bgp_rte_mergable(r, new))
! 2157: new->u.bgp.suppressed = 0;
! 2158:
! 2159: /* Found all existing routes mergable with best-in-group */
! 2160: for (s=net->routes; rte_is_valid(s); s=s->next)
! 2161: if (use_deterministic_med(s) && same_group(s, lpref, lasn))
! 2162: if ((s != r) && bgp_rte_mergable(r, s))
! 2163: s->u.bgp.suppressed = 0;
! 2164:
! 2165: /* Found best-in-group */
! 2166: r->u.bgp.suppressed = 0;
! 2167:
! 2168: /*
! 2169: * There are generally two reasons why we have to force
! 2170: * recalculation (return 1): First, the new route may be wrongfully
! 2171: * chosen to be the best in the first case check in
! 2172: * rte_recalculate(), this may happen only if old_best is from the
! 2173: * same group. Second, another (different than new route)
! 2174: * best-in-group is chosen and that may be the proper best (although
! 2175: * rte_recalculate() without ignore that possibility).
! 2176: *
! 2177: * There are three possible cases according to whether the old route
! 2178: * was the best in group (OBG, i.e. !old_suppressed) and whether the
! 2179: * new route is the best in group (NBG, tested by r == new). These
! 2180: * cases work even if old or new is NULL.
! 2181: *
! 2182: * NBG -> new is a possible candidate for the best route, so we just
! 2183: * check for the first reason using same_group().
! 2184: *
! 2185: * !NBG && OBG -> Second reason applies, return 1
! 2186: *
! 2187: * !NBG && !OBG -> Best in group does not change, old != old_best,
! 2188: * rte_better(new, old_best) is false and therefore
! 2189: * the first reason does not apply, return 0
! 2190: */
! 2191:
! 2192: if (r == new)
! 2193: return old_best && same_group(old_best, lpref, lasn);
! 2194: else
! 2195: return !old_suppressed;
! 2196: }
! 2197:
! 2198: struct rte *
! 2199: bgp_rte_modify_stale(struct rte *r, struct linpool *pool)
! 2200: {
! 2201: eattr *a = ea_find(r->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_COMMUNITY));
! 2202: const struct adata *ad = a ? a->u.ptr : NULL;
! 2203: uint flags = a ? a->flags : BAF_PARTIAL;
! 2204:
! 2205: if (ad && int_set_contains(ad, BGP_COMM_NO_LLGR))
! 2206: return NULL;
! 2207:
! 2208: if (ad && int_set_contains(ad, BGP_COMM_LLGR_STALE))
! 2209: return r;
! 2210:
! 2211: r = rte_cow_rta(r, pool);
! 2212: bgp_set_attr_ptr(&(r->attrs->eattrs), pool, BA_COMMUNITY, flags,
! 2213: int_set_add(pool, ad, BGP_COMM_LLGR_STALE));
! 2214: r->u.bgp.stale = 1;
! 2215:
! 2216: return r;
! 2217: }
! 2218:
! 2219:
! 2220: /*
! 2221: * Reconstruct AS_PATH and AGGREGATOR according to RFC 6793 4.2.3
! 2222: */
! 2223: static void
! 2224: bgp_process_as4_attrs(ea_list **attrs, struct linpool *pool)
! 2225: {
! 2226: eattr *p2 = bgp_find_attr(*attrs, BA_AS_PATH);
! 2227: eattr *p4 = bgp_find_attr(*attrs, BA_AS4_PATH);
! 2228: eattr *a2 = bgp_find_attr(*attrs, BA_AGGREGATOR);
! 2229: eattr *a4 = bgp_find_attr(*attrs, BA_AS4_AGGREGATOR);
! 2230:
! 2231: /* First, unset AS4_* attributes */
! 2232: if (p4) bgp_unset_attr(attrs, pool, BA_AS4_PATH);
! 2233: if (a4) bgp_unset_attr(attrs, pool, BA_AS4_AGGREGATOR);
! 2234:
! 2235: /* Handle AGGREGATOR attribute */
! 2236: if (a2 && a4)
! 2237: {
! 2238: u32 a2_asn = get_u32(a2->u.ptr->data);
! 2239:
! 2240: /* If routes were aggregated by an old router, then AS4_PATH and
! 2241: AS4_AGGREGATOR are invalid. In that case we give up. */
! 2242: if (a2_asn != AS_TRANS)
! 2243: return;
! 2244:
! 2245: /* Use AS4_AGGREGATOR instead of AGGREGATOR */
! 2246: a2->u.ptr = a4->u.ptr;
! 2247: }
! 2248:
! 2249: /* Handle AS_PATH attribute */
! 2250: if (p2 && p4)
! 2251: {
! 2252: /* Both as_path_getlen() and as_path_cut() take AS_CONFED* as zero length */
! 2253: int p2_len = as_path_getlen(p2->u.ptr);
! 2254: int p4_len = as_path_getlen(p4->u.ptr);
! 2255:
! 2256: /* AS_PATH is too short, give up */
! 2257: if (p2_len < p4_len)
! 2258: return;
! 2259:
! 2260: /* Merge AS_PATH and AS4_PATH */
! 2261: struct adata *apc = as_path_cut(pool, p2->u.ptr, p2_len - p4_len);
! 2262: p2->u.ptr = as_path_merge(pool, apc, p4->u.ptr);
! 2263: }
! 2264: }
! 2265:
! 2266: int
! 2267: bgp_get_attr(eattr *a, byte *buf, int buflen)
! 2268: {
! 2269: uint i = EA_ID(a->id);
! 2270: const struct bgp_attr_desc *d;
! 2271: int len;
! 2272:
! 2273: if (bgp_attr_known(i))
! 2274: {
! 2275: d = &bgp_attr_table[i];
! 2276: len = bsprintf(buf, "%s", d->name);
! 2277: buf += len;
! 2278: if (d->format)
! 2279: {
! 2280: *buf++ = ':';
! 2281: *buf++ = ' ';
! 2282: d->format(a, buf, buflen - len - 2);
! 2283: return GA_FULL;
! 2284: }
! 2285: return GA_NAME;
! 2286: }
! 2287:
! 2288: bsprintf(buf, "%02x%s", i, (a->flags & BAF_TRANSITIVE) ? " [t]" : "");
! 2289: return GA_NAME;
! 2290: }
! 2291:
! 2292: void
! 2293: bgp_get_route_info(rte *e, byte *buf)
! 2294: {
! 2295: eattr *p = ea_find(e->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_AS_PATH));
! 2296: eattr *o = ea_find(e->attrs->eattrs, EA_CODE(PROTOCOL_BGP, BA_ORIGIN));
! 2297: u32 origas;
! 2298:
! 2299: buf += bsprintf(buf, " (%d", e->pref);
! 2300:
! 2301: if (e->u.bgp.suppressed)
! 2302: buf += bsprintf(buf, "-");
! 2303:
! 2304: if (rte_stale(e))
! 2305: buf += bsprintf(buf, "s");
! 2306:
! 2307: u64 metric = bgp_total_aigp_metric(e);
! 2308: if (metric < BGP_AIGP_MAX)
! 2309: {
! 2310: buf += bsprintf(buf, "/%lu", metric);
! 2311: }
! 2312: else if (e->attrs->igp_metric)
! 2313: {
! 2314: if (!rte_resolvable(e))
! 2315: buf += bsprintf(buf, "/-");
! 2316: else if (e->attrs->igp_metric >= IGP_METRIC_UNKNOWN)
! 2317: buf += bsprintf(buf, "/?");
! 2318: else
! 2319: buf += bsprintf(buf, "/%d", e->attrs->igp_metric);
! 2320: }
! 2321: buf += bsprintf(buf, ") [");
! 2322:
! 2323: if (p && as_path_get_last(p->u.ptr, &origas))
! 2324: buf += bsprintf(buf, "AS%u", origas);
! 2325: if (o)
! 2326: buf += bsprintf(buf, "%c", "ie?"[o->u.data]);
! 2327: strcpy(buf, "]");
! 2328: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to attrs.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / bird2 / proto / bgp