Annotation of embedaddon/bird/proto/bgp/attrs.c, revision 1.1.1.1
1.1 misho 1: /*
2: * BIRD -- BGP Attributes
3: *
4: * (c) 2000 Martin Mares <mj@ucw.cz>
5: *
6: * Can be freely distributed and used under the terms of the GNU GPL.
7: */
8:
9: #undef LOCAL_DEBUG
10:
11: #include <stdlib.h>
12:
13: #include "nest/bird.h"
14: #include "nest/iface.h"
15: #include "nest/protocol.h"
16: #include "nest/route.h"
17: #include "nest/attrs.h"
18: #include "conf/conf.h"
19: #include "lib/resource.h"
20: #include "lib/string.h"
21: #include "lib/unaligned.h"
22:
23: #include "bgp.h"
24:
25: /*
26: * UPDATE message error handling
27: *
28: * All checks from RFC 4271 6.3 are done as specified with these exceptions:
29: * - The semantic check of an IP address from NEXT_HOP attribute is missing.
30: * - Checks of some optional attribute values are missing.
31: * - Syntactic and semantic checks of NLRIs (done in DECODE_PREFIX())
32: * are probably inadequate.
33: *
34: * Loop detection based on AS_PATH causes updates to be withdrawn. RFC
35: * 4271 does not explicitly specifiy the behavior in that case.
36: *
37: * Loop detection related to route reflection (based on ORIGINATOR_ID
38: * and CLUSTER_LIST) causes updates to be withdrawn. RFC 4456 8
39: * specifies that such updates should be ignored, but that is generally
40: * a bad idea.
41: *
42: * Error checking of optional transitive attributes is done according to
43: * draft-ietf-idr-optional-transitive-03, but errors are handled always
44: * as withdraws.
45: *
46: * Unexpected AS_CONFED_* segments in AS_PATH are logged and removed,
47: * but unknown segments cause a session drop with Malformed AS_PATH
48: * error (see validate_path()). The behavior in such case is not
49: * explicitly specified by RFC 4271. RFC 5065 specifies that
50: * inconsistent AS_CONFED_* segments should cause a session drop, but
51: * implementations that pass invalid AS_CONFED_* segments are
52: * widespread.
53: *
54: * Error handling of AS4_* attributes is done as specified by
55: * draft-ietf-idr-rfc4893bis-03. There are several possible
56: * inconsistencies between AGGREGATOR and AS4_AGGREGATOR that are not
57: * handled by that draft, these are logged and ignored (see
58: * bgp_reconstruct_4b_attrs()).
59: */
60:
61:
62: static byte bgp_mandatory_attrs[] = { BA_ORIGIN, BA_AS_PATH
63: #ifndef IPV6
64: ,BA_NEXT_HOP
65: #endif
66: };
67:
68: struct attr_desc {
69: char *name;
70: int expected_length;
71: int expected_flags;
72: int type;
73: int allow_in_ebgp;
74: int (*validate)(struct bgp_proto *p, byte *attr, int len);
75: void (*format)(eattr *ea, byte *buf, int buflen);
76: };
77:
78: #define IGNORE -1
79: #define WITHDRAW -2
80:
81: static int
82: bgp_check_origin(struct bgp_proto *p UNUSED, byte *a, int len UNUSED)
83: {
84: if (*a > 2)
85: return 6;
86: return 0;
87: }
88:
89: static void
90: bgp_format_origin(eattr *a, byte *buf, int buflen UNUSED)
91: {
92: static char *bgp_origin_names[] = { "IGP", "EGP", "Incomplete" };
93:
94: bsprintf(buf, bgp_origin_names[a->u.data]);
95: }
96:
97: static int
98: path_segment_contains(byte *p, int bs, u32 asn)
99: {
100: int i;
101: int len = p[1];
102: p += 2;
103:
104: for(i=0; i<len; i++)
105: {
106: u32 asn2 = (bs == 4) ? get_u32(p) : get_u16(p);
107: if (asn2 == asn)
108: return 1;
109: p += bs;
110: }
111:
112: return 0;
113: }
114:
115: /* Validates path attribute, removes AS_CONFED_* segments, and also returns path length */
116: static int
117: validate_path(struct bgp_proto *p, int as_path, int bs, byte *idata, uint *ilength)
118: {
119: int res = 0;
120: u8 *a, *dst;
121: int len, plen;
122:
123: dst = a = idata;
124: len = *ilength;
125:
126: while (len)
127: {
128: if (len < 2)
129: return -1;
130:
131: plen = 2 + bs * a[1];
132: if (len < plen)
133: return -1;
134:
135: if (a[1] == 0)
136: {
137: log(L_WARN "%s: %s_PATH attribute contains empty segment, skipping it",
138: p->p.name, as_path ? "AS" : "AS4");
139: goto skip;
140: }
141:
142: switch (a[0])
143: {
144: case AS_PATH_SET:
145: res++;
146: break;
147:
148: case AS_PATH_SEQUENCE:
149: res += a[1];
150: break;
151:
152: case AS_PATH_CONFED_SEQUENCE:
153: case AS_PATH_CONFED_SET:
154: if (as_path && path_segment_contains(a, bs, p->remote_as))
155: {
156: log(L_WARN "%s: AS_CONFED_* segment with peer ASN found, misconfigured confederation?", p->p.name);
157: return -1;
158: }
159:
160: log(L_WARN "%s: %s_PATH attribute contains AS_CONFED_* segment, skipping segment",
161: p->p.name, as_path ? "AS" : "AS4");
162: goto skip;
163:
164: default:
165: return -1;
166: }
167:
168: if (dst != a)
169: memmove(dst, a, plen);
170: dst += plen;
171:
172: skip:
173: len -= plen;
174: a += plen;
175: }
176:
177: *ilength = dst - idata;
178: return res;
179: }
180:
181: static inline int
182: validate_as_path(struct bgp_proto *p, byte *a, int *len)
183: {
184: return validate_path(p, 1, p->as4_session ? 4 : 2, a, len);
185: }
186:
187: static inline int
188: validate_as4_path(struct bgp_proto *p, struct adata *path)
189: {
190: return validate_path(p, 0, 4, path->data, &path->length);
191: }
192:
193: static int
194: bgp_check_next_hop(struct bgp_proto *p UNUSED, byte *a UNUSED6, int len UNUSED6)
195: {
196: #ifdef IPV6
197: return IGNORE;
198: #else
199: ip_addr addr;
200:
201: memcpy(&addr, a, len);
202: ipa_ntoh(addr);
203: if (ipa_classify(addr) & IADDR_HOST)
204: return 0;
205: else
206: return 8;
207: #endif
208: }
209:
210: static void
211: bgp_format_next_hop(eattr *a, byte *buf, int buflen UNUSED)
212: {
213: ip_addr *ipp = (ip_addr *) a->u.ptr->data;
214: #ifdef IPV6
215: /* in IPv6, we might have two addresses in NEXT HOP */
216: if ((a->u.ptr->length == NEXT_HOP_LENGTH) && ipa_nonzero(ipp[1]))
217: {
218: bsprintf(buf, "%I %I", ipp[0], ipp[1]);
219: return;
220: }
221: #endif
222:
223: bsprintf(buf, "%I", ipp[0]);
224: }
225:
226: static int
227: bgp_check_aggregator(struct bgp_proto *p, byte *a UNUSED, int len)
228: {
229: int exp_len = p->as4_session ? 8 : 6;
230:
231: return (len == exp_len) ? 0 : WITHDRAW;
232: }
233:
234: static void
235: bgp_format_aggregator(eattr *a, byte *buf, int buflen UNUSED)
236: {
237: struct adata *ad = a->u.ptr;
238: byte *data = ad->data;
239: u32 as;
240:
241: as = get_u32(data);
242: data += 4;
243:
244: bsprintf(buf, "%d.%d.%d.%d AS%u", data[0], data[1], data[2], data[3], as);
245: }
246:
247: static int
248: bgp_check_community(struct bgp_proto *p UNUSED, byte *a UNUSED, int len)
249: {
250: return ((len % 4) == 0) ? 0 : WITHDRAW;
251: }
252:
253: static int
254: bgp_check_cluster_list(struct bgp_proto *p UNUSED, byte *a UNUSED, int len)
255: {
256: return ((len % 4) == 0) ? 0 : 5;
257: }
258:
259: static void
260: bgp_format_cluster_list(eattr *a, byte *buf, int buflen)
261: {
262: /* Truncates cluster lists larger than buflen, probably not a problem */
263: int_set_format(a->u.ptr, 0, -1, buf, buflen);
264: }
265:
266: static int
267: bgp_check_reach_nlri(struct bgp_proto *p UNUSED, byte *a UNUSED, int len UNUSED)
268: {
269: #ifdef IPV6
270: p->mp_reach_start = a;
271: p->mp_reach_len = len;
272: #endif
273: return IGNORE;
274: }
275:
276: static int
277: bgp_check_unreach_nlri(struct bgp_proto *p UNUSED, byte *a UNUSED, int len UNUSED)
278: {
279: #ifdef IPV6
280: p->mp_unreach_start = a;
281: p->mp_unreach_len = len;
282: #endif
283: return IGNORE;
284: }
285:
286: static int
287: bgp_check_ext_community(struct bgp_proto *p UNUSED, byte *a UNUSED, int len)
288: {
289: return ((len % 8) == 0) ? 0 : WITHDRAW;
290: }
291:
292: static int
293: bgp_check_large_community(struct bgp_proto *p UNUSED, byte *a UNUSED, int len)
294: {
295: return ((len % 12) == 0) ? 0 : WITHDRAW;
296: }
297:
298:
299: static struct attr_desc bgp_attr_table[] = {
300: { NULL, -1, 0, 0, 0, /* Undefined */
301: NULL, NULL },
302: { "origin", 1, BAF_TRANSITIVE, EAF_TYPE_INT, 1, /* BA_ORIGIN */
303: bgp_check_origin, bgp_format_origin },
304: { "as_path", -1, BAF_TRANSITIVE, EAF_TYPE_AS_PATH, 1, /* BA_AS_PATH */
305: NULL, NULL }, /* is checked by validate_as_path() as a special case */
306: { "next_hop", 4, BAF_TRANSITIVE, EAF_TYPE_IP_ADDRESS, 1, /* BA_NEXT_HOP */
307: bgp_check_next_hop, bgp_format_next_hop },
308: { "med", 4, BAF_OPTIONAL, EAF_TYPE_INT, 1, /* BA_MULTI_EXIT_DISC */
309: NULL, NULL },
310: { "local_pref", 4, BAF_TRANSITIVE, EAF_TYPE_INT, 0, /* BA_LOCAL_PREF */
311: NULL, NULL },
312: { "atomic_aggr", 0, BAF_TRANSITIVE, EAF_TYPE_OPAQUE, 1, /* BA_ATOMIC_AGGR */
313: NULL, NULL },
314: { "aggregator", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_OPAQUE, 1, /* BA_AGGREGATOR */
315: bgp_check_aggregator, bgp_format_aggregator },
316: { "community", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_INT_SET, 1, /* BA_COMMUNITY */
317: bgp_check_community, NULL },
318: { "originator_id", 4, BAF_OPTIONAL, EAF_TYPE_ROUTER_ID, 0, /* BA_ORIGINATOR_ID */
319: NULL, NULL },
320: { "cluster_list", -1, BAF_OPTIONAL, EAF_TYPE_INT_SET, 0, /* BA_CLUSTER_LIST */
321: bgp_check_cluster_list, bgp_format_cluster_list },
322: { .name = NULL }, /* BA_DPA */
323: { .name = NULL }, /* BA_ADVERTISER */
324: { .name = NULL }, /* BA_RCID_PATH */
325: { "mp_reach_nlri", -1, BAF_OPTIONAL, EAF_TYPE_OPAQUE, 1, /* BA_MP_REACH_NLRI */
326: bgp_check_reach_nlri, NULL },
327: { "mp_unreach_nlri", -1, BAF_OPTIONAL, EAF_TYPE_OPAQUE, 1, /* BA_MP_UNREACH_NLRI */
328: bgp_check_unreach_nlri, NULL },
329: { "ext_community", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_EC_SET, 1, /* BA_EXT_COMMUNITY */
330: bgp_check_ext_community, NULL },
331: { "as4_path", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_OPAQUE, 1, /* BA_AS4_PATH */
332: NULL, NULL },
333: { "as4_aggregator", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_OPAQUE, 1, /* BA_AS4_PATH */
334: NULL, NULL },
335: [BA_LARGE_COMMUNITY] =
336: { "large_community", -1, BAF_OPTIONAL | BAF_TRANSITIVE, EAF_TYPE_LC_SET, 1,
337: bgp_check_large_community, NULL }
338: };
339:
340: /* BA_AS4_PATH is type EAF_TYPE_OPAQUE and not type EAF_TYPE_AS_PATH.
341: * It does not matter as this attribute does not appear on routes in the routing table.
342: */
343:
344: #define ATTR_KNOWN(code) ((code) < ARRAY_SIZE(bgp_attr_table) && bgp_attr_table[code].name)
345:
346: static inline struct adata *
347: bgp_alloc_adata(struct linpool *pool, unsigned len)
348: {
349: struct adata *ad = lp_alloc(pool, sizeof(struct adata) + len);
350: ad->length = len;
351: return ad;
352: }
353:
354: static void
355: bgp_set_attr(eattr *e, unsigned attr, uintptr_t val)
356: {
357: ASSERT(ATTR_KNOWN(attr));
358: e->id = EA_CODE(EAP_BGP, attr);
359: e->type = bgp_attr_table[attr].type;
360: e->flags = bgp_attr_table[attr].expected_flags;
361: if (e->type & EAF_EMBEDDED)
362: e->u.data = val;
363: else
364: e->u.ptr = (struct adata *) val;
365: }
366:
367: static byte *
368: bgp_set_attr_wa(eattr *e, struct linpool *pool, unsigned attr, unsigned len)
369: {
370: struct adata *ad = bgp_alloc_adata(pool, len);
371: bgp_set_attr(e, attr, (uintptr_t) ad);
372: return ad->data;
373: }
374:
375: void
376: bgp_attach_attr(ea_list **to, struct linpool *pool, unsigned attr, uintptr_t val)
377: {
378: ea_list *a = lp_alloc(pool, sizeof(ea_list) + sizeof(eattr));
379: a->next = *to;
380: *to = a;
381: a->flags = EALF_SORTED;
382: a->count = 1;
383: bgp_set_attr(a->attrs, attr, val);
384: }
385:
386: byte *
387: bgp_attach_attr_wa(ea_list **to, struct linpool *pool, unsigned attr, unsigned len)
388: {
389: struct adata *ad = bgp_alloc_adata(pool, len);
390: bgp_attach_attr(to, pool, attr, (uintptr_t) ad);
391: return ad->data;
392: }
393:
394: static int
395: bgp_encode_attr_hdr(byte *dst, uint flags, unsigned code, int len)
396: {
397: int wlen;
398:
399: DBG("\tAttribute %02x (%d bytes, flags %02x)\n", code, len, flags);
400:
401: if (len < 256)
402: {
403: *dst++ = flags;
404: *dst++ = code;
405: *dst++ = len;
406: wlen = 3;
407: }
408: else
409: {
410: *dst++ = flags | BAF_EXT_LEN;
411: *dst++ = code;
412: put_u16(dst, len);
413: wlen = 4;
414: }
415:
416: return wlen;
417: }
418:
419: static void
420: aggregator_convert_to_old(struct adata *aggr, byte *dst, int *new_used)
421: {
422: byte *src = aggr->data;
423: *new_used = 0;
424:
425: u32 as = get_u32(src);
426: if (as > 0xFFFF)
427: {
428: as = AS_TRANS;
429: *new_used = 1;
430: }
431: put_u16(dst, as);
432:
433: /* Copy IPv4 address */
434: memcpy(dst + 2, src + 4, 4);
435: }
436:
437: static void
438: aggregator_convert_to_new(struct adata *aggr, byte *dst)
439: {
440: byte *src = aggr->data;
441:
442: u32 as = get_u16(src);
443: put_u32(dst, as);
444:
445: /* Copy IPv4 address */
446: memcpy(dst + 4, src + 2, 4);
447: }
448:
449: static int
450: bgp_get_attr_len(eattr *a)
451: {
452: int len;
453: if (ATTR_KNOWN(EA_ID(a->id)))
454: {
455: int code = EA_ID(a->id);
456: struct attr_desc *desc = &bgp_attr_table[code];
457: len = desc->expected_length;
458: if (len < 0)
459: {
460: ASSERT(!(a->type & EAF_EMBEDDED));
461: len = a->u.ptr->length;
462: }
463: }
464: else
465: {
466: ASSERT((a->type & EAF_TYPE_MASK) == EAF_TYPE_OPAQUE);
467: len = a->u.ptr->length;
468: }
469:
470: return len;
471: }
472:
473: #define ADVANCE(w, r, l) do { r -= l; w += l; } while (0)
474:
475: /**
476: * bgp_encode_attrs - encode BGP attributes
477: * @p: BGP instance
478: * @w: buffer
479: * @attrs: a list of extended attributes
480: * @remains: remaining space in the buffer
481: *
482: * The bgp_encode_attrs() function takes a list of extended attributes
483: * and converts it to its BGP representation (a part of an Update message).
484: *
485: * Result: Length of the attribute block generated or -1 if not enough space.
486: */
487: uint
488: bgp_encode_attrs(struct bgp_proto *p, byte *w, ea_list *attrs, int remains)
489: {
490: uint i, code, type, flags;
491: byte *start = w;
492: int len, rv;
493:
494: for(i=0; i<attrs->count; i++)
495: {
496: eattr *a = &attrs->attrs[i];
497: ASSERT(EA_PROTO(a->id) == EAP_BGP);
498: code = EA_ID(a->id);
499:
500: #ifdef IPV6
501: /* When talking multiprotocol BGP, the NEXT_HOP attributes are used only temporarily. */
502: if (code == BA_NEXT_HOP)
503: continue;
504: #endif
505:
506: /* When AS4-aware BGP speaker is talking to non-AS4-aware BGP speaker,
507: * we have to convert our 4B AS_PATH to 2B AS_PATH and send our AS_PATH
508: * as optional AS4_PATH attribute.
509: */
510: if ((code == BA_AS_PATH) && (! p->as4_session))
511: {
512: len = a->u.ptr->length;
513:
514: if (remains < (len + 4))
515: goto err_no_buffer;
516:
517: /* Using temporary buffer because don't know a length of created attr
518: * and therefore a length of a header. Perhaps i should better always
519: * use BAF_EXT_LEN. */
520:
521: byte buf[len];
522: int new_used;
523: int nl = as_path_convert_to_old(a->u.ptr, buf, &new_used);
524:
525: DBG("BGP: Encoding old AS_PATH\n");
526: rv = bgp_encode_attr_hdr(w, BAF_TRANSITIVE, BA_AS_PATH, nl);
527: ADVANCE(w, remains, rv);
528: memcpy(w, buf, nl);
529: ADVANCE(w, remains, nl);
530:
531: if (! new_used)
532: continue;
533:
534: if (remains < (len + 4))
535: goto err_no_buffer;
536:
537: /* We should discard AS_CONFED_SEQUENCE or AS_CONFED_SET path segments
538: * here but we don't support confederations and such paths we already
539: * discarded in bgp_check_as_path().
540: */
541:
542: DBG("BGP: Encoding AS4_PATH\n");
543: rv = bgp_encode_attr_hdr(w, BAF_OPTIONAL | BAF_TRANSITIVE, BA_AS4_PATH, len);
544: ADVANCE(w, remains, rv);
545: memcpy(w, a->u.ptr->data, len);
546: ADVANCE(w, remains, len);
547:
548: continue;
549: }
550:
551: /* The same issue with AGGREGATOR attribute */
552: if ((code == BA_AGGREGATOR) && (! p->as4_session))
553: {
554: int new_used;
555:
556: len = 6;
557: if (remains < (len + 3))
558: goto err_no_buffer;
559:
560: rv = bgp_encode_attr_hdr(w, BAF_OPTIONAL | BAF_TRANSITIVE, BA_AGGREGATOR, len);
561: ADVANCE(w, remains, rv);
562: aggregator_convert_to_old(a->u.ptr, w, &new_used);
563: ADVANCE(w, remains, len);
564:
565: if (! new_used)
566: continue;
567:
568: len = 8;
569: if (remains < (len + 3))
570: goto err_no_buffer;
571:
572: rv = bgp_encode_attr_hdr(w, BAF_OPTIONAL | BAF_TRANSITIVE, BA_AS4_AGGREGATOR, len);
573: ADVANCE(w, remains, rv);
574: memcpy(w, a->u.ptr->data, len);
575: ADVANCE(w, remains, len);
576:
577: continue;
578: }
579:
580: /* Standard path continues here ... */
581:
582: type = a->type & EAF_TYPE_MASK;
583: flags = a->flags & (BAF_OPTIONAL | BAF_TRANSITIVE | BAF_PARTIAL);
584: len = bgp_get_attr_len(a);
585:
586: /* Skip empty sets */
587: if (((type == EAF_TYPE_INT_SET) || (type == EAF_TYPE_EC_SET) || (type == EAF_TYPE_LC_SET)) && (len == 0))
588: continue;
589:
590: if (remains < len + 4)
591: goto err_no_buffer;
592:
593: rv = bgp_encode_attr_hdr(w, flags, code, len);
594: ADVANCE(w, remains, rv);
595:
596: switch (type)
597: {
598: case EAF_TYPE_INT:
599: case EAF_TYPE_ROUTER_ID:
600: if (len == 4)
601: put_u32(w, a->u.data);
602: else
603: *w = a->u.data;
604: break;
605: case EAF_TYPE_IP_ADDRESS:
606: {
607: ip_addr ip = *(ip_addr *)a->u.ptr->data;
608: ipa_hton(ip);
609: memcpy(w, &ip, len);
610: break;
611: }
612: case EAF_TYPE_INT_SET:
613: case EAF_TYPE_LC_SET:
614: case EAF_TYPE_EC_SET:
615: {
616: u32 *z = int_set_get_data(a->u.ptr);
617: int i;
618: for(i=0; i<len; i+=4)
619: put_u32(w+i, *z++);
620: break;
621: }
622: case EAF_TYPE_OPAQUE:
623: case EAF_TYPE_AS_PATH:
624: memcpy(w, a->u.ptr->data, len);
625: break;
626: default:
627: bug("bgp_encode_attrs: unknown attribute type %02x", a->type);
628: }
629: ADVANCE(w, remains, len);
630: }
631: return w - start;
632:
633: err_no_buffer:
634: return -1;
635: }
636:
637: /*
638: static void
639: bgp_init_prefix(struct fib_node *N)
640: {
641: struct bgp_prefix *p = (struct bgp_prefix *) N;
642: p->bucket_node.next = NULL;
643: }
644: */
645:
646: static int
647: bgp_compare_u32(const u32 *x, const u32 *y)
648: {
649: return (*x < *y) ? -1 : (*x > *y) ? 1 : 0;
650: }
651:
652: static inline void
653: bgp_normalize_int_set(u32 *dest, u32 *src, unsigned cnt)
654: {
655: memcpy(dest, src, sizeof(u32) * cnt);
656: qsort(dest, cnt, sizeof(u32), (int(*)(const void *, const void *)) bgp_compare_u32);
657: }
658:
659: static int
660: bgp_compare_ec(const u32 *xp, const u32 *yp)
661: {
662: u64 x = ec_get(xp, 0);
663: u64 y = ec_get(yp, 0);
664: return (x < y) ? -1 : (x > y) ? 1 : 0;
665: }
666:
667: static inline void
668: bgp_normalize_ec_set(struct adata *ad, u32 *src, int internal)
669: {
670: u32 *dst = int_set_get_data(ad);
671:
672: /* Remove non-transitive communities (EC_TBIT active) on external sessions */
673: if (! internal)
674: {
675: int len = int_set_get_size(ad);
676: u32 *t = dst;
677: int i;
678:
679: for (i=0; i < len; i += 2)
680: {
681: if (src[i] & EC_TBIT)
682: continue;
683:
684: *t++ = src[i];
685: *t++ = src[i+1];
686: }
687:
688: ad->length = (t - dst) * 4;
689: }
690: else
691: memcpy(dst, src, ad->length);
692:
693: qsort(dst, ad->length / 8, 8, (int(*)(const void *, const void *)) bgp_compare_ec);
694: }
695:
696: static int
697: bgp_compare_lc(const u32 *x, const u32 *y)
698: {
699: if (x[0] != y[0])
700: return (x[0] > y[0]) ? 1 : -1;
701: if (x[1] != y[1])
702: return (x[1] > y[1]) ? 1 : -1;
703: if (x[2] != y[2])
704: return (x[2] > y[2]) ? 1 : -1;
705: return 0;
706: }
707:
708: static inline void
709: bgp_normalize_lc_set(u32 *dest, u32 *src, unsigned cnt)
710: {
711: memcpy(dest, src, LCOMM_LENGTH * cnt);
712: qsort(dest, cnt, LCOMM_LENGTH, (int(*)(const void *, const void *)) bgp_compare_lc);
713: }
714:
715: static void
716: bgp_rehash_buckets(struct bgp_proto *p)
717: {
718: struct bgp_bucket **old = p->bucket_hash;
719: struct bgp_bucket **new;
720: unsigned oldn = p->hash_size;
721: unsigned i, e, mask;
722: struct bgp_bucket *b;
723:
724: p->hash_size = p->hash_limit;
725: DBG("BGP: Rehashing bucket table from %d to %d\n", oldn, p->hash_size);
726: p->hash_limit *= 4;
727: if (p->hash_limit >= 65536)
728: p->hash_limit = ~0;
729: new = p->bucket_hash = mb_allocz(p->p.pool, p->hash_size * sizeof(struct bgp_bucket *));
730: mask = p->hash_size - 1;
731: for (i=0; i<oldn; i++)
732: while (b = old[i])
733: {
734: old[i] = b->hash_next;
735: e = b->hash & mask;
736: b->hash_next = new[e];
737: if (b->hash_next)
738: b->hash_next->hash_prev = b;
739: b->hash_prev = NULL;
740: new[e] = b;
741: }
742: mb_free(old);
743: }
744:
745: static struct bgp_bucket *
746: bgp_new_bucket(struct bgp_proto *p, ea_list *new, unsigned hash)
747: {
748: struct bgp_bucket *b;
749: unsigned ea_size = sizeof(ea_list) + new->count * sizeof(eattr);
750: unsigned ea_size_aligned = BIRD_ALIGN(ea_size, CPU_STRUCT_ALIGN);
751: unsigned size = sizeof(struct bgp_bucket) + ea_size_aligned;
752: unsigned i;
753: byte *dest;
754: unsigned index = hash & (p->hash_size - 1);
755:
756: /* Gather total size of non-inline attributes */
757: for (i=0; i<new->count; i++)
758: {
759: eattr *a = &new->attrs[i];
760: if (!(a->type & EAF_EMBEDDED))
761: size += BIRD_ALIGN(sizeof(struct adata) + a->u.ptr->length, CPU_STRUCT_ALIGN);
762: }
763:
764: /* Create the bucket and hash it */
765: b = mb_alloc(p->p.pool, size);
766: b->hash_next = p->bucket_hash[index];
767: if (b->hash_next)
768: b->hash_next->hash_prev = b;
769: p->bucket_hash[index] = b;
770: b->hash_prev = NULL;
771: b->hash = hash;
772: add_tail(&p->bucket_queue, &b->send_node);
773: init_list(&b->prefixes);
774: memcpy(b->eattrs, new, ea_size);
775: dest = ((byte *)b->eattrs) + ea_size_aligned;
776:
777: /* Copy values of non-inline attributes */
778: for (i=0; i<new->count; i++)
779: {
780: eattr *a = &b->eattrs->attrs[i];
781: if (!(a->type & EAF_EMBEDDED))
782: {
783: struct adata *oa = a->u.ptr;
784: struct adata *na = (struct adata *) dest;
785: memcpy(na, oa, sizeof(struct adata) + oa->length);
786: a->u.ptr = na;
787: dest += BIRD_ALIGN(sizeof(struct adata) + na->length, CPU_STRUCT_ALIGN);
788: }
789: }
790:
791: /* If needed, rehash */
792: p->hash_count++;
793: if (p->hash_count > p->hash_limit)
794: bgp_rehash_buckets(p);
795:
796: return b;
797: }
798:
799: static struct bgp_bucket *
800: bgp_get_bucket(struct bgp_proto *p, net *n, ea_list *attrs, int originate)
801: {
802: ea_list *new;
803: unsigned i, cnt, hash, code;
804: eattr *a, *d;
805: u32 seen = 0;
806: struct bgp_bucket *b;
807:
808: /* Merge the attribute list */
809: new = alloca(ea_scan(attrs));
810: ea_merge(attrs, new);
811: ea_sort(new);
812:
813: /* Normalize attributes */
814: d = new->attrs;
815: cnt = new->count;
816: new->count = 0;
817: for(i=0; i<cnt; i++)
818: {
819: a = &new->attrs[i];
820: if (EA_PROTO(a->id) != EAP_BGP)
821: continue;
822: code = EA_ID(a->id);
823: if (ATTR_KNOWN(code))
824: {
825: if (!bgp_attr_table[code].allow_in_ebgp && !p->is_internal)
826: continue;
827: /* The flags might have been zero if the attr was added by filters */
828: a->flags = (a->flags & BAF_PARTIAL) | bgp_attr_table[code].expected_flags;
829: if (code < 32)
830: seen |= 1 << code;
831: }
832: else
833: {
834: /* Don't re-export unknown non-transitive attributes */
835: if (!(a->flags & BAF_TRANSITIVE))
836: continue;
837: }
838: *d = *a;
839: if ((d->type & EAF_ORIGINATED) && !originate && (d->flags & BAF_TRANSITIVE) && (d->flags & BAF_OPTIONAL))
840: d->flags |= BAF_PARTIAL;
841: switch (d->type & EAF_TYPE_MASK)
842: {
843: case EAF_TYPE_INT_SET:
844: {
845: struct adata *z = alloca(sizeof(struct adata) + d->u.ptr->length);
846: z->length = d->u.ptr->length;
847: bgp_normalize_int_set((u32 *) z->data, (u32 *) d->u.ptr->data, z->length / 4);
848: d->u.ptr = z;
849: break;
850: }
851: case EAF_TYPE_EC_SET:
852: {
853: struct adata *z = alloca(sizeof(struct adata) + d->u.ptr->length);
854: z->length = d->u.ptr->length;
855: bgp_normalize_ec_set(z, (u32 *) d->u.ptr->data, p->is_internal);
856: d->u.ptr = z;
857: break;
858: }
859: case EAF_TYPE_LC_SET:
860: {
861: struct adata *z = alloca(sizeof(struct adata) + d->u.ptr->length);
862: z->length = d->u.ptr->length;
863: bgp_normalize_lc_set((u32 *) z->data, (u32 *) d->u.ptr->data, z->length / LCOMM_LENGTH);
864: d->u.ptr = z;
865: break;
866: }
867: default: ;
868: }
869: d++;
870: new->count++;
871: }
872:
873: /* Hash */
874: hash = ea_hash(new);
875: for(b=p->bucket_hash[hash & (p->hash_size - 1)]; b; b=b->hash_next)
876: if (b->hash == hash && ea_same(b->eattrs, new))
877: {
878: DBG("Found bucket.\n");
879: return b;
880: }
881:
882: /* Ensure that there are all mandatory attributes */
883: for(i=0; i<ARRAY_SIZE(bgp_mandatory_attrs); i++)
884: if (!(seen & (1 << bgp_mandatory_attrs[i])))
885: {
886: log(L_ERR "%s: Mandatory attribute %s missing in route %I/%d", p->p.name, bgp_attr_table[bgp_mandatory_attrs[i]].name, n->n.prefix, n->n.pxlen);
887: return NULL;
888: }
889:
890: /* Check if next hop is valid */
891: a = ea_find(new, EA_CODE(EAP_BGP, BA_NEXT_HOP));
892: if (!a || ipa_equal(p->cf->remote_ip, *(ip_addr *)a->u.ptr->data))
893: {
894: log(L_ERR "%s: Invalid NEXT_HOP attribute in route %I/%d", p->p.name, n->n.prefix, n->n.pxlen);
895: return NULL;
896: }
897:
898: /* Create new bucket */
899: DBG("Creating bucket.\n");
900: return bgp_new_bucket(p, new, hash);
901: }
902:
903: void
904: bgp_free_bucket(struct bgp_proto *p, struct bgp_bucket *buck)
905: {
906: if (buck->hash_next)
907: buck->hash_next->hash_prev = buck->hash_prev;
908: if (buck->hash_prev)
909: buck->hash_prev->hash_next = buck->hash_next;
910: else
911: p->bucket_hash[buck->hash & (p->hash_size-1)] = buck->hash_next;
912: mb_free(buck);
913: }
914:
915:
916: /* Prefix hash table */
917:
918: #define PXH_KEY(n1) n1->n.prefix, n1->n.pxlen, n1->path_id
919: #define PXH_NEXT(n) n->next
920: #define PXH_EQ(p1,l1,i1,p2,l2,i2) ipa_equal(p1, p2) && l1 == l2 && i1 == i2
921: #define PXH_FN(p,l,i) ipa_hash32(p) ^ u32_hash((l << 16) ^ i)
922:
923: #define PXH_REHASH bgp_pxh_rehash
924: #define PXH_PARAMS /8, *2, 2, 2, 8, 20
925:
926:
927: HASH_DEFINE_REHASH_FN(PXH, struct bgp_prefix)
928:
929: void
930: bgp_init_prefix_table(struct bgp_proto *p, u32 order)
931: {
932: HASH_INIT(p->prefix_hash, p->p.pool, order);
933:
934: p->prefix_slab = sl_new(p->p.pool, sizeof(struct bgp_prefix));
935: }
936:
937: void
938: bgp_free_prefix_table(struct bgp_proto *p)
939: {
940: HASH_FREE(p->prefix_hash);
941:
942: rfree(p->prefix_slab);
943: p->prefix_slab = NULL;
944: }
945:
946: static struct bgp_prefix *
947: bgp_get_prefix(struct bgp_proto *p, ip_addr prefix, int pxlen, u32 path_id)
948: {
949: struct bgp_prefix *bp = HASH_FIND(p->prefix_hash, PXH, prefix, pxlen, path_id);
950:
951: if (bp)
952: return bp;
953:
954: bp = sl_alloc(p->prefix_slab);
955: bp->n.prefix = prefix;
956: bp->n.pxlen = pxlen;
957: bp->path_id = path_id;
958: bp->bucket_node.next = NULL;
959:
960: HASH_INSERT2(p->prefix_hash, PXH, p->p.pool, bp);
961:
962: return bp;
963: }
964:
965: void
966: bgp_free_prefix(struct bgp_proto *p, struct bgp_prefix *bp)
967: {
968: HASH_REMOVE2(p->prefix_hash, PXH, p->p.pool, bp);
969: sl_free(p->prefix_slab, bp);
970: }
971:
972:
973: void
974: bgp_rt_notify(struct proto *P, rtable *tbl UNUSED, net *n, rte *new, rte *old UNUSED, ea_list *attrs)
975: {
976: struct bgp_proto *p = (struct bgp_proto *) P;
977: struct bgp_bucket *buck;
978: struct bgp_prefix *px;
979: rte *key;
980: u32 path_id;
981:
982: DBG("BGP: Got route %I/%d %s\n", n->n.prefix, n->n.pxlen, new ? "up" : "down");
983:
984: if (new)
985: {
986: key = new;
987: buck = bgp_get_bucket(p, n, attrs, new->attrs->source != RTS_BGP);
988: if (!buck) /* Inconsistent attribute list */
989: return;
990: }
991: else
992: {
993: key = old;
994: if (!(buck = p->withdraw_bucket))
995: {
996: buck = p->withdraw_bucket = mb_alloc(P->pool, sizeof(struct bgp_bucket));
997: init_list(&buck->prefixes);
998: }
999: }
1000: path_id = p->add_path_tx ? key->attrs->src->global_id : 0;
1001: px = bgp_get_prefix(p, n->n.prefix, n->n.pxlen, path_id);
1002: if (px->bucket_node.next)
1003: {
1004: DBG("\tRemoving old entry.\n");
1005: rem_node(&px->bucket_node);
1006: }
1007: add_tail(&buck->prefixes, &px->bucket_node);
1008: bgp_schedule_packet(p->conn, PKT_UPDATE);
1009: }
1010:
1011: static int
1012: bgp_create_attrs(struct bgp_proto *p, rte *e, ea_list **attrs, struct linpool *pool)
1013: {
1014: ea_list *ea = lp_alloc(pool, sizeof(ea_list) + 4*sizeof(eattr));
1015: rta *rta = e->attrs;
1016: byte *z;
1017:
1018: ea->next = *attrs;
1019: *attrs = ea;
1020: ea->flags = EALF_SORTED;
1021: ea->count = 4;
1022:
1023: bgp_set_attr(ea->attrs, BA_ORIGIN,
1024: ((rta->source == RTS_OSPF_EXT1) || (rta->source == RTS_OSPF_EXT2)) ? ORIGIN_INCOMPLETE : ORIGIN_IGP);
1025:
1026: if (p->is_internal)
1027: bgp_set_attr_wa(ea->attrs+1, pool, BA_AS_PATH, 0);
1028: else
1029: {
1030: z = bgp_set_attr_wa(ea->attrs+1, pool, BA_AS_PATH, 6);
1031: z[0] = AS_PATH_SEQUENCE;
1032: z[1] = 1; /* 1 AS */
1033: put_u32(z+2, p->local_as);
1034: }
1035:
1036: /* iBGP -> use gw, eBGP multi-hop -> use source_addr,
1037: eBGP single-hop -> use gw if on the same iface */
1038: z = bgp_set_attr_wa(ea->attrs+2, pool, BA_NEXT_HOP, NEXT_HOP_LENGTH);
1039: if (p->cf->next_hop_self ||
1040: rta->dest != RTD_ROUTER ||
1041: ipa_equal(rta->gw, IPA_NONE) ||
1042: ipa_is_link_local(rta->gw) ||
1043: (!p->is_internal && !p->cf->next_hop_keep &&
1044: (!p->neigh || (rta->iface != p->neigh->iface))))
1045: set_next_hop(z, p->source_addr);
1046: else
1047: set_next_hop(z, rta->gw);
1048:
1049: bgp_set_attr(ea->attrs+3, BA_LOCAL_PREF, p->cf->default_local_pref);
1050:
1051: return 0; /* Leave decision to the filters */
1052: }
1053:
1054:
1055: static inline int
1056: bgp_as_path_loopy(struct bgp_proto *p, rta *a)
1057: {
1058: int num = p->cf->allow_local_as + 1;
1059: eattr *e = ea_find(a->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1060: return (e && (num > 0) && as_path_contains(e->u.ptr, p->local_as, num));
1061: }
1062:
1063: static inline int
1064: bgp_originator_id_loopy(struct bgp_proto *p, rta *a)
1065: {
1066: eattr *e = ea_find(a->eattrs, EA_CODE(EAP_BGP, BA_ORIGINATOR_ID));
1067: return (e && (e->u.data == p->local_id));
1068: }
1069:
1070: static inline int
1071: bgp_cluster_list_loopy(struct bgp_proto *p, rta *a)
1072: {
1073: eattr *e = ea_find(a->eattrs, EA_CODE(EAP_BGP, BA_CLUSTER_LIST));
1074: return (e && p->rr_client && int_set_contains(e->u.ptr, p->rr_cluster_id));
1075: }
1076:
1077:
1078: static inline void
1079: bgp_path_prepend(rte *e, ea_list **attrs, struct linpool *pool, u32 as)
1080: {
1081: eattr *a = ea_find(e->attrs->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1082: bgp_attach_attr(attrs, pool, BA_AS_PATH, (uintptr_t) as_path_prepend(pool, a->u.ptr, as));
1083: }
1084:
1085: static inline void
1086: bgp_cluster_list_prepend(rte *e, ea_list **attrs, struct linpool *pool, u32 cid)
1087: {
1088: eattr *a = ea_find(e->attrs->eattrs, EA_CODE(EAP_BGP, BA_CLUSTER_LIST));
1089: bgp_attach_attr(attrs, pool, BA_CLUSTER_LIST, (uintptr_t) int_set_prepend(pool, a ? a->u.ptr : NULL, cid));
1090: }
1091:
1092: static int
1093: bgp_update_attrs(struct bgp_proto *p, rte *e, ea_list **attrs, struct linpool *pool, int rr)
1094: {
1095: eattr *a;
1096:
1097: if (!p->is_internal && !p->rs_client)
1098: {
1099: bgp_path_prepend(e, attrs, pool, p->local_as);
1100:
1101: /* The MULTI_EXIT_DISC attribute received from a neighboring AS MUST NOT be
1102: * propagated to other neighboring ASes.
1103: * Perhaps it would be better to undefine it.
1104: */
1105: a = ea_find(e->attrs->eattrs, EA_CODE(EAP_BGP, BA_MULTI_EXIT_DISC));
1106: if (a)
1107: bgp_attach_attr(attrs, pool, BA_MULTI_EXIT_DISC, 0);
1108: }
1109:
1110: /* iBGP -> keep next_hop, eBGP multi-hop -> use source_addr,
1111: * eBGP single-hop -> keep next_hop if on the same iface.
1112: * If the next_hop is zero (i.e. link-local), keep only if on the same iface.
1113: *
1114: * Note that same-iface-check uses iface from route, which is based on gw.
1115: */
1116: a = ea_find(e->attrs->eattrs, EA_CODE(EAP_BGP, BA_NEXT_HOP));
1117: if (a && !p->cf->next_hop_self &&
1118: (p->cf->next_hop_keep ||
1119: (p->is_internal && ipa_nonzero(*((ip_addr *) a->u.ptr->data))) ||
1120: (p->neigh && (e->attrs->iface == p->neigh->iface))))
1121: {
1122: /* Leave the original next hop attribute, will check later where does it point */
1123: }
1124: else
1125: {
1126: /* Need to create new one */
1127: byte *b = bgp_attach_attr_wa(attrs, pool, BA_NEXT_HOP, NEXT_HOP_LENGTH);
1128: set_next_hop(b, p->source_addr);
1129: }
1130:
1131: if (rr)
1132: {
1133: /* Handling route reflection, RFC 4456 */
1134: struct bgp_proto *src = (struct bgp_proto *) e->attrs->src->proto;
1135:
1136: a = ea_find(e->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGINATOR_ID));
1137: if (!a)
1138: bgp_attach_attr(attrs, pool, BA_ORIGINATOR_ID, src->remote_id);
1139:
1140: /* We attach proper cluster ID according to whether the route is entering or leaving the cluster */
1141: bgp_cluster_list_prepend(e, attrs, pool, src->rr_client ? src->rr_cluster_id : p->rr_cluster_id);
1142:
1143: /* Two RR clients with different cluster ID, hmmm */
1144: if (src->rr_client && p->rr_client && (src->rr_cluster_id != p->rr_cluster_id))
1145: bgp_cluster_list_prepend(e, attrs, pool, p->rr_cluster_id);
1146: }
1147:
1148: return 0; /* Leave decision to the filters */
1149: }
1150:
1151: static int
1152: bgp_community_filter(struct bgp_proto *p, rte *e)
1153: {
1154: eattr *a;
1155: struct adata *d;
1156:
1157: /* Check if we aren't forbidden to export the route by communities */
1158: a = ea_find(e->attrs->eattrs, EA_CODE(EAP_BGP, BA_COMMUNITY));
1159: if (a)
1160: {
1161: d = a->u.ptr;
1162: if (int_set_contains(d, BGP_COMM_NO_ADVERTISE))
1163: {
1164: DBG("\tNO_ADVERTISE\n");
1165: return 1;
1166: }
1167: if (!p->is_internal &&
1168: (int_set_contains(d, BGP_COMM_NO_EXPORT) ||
1169: int_set_contains(d, BGP_COMM_NO_EXPORT_SUBCONFED)))
1170: {
1171: DBG("\tNO_EXPORT\n");
1172: return 1;
1173: }
1174: }
1175:
1176: return 0;
1177: }
1178:
1179: int
1180: bgp_import_control(struct proto *P, rte **new, ea_list **attrs, struct linpool *pool)
1181: {
1182: rte *e = *new;
1183: struct bgp_proto *p = (struct bgp_proto *) P;
1184: struct bgp_proto *new_bgp = (e->attrs->src->proto->proto == &proto_bgp) ?
1185: (struct bgp_proto *) e->attrs->src->proto : NULL;
1186:
1187: if (p == new_bgp) /* Poison reverse updates */
1188: return -1;
1189: if (new_bgp)
1190: {
1191: /* We should check here for cluster list loop, because the receiving BGP instance
1192: might have different cluster ID */
1193: if (bgp_cluster_list_loopy(p, e->attrs))
1194: return -1;
1195:
1196: if (p->cf->interpret_communities && bgp_community_filter(p, e))
1197: return -1;
1198:
1199: if (p->local_as == new_bgp->local_as && p->is_internal && new_bgp->is_internal)
1200: {
1201: /* Redistribution of internal routes with IBGP */
1202: if (p->rr_client || new_bgp->rr_client)
1203: /* Route reflection, RFC 4456 */
1204: return bgp_update_attrs(p, e, attrs, pool, 1);
1205: else
1206: return -1;
1207: }
1208: else
1209: return bgp_update_attrs(p, e, attrs, pool, 0);
1210: }
1211: else
1212: return bgp_create_attrs(p, e, attrs, pool);
1213: }
1214:
1215: static inline u32
1216: bgp_get_neighbor(rte *r)
1217: {
1218: eattr *e = ea_find(r->attrs->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1219: u32 as;
1220:
1221: if (e && as_path_get_first(e->u.ptr, &as))
1222: return as;
1223: else
1224: return ((struct bgp_proto *) r->attrs->src->proto)->remote_as;
1225: }
1226:
1227: static inline int
1228: rte_resolvable(rte *rt)
1229: {
1230: int rd = rt->attrs->dest;
1231: return (rd == RTD_ROUTER) || (rd == RTD_DEVICE) || (rd == RTD_MULTIPATH);
1232: }
1233:
1234: int
1235: bgp_rte_better(rte *new, rte *old)
1236: {
1237: struct bgp_proto *new_bgp = (struct bgp_proto *) new->attrs->src->proto;
1238: struct bgp_proto *old_bgp = (struct bgp_proto *) old->attrs->src->proto;
1239: eattr *x, *y;
1240: u32 n, o;
1241:
1242: /* Skip suppressed routes (see bgp_rte_recalculate()) */
1243: n = new->u.bgp.suppressed;
1244: o = old->u.bgp.suppressed;
1245: if (n > o)
1246: return 0;
1247: if (n < o)
1248: return 1;
1249:
1250: /* RFC 4271 9.1.2.1. Route resolvability test */
1251: n = rte_resolvable(new);
1252: o = rte_resolvable(old);
1253: if (n > o)
1254: return 1;
1255: if (n < o)
1256: return 0;
1257:
1258: /* Start with local preferences */
1259: x = ea_find(new->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
1260: y = ea_find(old->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
1261: n = x ? x->u.data : new_bgp->cf->default_local_pref;
1262: o = y ? y->u.data : old_bgp->cf->default_local_pref;
1263: if (n > o)
1264: return 1;
1265: if (n < o)
1266: return 0;
1267:
1268: /* RFC 4271 9.1.2.2. a) Use AS path lengths */
1269: if (new_bgp->cf->compare_path_lengths || old_bgp->cf->compare_path_lengths)
1270: {
1271: x = ea_find(new->attrs->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1272: y = ea_find(old->attrs->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1273: n = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
1274: o = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
1275: if (n < o)
1276: return 1;
1277: if (n > o)
1278: return 0;
1279: }
1280:
1281: /* RFC 4271 9.1.2.2. b) Use origins */
1282: x = ea_find(new->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGIN));
1283: y = ea_find(old->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGIN));
1284: n = x ? x->u.data : ORIGIN_INCOMPLETE;
1285: o = y ? y->u.data : ORIGIN_INCOMPLETE;
1286: if (n < o)
1287: return 1;
1288: if (n > o)
1289: return 0;
1290:
1291: /* RFC 4271 9.1.2.2. c) Compare MED's */
1292: /* Proper RFC 4271 path selection cannot be interpreted as finding
1293: * the best path in some ordering. It is implemented partially in
1294: * bgp_rte_recalculate() when deterministic_med option is
1295: * active. Without that option, the behavior is just an
1296: * approximation, which in specific situations may lead to
1297: * persistent routing loops, because it is nondeterministic - it
1298: * depends on the order in which routes appeared. But it is also the
1299: * same behavior as used by default in Cisco routers, so it is
1300: * probably not a big issue.
1301: */
1302: if (new_bgp->cf->med_metric || old_bgp->cf->med_metric ||
1303: (bgp_get_neighbor(new) == bgp_get_neighbor(old)))
1304: {
1305: x = ea_find(new->attrs->eattrs, EA_CODE(EAP_BGP, BA_MULTI_EXIT_DISC));
1306: y = ea_find(old->attrs->eattrs, EA_CODE(EAP_BGP, BA_MULTI_EXIT_DISC));
1307: n = x ? x->u.data : new_bgp->cf->default_med;
1308: o = y ? y->u.data : old_bgp->cf->default_med;
1309: if (n < o)
1310: return 1;
1311: if (n > o)
1312: return 0;
1313: }
1314:
1315: /* RFC 4271 9.1.2.2. d) Prefer external peers */
1316: if (new_bgp->is_internal > old_bgp->is_internal)
1317: return 0;
1318: if (new_bgp->is_internal < old_bgp->is_internal)
1319: return 1;
1320:
1321: /* RFC 4271 9.1.2.2. e) Compare IGP metrics */
1322: n = new_bgp->cf->igp_metric ? new->attrs->igp_metric : 0;
1323: o = old_bgp->cf->igp_metric ? old->attrs->igp_metric : 0;
1324: if (n < o)
1325: return 1;
1326: if (n > o)
1327: return 0;
1328:
1329: /* RFC 4271 9.1.2.2. f) Compare BGP identifiers */
1330: /* RFC 4456 9. a) Use ORIGINATOR_ID instead of local neighor ID */
1331: x = ea_find(new->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGINATOR_ID));
1332: y = ea_find(old->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGINATOR_ID));
1333: n = x ? x->u.data : new_bgp->remote_id;
1334: o = y ? y->u.data : old_bgp->remote_id;
1335:
1336: /* RFC 5004 - prefer older routes */
1337: /* (if both are external and from different peer) */
1338: if ((new_bgp->cf->prefer_older || old_bgp->cf->prefer_older) &&
1339: !new_bgp->is_internal && n != o)
1340: return 0;
1341:
1342: /* rest of RFC 4271 9.1.2.2. f) */
1343: if (n < o)
1344: return 1;
1345: if (n > o)
1346: return 0;
1347:
1348: /* RFC 4456 9. b) Compare cluster list lengths */
1349: x = ea_find(new->attrs->eattrs, EA_CODE(EAP_BGP, BA_CLUSTER_LIST));
1350: y = ea_find(old->attrs->eattrs, EA_CODE(EAP_BGP, BA_CLUSTER_LIST));
1351: n = x ? int_set_get_size(x->u.ptr) : 0;
1352: o = y ? int_set_get_size(y->u.ptr) : 0;
1353: if (n < o)
1354: return 1;
1355: if (n > o)
1356: return 0;
1357:
1358: /* RFC 4271 9.1.2.2. g) Compare peer IP adresses */
1359: return (ipa_compare(new_bgp->cf->remote_ip, old_bgp->cf->remote_ip) < 0);
1360: }
1361:
1362:
1363: int
1364: bgp_rte_mergable(rte *pri, rte *sec)
1365: {
1366: struct bgp_proto *pri_bgp = (struct bgp_proto *) pri->attrs->src->proto;
1367: struct bgp_proto *sec_bgp = (struct bgp_proto *) sec->attrs->src->proto;
1368: eattr *x, *y;
1369: u32 p, s;
1370:
1371: /* Skip suppressed routes (see bgp_rte_recalculate()) */
1372: if (pri->u.bgp.suppressed != sec->u.bgp.suppressed)
1373: return 0;
1374:
1375: /* RFC 4271 9.1.2.1. Route resolvability test */
1376: if (!rte_resolvable(sec))
1377: return 0;
1378:
1379: /* Start with local preferences */
1380: x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
1381: y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_LOCAL_PREF));
1382: p = x ? x->u.data : pri_bgp->cf->default_local_pref;
1383: s = y ? y->u.data : sec_bgp->cf->default_local_pref;
1384: if (p != s)
1385: return 0;
1386:
1387: /* RFC 4271 9.1.2.2. a) Use AS path lengths */
1388: if (pri_bgp->cf->compare_path_lengths || sec_bgp->cf->compare_path_lengths)
1389: {
1390: x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1391: y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1392: p = x ? as_path_getlen(x->u.ptr) : AS_PATH_MAXLEN;
1393: s = y ? as_path_getlen(y->u.ptr) : AS_PATH_MAXLEN;
1394:
1395: if (p != s)
1396: return 0;
1397:
1398: // if (DELTA(p, s) > pri_bgp->cf->relax_multipath)
1399: // return 0;
1400: }
1401:
1402: /* RFC 4271 9.1.2.2. b) Use origins */
1403: x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGIN));
1404: y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_ORIGIN));
1405: p = x ? x->u.data : ORIGIN_INCOMPLETE;
1406: s = y ? y->u.data : ORIGIN_INCOMPLETE;
1407: if (p != s)
1408: return 0;
1409:
1410: /* RFC 4271 9.1.2.2. c) Compare MED's */
1411: if (pri_bgp->cf->med_metric || sec_bgp->cf->med_metric ||
1412: (bgp_get_neighbor(pri) == bgp_get_neighbor(sec)))
1413: {
1414: x = ea_find(pri->attrs->eattrs, EA_CODE(EAP_BGP, BA_MULTI_EXIT_DISC));
1415: y = ea_find(sec->attrs->eattrs, EA_CODE(EAP_BGP, BA_MULTI_EXIT_DISC));
1416: p = x ? x->u.data : pri_bgp->cf->default_med;
1417: s = y ? y->u.data : sec_bgp->cf->default_med;
1418: if (p != s)
1419: return 0;
1420: }
1421:
1422: /* RFC 4271 9.1.2.2. d) Prefer external peers */
1423: if (pri_bgp->is_internal != sec_bgp->is_internal)
1424: return 0;
1425:
1426: /* RFC 4271 9.1.2.2. e) Compare IGP metrics */
1427: p = pri_bgp->cf->igp_metric ? pri->attrs->igp_metric : 0;
1428: s = sec_bgp->cf->igp_metric ? sec->attrs->igp_metric : 0;
1429: if (p != s)
1430: return 0;
1431:
1432: /* Remaining criteria are ignored */
1433:
1434: return 1;
1435: }
1436:
1437:
1438:
1439: static inline int
1440: same_group(rte *r, u32 lpref, u32 lasn)
1441: {
1442: return (r->pref == lpref) && (bgp_get_neighbor(r) == lasn);
1443: }
1444:
1445: static inline int
1446: use_deterministic_med(rte *r)
1447: {
1448: struct proto *P = r->attrs->src->proto;
1449: return (P->proto == &proto_bgp) && ((struct bgp_proto *) P)->cf->deterministic_med;
1450: }
1451:
1452: int
1453: bgp_rte_recalculate(rtable *table, net *net, rte *new, rte *old, rte *old_best)
1454: {
1455: rte *r, *s;
1456: rte *key = new ? new : old;
1457: u32 lpref = key->pref;
1458: u32 lasn = bgp_get_neighbor(key);
1459: int old_is_group_best = 0;
1460:
1461: /*
1462: * Proper RFC 4271 path selection is a bit complicated, it cannot be
1463: * implemented just by rte_better(), because it is not a linear
1464: * ordering. But it can be splitted to two levels, where the lower
1465: * level chooses the best routes in each group of routes from the
1466: * same neighboring AS and higher level chooses the best route (with
1467: * a slightly different ordering) between the best-in-group routes.
1468: *
1469: * When deterministic_med is disabled, we just ignore this issue and
1470: * choose the best route by bgp_rte_better() alone. If enabled, the
1471: * lower level of the route selection is done here (for the group
1472: * to which the changed route belongs), all routes in group are
1473: * marked as suppressed, just chosen best-in-group is not.
1474: *
1475: * Global best route selection then implements higher level by
1476: * choosing between non-suppressed routes (as they are always
1477: * preferred over suppressed routes). Routes from BGP protocols
1478: * that do not set deterministic_med are just never suppressed. As
1479: * they do not participate in the lower level selection, it is OK
1480: * that this fn is not called for them.
1481: *
1482: * The idea is simple, the implementation is more problematic,
1483: * mostly because of optimizations in rte_recalculate() that
1484: * avoids full recalculation in most cases.
1485: *
1486: * We can assume that at least one of new, old is non-NULL and both
1487: * are from the same protocol with enabled deterministic_med. We
1488: * group routes by both neighbor AS (lasn) and preference (lpref),
1489: * because bgp_rte_better() does not handle preference itself.
1490: */
1491:
1492: /* If new and old are from different groups, we just process that
1493: as two independent events */
1494: if (new && old && !same_group(old, lpref, lasn))
1495: {
1496: int i1, i2;
1497: i1 = bgp_rte_recalculate(table, net, NULL, old, old_best);
1498: i2 = bgp_rte_recalculate(table, net, new, NULL, old_best);
1499: return i1 || i2;
1500: }
1501:
1502: /*
1503: * We could find the best-in-group and then make some shortcuts like
1504: * in rte_recalculate, but as we would have to walk through all
1505: * net->routes just to find it, it is probably not worth. So we
1506: * just have two simpler fast cases that use just the old route.
1507: * We also set suppressed flag to avoid using it in bgp_rte_better().
1508: */
1509:
1510: if (new)
1511: new->u.bgp.suppressed = 1;
1512:
1513: if (old)
1514: {
1515: old_is_group_best = !old->u.bgp.suppressed;
1516: old->u.bgp.suppressed = 1;
1517: int new_is_better = new && bgp_rte_better(new, old);
1518:
1519: /* The first case - replace not best with worse (or remove not best) */
1520: if (!old_is_group_best && !new_is_better)
1521: return 0;
1522:
1523: /* The second case - replace the best with better */
1524: if (old_is_group_best && new_is_better)
1525: {
1526: /* new is best-in-group, the see discussion below - this is
1527: a special variant of NBG && OBG. From OBG we can deduce
1528: that same_group(old_best) iff (old == old_best) */
1529: new->u.bgp.suppressed = 0;
1530: return (old == old_best);
1531: }
1532: }
1533:
1534: /* The default case - find a new best-in-group route */
1535: r = new; /* new may not be in the list */
1536: for (s=net->routes; rte_is_valid(s); s=s->next)
1537: if (use_deterministic_med(s) && same_group(s, lpref, lasn))
1538: {
1539: s->u.bgp.suppressed = 1;
1540: if (!r || bgp_rte_better(s, r))
1541: r = s;
1542: }
1543:
1544: /* Simple case - the last route in group disappears */
1545: if (!r)
1546: return 0;
1547:
1548: /* Found best-in-group */
1549: r->u.bgp.suppressed = 0;
1550:
1551: /*
1552: * There are generally two reasons why we have to force
1553: * recalculation (return 1): First, the new route may be wrongfully
1554: * chosen to be the best in the first case check in
1555: * rte_recalculate(), this may happen only if old_best is from the
1556: * same group. Second, another (different than new route)
1557: * best-in-group is chosen and that may be the proper best (although
1558: * rte_recalculate() without ignore that possibility).
1559: *
1560: * There are three possible cases according to whether the old route
1561: * was the best in group (OBG, stored in old_is_group_best) and
1562: * whether the new route is the best in group (NBG, tested by r == new).
1563: * These cases work even if old or new is NULL.
1564: *
1565: * NBG -> new is a possible candidate for the best route, so we just
1566: * check for the first reason using same_group().
1567: *
1568: * !NBG && OBG -> Second reason applies, return 1
1569: *
1570: * !NBG && !OBG -> Best in group does not change, old != old_best,
1571: * rte_better(new, old_best) is false and therefore
1572: * the first reason does not apply, return 0
1573: */
1574:
1575: if (r == new)
1576: return old_best && same_group(old_best, lpref, lasn);
1577: else
1578: return old_is_group_best;
1579: }
1580:
1581: static struct adata *
1582: bgp_aggregator_convert_to_new(struct adata *old, struct linpool *pool)
1583: {
1584: struct adata *newa = lp_alloc(pool, sizeof(struct adata) + 8);
1585: newa->length = 8;
1586: aggregator_convert_to_new(old, newa->data);
1587: return newa;
1588: }
1589:
1590:
1591: /* Take last req_as ASNs from path old2 (in 2B format), convert to 4B format
1592: * and append path old4 (in 4B format).
1593: */
1594: static struct adata *
1595: bgp_merge_as_paths(struct adata *old2, struct adata *old4, int req_as, struct linpool *pool)
1596: {
1597: byte buf[old2->length * 2];
1598:
1599: int ol = as_path_convert_to_new(old2, buf, req_as);
1600: int nl = ol + (old4 ? old4->length : 0);
1601:
1602: struct adata *newa = lp_alloc(pool, sizeof(struct adata) + nl);
1603: newa->length = nl;
1604: memcpy(newa->data, buf, ol);
1605: if (old4) memcpy(newa->data + ol, old4->data, old4->length);
1606:
1607: return newa;
1608: }
1609:
1610: static int
1611: as4_aggregator_valid(struct adata *aggr)
1612: {
1613: return aggr->length == 8;
1614: }
1615:
1616:
1617: /* Reconstruct 4B AS_PATH and AGGREGATOR according to RFC 4893 4.2.3 */
1618: static void
1619: bgp_reconstruct_4b_atts(struct bgp_proto *p, rta *a, struct linpool *pool)
1620: {
1621: eattr *p2 =ea_find(a->eattrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1622: eattr *p4 =ea_find(a->eattrs, EA_CODE(EAP_BGP, BA_AS4_PATH));
1623: eattr *a2 =ea_find(a->eattrs, EA_CODE(EAP_BGP, BA_AGGREGATOR));
1624: eattr *a4 =ea_find(a->eattrs, EA_CODE(EAP_BGP, BA_AS4_AGGREGATOR));
1625: int a4_removed = 0;
1626:
1627: if (a4 && !as4_aggregator_valid(a4->u.ptr))
1628: {
1629: log(L_WARN "%s: AS4_AGGREGATOR attribute is invalid, skipping attribute", p->p.name);
1630: a4 = NULL;
1631: a4_removed = 1;
1632: }
1633:
1634: if (a2)
1635: {
1636: u32 a2_as = get_u16(a2->u.ptr->data);
1637:
1638: if (a4)
1639: {
1640: if (a2_as != AS_TRANS)
1641: {
1642: /* Routes were aggregated by old router and therefore AS4_PATH
1643: * and AS4_AGGREGATOR is invalid
1644: *
1645: * Convert AS_PATH and AGGREGATOR to 4B format and finish.
1646: */
1647:
1648: a2->u.ptr = bgp_aggregator_convert_to_new(a2->u.ptr, pool);
1649: p2->u.ptr = bgp_merge_as_paths(p2->u.ptr, NULL, AS_PATH_MAXLEN, pool);
1650:
1651: return;
1652: }
1653: else
1654: {
1655: /* Common case, use AS4_AGGREGATOR attribute */
1656: a2->u.ptr = a4->u.ptr;
1657: }
1658: }
1659: else
1660: {
1661: /* Common case, use old AGGREGATOR attribute */
1662: a2->u.ptr = bgp_aggregator_convert_to_new(a2->u.ptr, pool);
1663:
1664: if ((a2_as == AS_TRANS) && !a4_removed)
1665: log(L_WARN "%s: AGGREGATOR attribute contain AS_TRANS, but AS4_AGGREGATOR is missing", p->p.name);
1666: }
1667: }
1668: else
1669: if (a4)
1670: log(L_WARN "%s: AS4_AGGREGATOR attribute received, but AGGREGATOR attribute is missing", p->p.name);
1671:
1672: int p2_len = as_path_getlen_int(p2->u.ptr, 2);
1673: int p4_len = p4 ? validate_as4_path(p, p4->u.ptr) : -1;
1674:
1675: if (p4 && (p4_len < 0))
1676: log(L_WARN "%s: AS4_PATH attribute is malformed, skipping attribute", p->p.name);
1677:
1678: if ((p4_len <= 0) || (p2_len < p4_len))
1679: p2->u.ptr = bgp_merge_as_paths(p2->u.ptr, NULL, AS_PATH_MAXLEN, pool);
1680: else
1681: p2->u.ptr = bgp_merge_as_paths(p2->u.ptr, p4->u.ptr, p2_len - p4_len, pool);
1682: }
1683:
1684: static void
1685: bgp_remove_as4_attrs(struct bgp_proto *p, rta *a)
1686: {
1687: unsigned id1 = EA_CODE(EAP_BGP, BA_AS4_PATH);
1688: unsigned id2 = EA_CODE(EAP_BGP, BA_AS4_AGGREGATOR);
1689: ea_list **el = &(a->eattrs);
1690:
1691: /* We know that ea_lists constructed in bgp_decode attrs have one attribute per ea_list struct */
1692: while (*el != NULL)
1693: {
1694: unsigned fid = (*el)->attrs[0].id;
1695:
1696: if ((fid == id1) || (fid == id2))
1697: {
1698: *el = (*el)->next;
1699: if (p->as4_session)
1700: log(L_WARN "%s: Unexpected AS4_* attributes received", p->p.name);
1701: }
1702: else
1703: el = &((*el)->next);
1704: }
1705: }
1706:
1707: /**
1708: * bgp_decode_attrs - check and decode BGP attributes
1709: * @conn: connection
1710: * @attr: start of attribute block
1711: * @len: length of attribute block
1712: * @pool: linear pool to make all the allocations in
1713: * @mandatory: 1 iff presence of mandatory attributes has to be checked
1714: *
1715: * This function takes a BGP attribute block (a part of an Update message), checks
1716: * its consistency and converts it to a list of BIRD route attributes represented
1717: * by a &rta.
1718: */
1719: struct rta *
1720: bgp_decode_attrs(struct bgp_conn *conn, byte *attr, uint len, struct linpool *pool, int mandatory)
1721: {
1722: struct bgp_proto *bgp = conn->bgp;
1723: rta *a = lp_alloc(pool, sizeof(struct rta));
1724: uint flags, code, l, i, type;
1725: int errcode;
1726: byte *z, *attr_start;
1727: byte seen[256/8];
1728: ea_list *ea;
1729: struct adata *ad;
1730: int withdraw = 0;
1731:
1732: bzero(a, sizeof(rta));
1733: a->source = RTS_BGP;
1734: a->scope = SCOPE_UNIVERSE;
1735: a->cast = RTC_UNICAST;
1736: /* a->dest = RTD_ROUTER; -- set in bgp_set_next_hop() */
1737: a->from = bgp->cf->remote_ip;
1738:
1739: /* Parse the attributes */
1740: bzero(seen, sizeof(seen));
1741: DBG("BGP: Parsing attributes\n");
1742: while (len)
1743: {
1744: if (len < 2)
1745: goto malformed;
1746: attr_start = attr;
1747: flags = *attr++;
1748: code = *attr++;
1749: len -= 2;
1750: if (flags & BAF_EXT_LEN)
1751: {
1752: if (len < 2)
1753: goto malformed;
1754: l = get_u16(attr);
1755: attr += 2;
1756: len -= 2;
1757: }
1758: else
1759: {
1760: if (len < 1)
1761: goto malformed;
1762: l = *attr++;
1763: len--;
1764: }
1765: if (l > len)
1766: goto malformed;
1767: len -= l;
1768: z = attr;
1769: attr += l;
1770: DBG("Attr %02x %02x %d\n", code, flags, l);
1771: if (seen[code/8] & (1 << (code%8)))
1772: goto malformed;
1773: if (ATTR_KNOWN(code))
1774: {
1775: struct attr_desc *desc = &bgp_attr_table[code];
1776: if (desc->expected_length >= 0 && desc->expected_length != (int) l)
1777: { errcode = 5; goto err; }
1778: if ((desc->expected_flags ^ flags) & (BAF_OPTIONAL | BAF_TRANSITIVE))
1779: { errcode = 4; goto err; }
1780: if (!desc->allow_in_ebgp && !bgp->is_internal)
1781: continue;
1782: if (desc->validate)
1783: {
1784: errcode = desc->validate(bgp, z, l);
1785: if (errcode > 0)
1786: goto err;
1787: if (errcode == IGNORE)
1788: continue;
1789: if (errcode <= WITHDRAW)
1790: {
1791: log(L_WARN "%s: Attribute %s is malformed, withdrawing update",
1792: bgp->p.name, desc->name);
1793: withdraw = 1;
1794: }
1795: }
1796: else if (code == BA_AS_PATH)
1797: {
1798: /* Special case as it might also trim the attribute */
1799: if (validate_as_path(bgp, z, &l) < 0)
1800: { errcode = 11; goto err; }
1801: }
1802: type = desc->type;
1803: }
1804: else /* Unknown attribute */
1805: {
1806: if (!(flags & BAF_OPTIONAL))
1807: { errcode = 2; goto err; }
1808: type = EAF_TYPE_OPAQUE;
1809: }
1810:
1811: // Only OPTIONAL and TRANSITIVE attributes may have non-zero PARTIAL flag
1812: // if (!((flags & BAF_OPTIONAL) && (flags & BAF_TRANSITIVE)) && (flags & BAF_PARTIAL))
1813: // { errcode = 4; goto err; }
1814:
1815: seen[code/8] |= (1 << (code%8));
1816: ea = lp_alloc(pool, sizeof(ea_list) + sizeof(eattr));
1817: ea->next = a->eattrs;
1818: a->eattrs = ea;
1819: ea->flags = 0;
1820: ea->count = 1;
1821: ea->attrs[0].id = EA_CODE(EAP_BGP, code);
1822: ea->attrs[0].flags = flags;
1823: ea->attrs[0].type = type;
1824: if (type & EAF_EMBEDDED)
1825: ad = NULL;
1826: else
1827: {
1828: ad = lp_alloc(pool, sizeof(struct adata) + l);
1829: ea->attrs[0].u.ptr = ad;
1830: ad->length = l;
1831: memcpy(ad->data, z, l);
1832: }
1833: switch (type)
1834: {
1835: case EAF_TYPE_ROUTER_ID:
1836: case EAF_TYPE_INT:
1837: if (l == 1)
1838: ea->attrs[0].u.data = *z;
1839: else
1840: ea->attrs[0].u.data = get_u32(z);
1841: break;
1842: case EAF_TYPE_IP_ADDRESS:
1843: ipa_ntoh(*(ip_addr *)ad->data);
1844: break;
1845: case EAF_TYPE_INT_SET:
1846: case EAF_TYPE_LC_SET:
1847: case EAF_TYPE_EC_SET:
1848: {
1849: u32 *z = (u32 *) ad->data;
1850: for(i=0; i<ad->length/4; i++)
1851: z[i] = ntohl(z[i]);
1852: break;
1853: }
1854: }
1855: }
1856:
1857: if (withdraw)
1858: goto withdraw;
1859:
1860: #ifdef IPV6
1861: /* If we received MP_REACH_NLRI we should check mandatory attributes */
1862: if (bgp->mp_reach_len != 0)
1863: mandatory = 1;
1864: #endif
1865:
1866: /* If there is no (reachability) NLRI, we should exit now */
1867: if (! mandatory)
1868: return a;
1869:
1870: /* Check if all mandatory attributes are present */
1871: for(i=0; i < ARRAY_SIZE(bgp_mandatory_attrs); i++)
1872: {
1873: code = bgp_mandatory_attrs[i];
1874: if (!(seen[code/8] & (1 << (code%8))))
1875: {
1876: bgp_error(conn, 3, 3, &bgp_mandatory_attrs[i], 1);
1877: return NULL;
1878: }
1879: }
1880:
1881: /* When receiving attributes from non-AS4-aware BGP speaker,
1882: * we have to reconstruct 4B AS_PATH and AGGREGATOR attributes
1883: */
1884: if (! bgp->as4_session)
1885: bgp_reconstruct_4b_atts(bgp, a, pool);
1886:
1887: bgp_remove_as4_attrs(bgp, a);
1888:
1889: /* If the AS path attribute contains our AS, reject the routes */
1890: if (bgp_as_path_loopy(bgp, a))
1891: goto withdraw;
1892:
1893: /* Two checks for IBGP loops caused by route reflection, RFC 4456 */
1894: if (bgp_originator_id_loopy(bgp, a) ||
1895: bgp_cluster_list_loopy(bgp, a))
1896: goto withdraw;
1897:
1898: /* If there's no local preference, define one */
1899: if (!(seen[0] & (1 << BA_LOCAL_PREF)))
1900: bgp_attach_attr(&a->eattrs, pool, BA_LOCAL_PREF, bgp->cf->default_local_pref);
1901:
1902: return a;
1903:
1904: withdraw:
1905: return NULL;
1906:
1907: malformed:
1908: bgp_error(conn, 3, 1, NULL, 0);
1909: return NULL;
1910:
1911: err:
1912: bgp_error(conn, 3, errcode, attr_start, z+l-attr_start);
1913: return NULL;
1914: }
1915:
1916: int
1917: bgp_get_attr(eattr *a, byte *buf, int buflen)
1918: {
1919: uint i = EA_ID(a->id);
1920: struct attr_desc *d;
1921: int len;
1922:
1923: if (ATTR_KNOWN(i))
1924: {
1925: d = &bgp_attr_table[i];
1926: len = bsprintf(buf, "%s", d->name);
1927: buf += len;
1928: if (d->format)
1929: {
1930: *buf++ = ':';
1931: *buf++ = ' ';
1932: d->format(a, buf, buflen - len - 2);
1933: return GA_FULL;
1934: }
1935: return GA_NAME;
1936: }
1937: bsprintf(buf, "%02x%s", i, (a->flags & BAF_TRANSITIVE) ? " [t]" : "");
1938: return GA_NAME;
1939: }
1940:
1941: void
1942: bgp_init_bucket_table(struct bgp_proto *p)
1943: {
1944: p->hash_size = 256;
1945: p->hash_limit = p->hash_size * 4;
1946: p->bucket_hash = mb_allocz(p->p.pool, p->hash_size * sizeof(struct bgp_bucket *));
1947: init_list(&p->bucket_queue);
1948: p->withdraw_bucket = NULL;
1949: // fib_init(&p->prefix_fib, p->p.pool, sizeof(struct bgp_prefix), 0, bgp_init_prefix);
1950: }
1951:
1952: void
1953: bgp_free_bucket_table(struct bgp_proto *p)
1954: {
1955: mb_free(p->bucket_hash);
1956: p->bucket_hash = NULL;
1957:
1958: struct bgp_bucket *b;
1959: WALK_LIST_FIRST(b, p->bucket_queue)
1960: {
1961: rem_node(&b->send_node);
1962: mb_free(b);
1963: }
1964:
1965: mb_free(p->withdraw_bucket);
1966: p->withdraw_bucket = NULL;
1967: }
1968:
1969: void
1970: bgp_get_route_info(rte *e, byte *buf, ea_list *attrs)
1971: {
1972: eattr *p = ea_find(attrs, EA_CODE(EAP_BGP, BA_AS_PATH));
1973: eattr *o = ea_find(attrs, EA_CODE(EAP_BGP, BA_ORIGIN));
1974: u32 origas;
1975:
1976: buf += bsprintf(buf, " (%d", e->pref);
1977:
1978: if (e->u.bgp.suppressed)
1979: buf += bsprintf(buf, "-");
1980:
1981: if (e->attrs->hostentry)
1982: {
1983: if (!rte_resolvable(e))
1984: buf += bsprintf(buf, "/-");
1985: else if (e->attrs->igp_metric >= IGP_METRIC_UNKNOWN)
1986: buf += bsprintf(buf, "/?");
1987: else
1988: buf += bsprintf(buf, "/%d", e->attrs->igp_metric);
1989: }
1990: buf += bsprintf(buf, ") [");
1991:
1992: if (p && as_path_get_last(p->u.ptr, &origas))
1993: buf += bsprintf(buf, "AS%u", origas);
1994: if (o)
1995: buf += bsprintf(buf, "%c", "ie?"[o->u.data]);
1996: strcpy(buf, "]");
1997: }
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 / bird / proto / bgp