blob: ac67c62748fe5ddde497e6698ae6bf51a9a0f1be [file] [log] [blame]
paul718e3742002-12-13 20:15:29 +00001/* BGP attributes management routines.
2 Copyright (C) 1996, 97, 98, 1999 Kunihiro Ishiguro
3
4This file is part of GNU Zebra.
5
6GNU Zebra is free software; you can redistribute it and/or modify it
7under the terms of the GNU General Public License as published by the
8Free Software Foundation; either version 2, or (at your option) any
9later version.
10
11GNU Zebra is distributed in the hope that it will be useful, but
12WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU Zebra; see the file COPYING. If not, write to the Free
18Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
1902111-1307, USA. */
20
21#include <zebra.h>
22
23#include "linklist.h"
24#include "prefix.h"
25#include "memory.h"
26#include "vector.h"
27#include "vty.h"
28#include "stream.h"
29#include "log.h"
30#include "hash.h"
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -070031#include "jhash.h"
Donald Sharp04907292016-01-07 10:03:01 -050032#include "filter.h"
paul718e3742002-12-13 20:15:29 +000033
34#include "bgpd/bgpd.h"
35#include "bgpd/bgp_attr.h"
36#include "bgpd/bgp_route.h"
37#include "bgpd/bgp_aspath.h"
38#include "bgpd/bgp_community.h"
39#include "bgpd/bgp_debug.h"
40#include "bgpd/bgp_packet.h"
41#include "bgpd/bgp_ecommunity.h"
Lou Bergerc3741782016-01-12 13:42:01 -050042#include "table.h"
43#include "bgp_encap_types.h"
David Lamparter6b0655a2014-06-04 06:53:35 +020044
paul718e3742002-12-13 20:15:29 +000045/* Attribute strings for logging. */
Stephen Hemminger9bddac42009-05-15 09:59:51 -070046static const struct message attr_str [] =
paul718e3742002-12-13 20:15:29 +000047{
48 { BGP_ATTR_ORIGIN, "ORIGIN" },
49 { BGP_ATTR_AS_PATH, "AS_PATH" },
50 { BGP_ATTR_NEXT_HOP, "NEXT_HOP" },
51 { BGP_ATTR_MULTI_EXIT_DISC, "MULTI_EXIT_DISC" },
52 { BGP_ATTR_LOCAL_PREF, "LOCAL_PREF" },
53 { BGP_ATTR_ATOMIC_AGGREGATE, "ATOMIC_AGGREGATE" },
54 { BGP_ATTR_AGGREGATOR, "AGGREGATOR" },
55 { BGP_ATTR_COMMUNITIES, "COMMUNITY" },
56 { BGP_ATTR_ORIGINATOR_ID, "ORIGINATOR_ID" },
Denis Ovsienkof8627ff2011-10-10 16:52:20 +040057 { BGP_ATTR_CLUSTER_LIST, "CLUSTER_LIST" },
paul718e3742002-12-13 20:15:29 +000058 { BGP_ATTR_DPA, "DPA" },
59 { BGP_ATTR_ADVERTISER, "ADVERTISER"} ,
60 { BGP_ATTR_RCID_PATH, "RCID_PATH" },
61 { BGP_ATTR_MP_REACH_NLRI, "MP_REACH_NLRI" },
62 { BGP_ATTR_MP_UNREACH_NLRI, "MP_UNREACH_NLRI" },
Paul Jakma0b2aa3a2007-10-14 22:32:21 +000063 { BGP_ATTR_EXT_COMMUNITIES, "EXT_COMMUNITIES" },
64 { BGP_ATTR_AS4_PATH, "AS4_PATH" },
65 { BGP_ATTR_AS4_AGGREGATOR, "AS4_AGGREGATOR" },
66 { BGP_ATTR_AS_PATHLIMIT, "AS_PATHLIMIT" },
Lou Bergerc3741782016-01-12 13:42:01 -050067 { BGP_ATTR_ENCAP, "ENCAP" },
paul718e3742002-12-13 20:15:29 +000068};
Balaji.G837d16c2012-09-26 14:09:10 +053069static const int attr_str_max = array_size(attr_str);
Denis Ovsienkoafcb7672011-10-23 22:32:44 +040070
71static const struct message attr_flag_str[] =
72{
73 { BGP_ATTR_FLAG_OPTIONAL, "Optional" },
74 { BGP_ATTR_FLAG_TRANS, "Transitive" },
75 { BGP_ATTR_FLAG_PARTIAL, "Partial" },
76 /* bgp_attr_flags_diagnose() relies on this bit being last in this list */
77 { BGP_ATTR_FLAG_EXTLEN, "Extended Length" },
78};
David Lamparter6b0655a2014-06-04 06:53:35 +020079
Stephen Hemminger9bddac42009-05-15 09:59:51 -070080static struct hash *cluster_hash;
paul718e3742002-12-13 20:15:29 +000081
paul94f2b392005-06-28 12:44:16 +000082static void *
Paul Jakma923de652007-04-29 18:25:17 +000083cluster_hash_alloc (void *p)
paul718e3742002-12-13 20:15:29 +000084{
Paul Jakma923de652007-04-29 18:25:17 +000085 struct cluster_list * val = (struct cluster_list *) p;
paul718e3742002-12-13 20:15:29 +000086 struct cluster_list *cluster;
87
88 cluster = XMALLOC (MTYPE_CLUSTER, sizeof (struct cluster_list));
89 cluster->length = val->length;
90
91 if (cluster->length)
92 {
93 cluster->list = XMALLOC (MTYPE_CLUSTER_VAL, val->length);
94 memcpy (cluster->list, val->list, val->length);
95 }
96 else
97 cluster->list = NULL;
98
99 cluster->refcnt = 0;
100
101 return cluster;
102}
103
104/* Cluster list related functions. */
paul94f2b392005-06-28 12:44:16 +0000105static struct cluster_list *
paul5228ad22004-06-04 17:58:18 +0000106cluster_parse (struct in_addr * pnt, int length)
paul718e3742002-12-13 20:15:29 +0000107{
108 struct cluster_list tmp;
109 struct cluster_list *cluster;
110
111 tmp.length = length;
paul5228ad22004-06-04 17:58:18 +0000112 tmp.list = pnt;
paul718e3742002-12-13 20:15:29 +0000113
114 cluster = hash_get (cluster_hash, &tmp, cluster_hash_alloc);
115 cluster->refcnt++;
116 return cluster;
117}
118
119int
120cluster_loop_check (struct cluster_list *cluster, struct in_addr originator)
121{
122 int i;
123
124 for (i = 0; i < cluster->length / 4; i++)
125 if (cluster->list[i].s_addr == originator.s_addr)
126 return 1;
127 return 0;
128}
129
paul94f2b392005-06-28 12:44:16 +0000130static unsigned int
Paul Jakma923de652007-04-29 18:25:17 +0000131cluster_hash_key_make (void *p)
paul718e3742002-12-13 20:15:29 +0000132{
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -0700133 const struct cluster_list *cluster = p;
paul718e3742002-12-13 20:15:29 +0000134
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -0700135 return jhash(cluster->list, cluster->length, 0);
paul718e3742002-12-13 20:15:29 +0000136}
137
paul94f2b392005-06-28 12:44:16 +0000138static int
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100139cluster_hash_cmp (const void *p1, const void *p2)
paul718e3742002-12-13 20:15:29 +0000140{
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100141 const struct cluster_list * cluster1 = p1;
142 const struct cluster_list * cluster2 = p2;
Paul Jakma923de652007-04-29 18:25:17 +0000143
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100144 return (cluster1->length == cluster2->length &&
145 memcmp (cluster1->list, cluster2->list, cluster1->length) == 0);
paul718e3742002-12-13 20:15:29 +0000146}
147
paul94f2b392005-06-28 12:44:16 +0000148static void
paul718e3742002-12-13 20:15:29 +0000149cluster_free (struct cluster_list *cluster)
150{
151 if (cluster->list)
152 XFREE (MTYPE_CLUSTER_VAL, cluster->list);
153 XFREE (MTYPE_CLUSTER, cluster);
154}
155
Chris Caputo228da422009-07-18 05:44:03 +0000156#if 0
paul94f2b392005-06-28 12:44:16 +0000157static struct cluster_list *
paul718e3742002-12-13 20:15:29 +0000158cluster_dup (struct cluster_list *cluster)
159{
160 struct cluster_list *new;
161
Stephen Hemminger393deb92008-08-18 14:13:29 -0700162 new = XCALLOC (MTYPE_CLUSTER, sizeof (struct cluster_list));
paul718e3742002-12-13 20:15:29 +0000163 new->length = cluster->length;
164
165 if (cluster->length)
166 {
167 new->list = XMALLOC (MTYPE_CLUSTER_VAL, cluster->length);
168 memcpy (new->list, cluster->list, cluster->length);
169 }
170 else
171 new->list = NULL;
172
173 return new;
174}
Chris Caputo228da422009-07-18 05:44:03 +0000175#endif
paul718e3742002-12-13 20:15:29 +0000176
paul94f2b392005-06-28 12:44:16 +0000177static struct cluster_list *
paul718e3742002-12-13 20:15:29 +0000178cluster_intern (struct cluster_list *cluster)
179{
180 struct cluster_list *find;
181
182 find = hash_get (cluster_hash, cluster, cluster_hash_alloc);
183 find->refcnt++;
184
185 return find;
186}
187
188void
189cluster_unintern (struct cluster_list *cluster)
190{
paul718e3742002-12-13 20:15:29 +0000191 if (cluster->refcnt)
192 cluster->refcnt--;
193
194 if (cluster->refcnt == 0)
195 {
Stephen Hemminger9206f9e2011-12-18 19:43:40 +0400196 hash_release (cluster_hash, cluster);
paul718e3742002-12-13 20:15:29 +0000197 cluster_free (cluster);
198 }
199}
200
paul94f2b392005-06-28 12:44:16 +0000201static void
202cluster_init (void)
paul718e3742002-12-13 20:15:29 +0000203{
204 cluster_hash = hash_create (cluster_hash_key_make, cluster_hash_cmp);
205}
Chris Caputo228da422009-07-18 05:44:03 +0000206
207static void
208cluster_finish (void)
209{
Lou Berger056f3762013-04-10 12:30:04 -0700210 hash_clean (cluster_hash, (void (*)(void *))cluster_free);
Chris Caputo228da422009-07-18 05:44:03 +0000211 hash_free (cluster_hash);
212 cluster_hash = NULL;
213}
David Lamparter6b0655a2014-06-04 06:53:35 +0200214
Lou Bergerc3741782016-01-12 13:42:01 -0500215struct bgp_attr_encap_subtlv *
216encap_tlv_dup(struct bgp_attr_encap_subtlv *orig)
217{
218 struct bgp_attr_encap_subtlv *new;
219 struct bgp_attr_encap_subtlv *tail;
220 struct bgp_attr_encap_subtlv *p;
221
222 for (p = orig, tail = new = NULL; p; p = p->next) {
223 int size = sizeof(struct bgp_attr_encap_subtlv) - 1 + p->length;
224 if (tail) {
225 tail->next = XCALLOC(MTYPE_ENCAP_TLV, size);
226 tail = tail->next;
227 } else {
228 tail = new = XCALLOC(MTYPE_ENCAP_TLV, size);
229 }
230 assert(tail);
231 memcpy(tail, p, size);
232 tail->next = NULL;
233 }
234
235 return new;
236}
237
238static void
239encap_free(struct bgp_attr_encap_subtlv *p)
240{
241 struct bgp_attr_encap_subtlv *next;
242 while (p) {
243 next = p->next;
244 p->next = NULL;
245 XFREE(MTYPE_ENCAP_TLV, p);
246 p = next;
247 }
248}
249
250void
251bgp_attr_flush_encap(struct attr *attr)
252{
253 if (!attr || !attr->extra)
254 return;
255
256 if (attr->extra->encap_subtlvs) {
257 encap_free(attr->extra->encap_subtlvs);
258 attr->extra->encap_subtlvs = NULL;
259 }
260}
261
262/*
263 * Compare encap sub-tlv chains
264 *
265 * 1 = equivalent
266 * 0 = not equivalent
267 *
268 * This algorithm could be made faster if needed
269 */
270static int
271encap_same(struct bgp_attr_encap_subtlv *h1, struct bgp_attr_encap_subtlv *h2)
272{
273 struct bgp_attr_encap_subtlv *p;
274 struct bgp_attr_encap_subtlv *q;
275
276 if (!h1 && !h2)
277 return 1;
278 if (h1 && !h2)
279 return 0;
280 if (!h1 && h2)
281 return 0;
282 if (h1 == h2)
283 return 1;
284
285 for (p = h1; p; p = p->next) {
286 for (q = h2; q; q = q->next) {
287 if ((p->type == q->type) &&
288 (p->length == q->length) &&
289 !memcmp(p->value, q->value, p->length)) {
290
291 break;
292 }
293 }
294 if (!q)
295 return 0;
296 }
297
298 for (p = h2; p; p = p->next) {
299 for (q = h1; q; q = q->next) {
300 if ((p->type == q->type) &&
301 (p->length == q->length) &&
302 !memcmp(p->value, q->value, p->length)) {
303
304 break;
305 }
306 }
307 if (!q)
308 return 0;
309 }
310
311 return 1;
312}
313
paul718e3742002-12-13 20:15:29 +0000314/* Unknown transit attribute. */
Stephen Hemminger9bddac42009-05-15 09:59:51 -0700315static struct hash *transit_hash;
paul718e3742002-12-13 20:15:29 +0000316
paul94f2b392005-06-28 12:44:16 +0000317static void
paul718e3742002-12-13 20:15:29 +0000318transit_free (struct transit *transit)
319{
320 if (transit->val)
321 XFREE (MTYPE_TRANSIT_VAL, transit->val);
322 XFREE (MTYPE_TRANSIT, transit);
323}
324
Paul Jakma923de652007-04-29 18:25:17 +0000325
paul94f2b392005-06-28 12:44:16 +0000326static void *
Paul Jakma923de652007-04-29 18:25:17 +0000327transit_hash_alloc (void *p)
paul718e3742002-12-13 20:15:29 +0000328{
329 /* Transit structure is already allocated. */
Paul Jakma923de652007-04-29 18:25:17 +0000330 return p;
paul718e3742002-12-13 20:15:29 +0000331}
332
paul94f2b392005-06-28 12:44:16 +0000333static struct transit *
paul718e3742002-12-13 20:15:29 +0000334transit_intern (struct transit *transit)
335{
336 struct transit *find;
337
338 find = hash_get (transit_hash, transit, transit_hash_alloc);
339 if (find != transit)
340 transit_free (transit);
341 find->refcnt++;
342
343 return find;
344}
345
346void
347transit_unintern (struct transit *transit)
348{
paul718e3742002-12-13 20:15:29 +0000349 if (transit->refcnt)
350 transit->refcnt--;
351
352 if (transit->refcnt == 0)
353 {
Stephen Hemminger9206f9e2011-12-18 19:43:40 +0400354 hash_release (transit_hash, transit);
paul718e3742002-12-13 20:15:29 +0000355 transit_free (transit);
356 }
357}
358
paul94f2b392005-06-28 12:44:16 +0000359static unsigned int
Paul Jakma923de652007-04-29 18:25:17 +0000360transit_hash_key_make (void *p)
paul718e3742002-12-13 20:15:29 +0000361{
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -0700362 const struct transit * transit = p;
paul718e3742002-12-13 20:15:29 +0000363
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -0700364 return jhash(transit->val, transit->length, 0);
paul718e3742002-12-13 20:15:29 +0000365}
366
paul94f2b392005-06-28 12:44:16 +0000367static int
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100368transit_hash_cmp (const void *p1, const void *p2)
paul718e3742002-12-13 20:15:29 +0000369{
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100370 const struct transit * transit1 = p1;
371 const struct transit * transit2 = p2;
Paul Jakma923de652007-04-29 18:25:17 +0000372
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100373 return (transit1->length == transit2->length &&
374 memcmp (transit1->val, transit2->val, transit1->length) == 0);
paul718e3742002-12-13 20:15:29 +0000375}
376
paul94f2b392005-06-28 12:44:16 +0000377static void
Stephen Hemminger66e5cd82009-02-09 10:14:16 -0800378transit_init (void)
paul718e3742002-12-13 20:15:29 +0000379{
380 transit_hash = hash_create (transit_hash_key_make, transit_hash_cmp);
381}
Chris Caputo228da422009-07-18 05:44:03 +0000382
383static void
384transit_finish (void)
385{
Lou Berger056f3762013-04-10 12:30:04 -0700386 hash_clean (transit_hash, (void (*)(void *))transit_free);
Chris Caputo228da422009-07-18 05:44:03 +0000387 hash_free (transit_hash);
388 transit_hash = NULL;
389}
David Lamparter6b0655a2014-06-04 06:53:35 +0200390
paul718e3742002-12-13 20:15:29 +0000391/* Attribute hash routines. */
Stephen Hemminger9bddac42009-05-15 09:59:51 -0700392static struct hash *attrhash;
paul718e3742002-12-13 20:15:29 +0000393
Paul Jakmafb982c22007-05-04 20:15:47 +0000394static struct attr_extra *
395bgp_attr_extra_new (void)
396{
397 return XCALLOC (MTYPE_ATTR_EXTRA, sizeof (struct attr_extra));
398}
399
400void
401bgp_attr_extra_free (struct attr *attr)
402{
403 if (attr->extra)
404 {
Lou Bergerc3741782016-01-12 13:42:01 -0500405 if (attr->extra->encap_subtlvs) {
406 encap_free(attr->extra->encap_subtlvs);
407 attr->extra->encap_subtlvs = NULL;
408 }
Paul Jakmafb982c22007-05-04 20:15:47 +0000409 XFREE (MTYPE_ATTR_EXTRA, attr->extra);
410 attr->extra = NULL;
411 }
412}
413
414struct attr_extra *
415bgp_attr_extra_get (struct attr *attr)
416{
417 if (!attr->extra)
418 attr->extra = bgp_attr_extra_new();
419 return attr->extra;
420}
421
422/* Shallow copy of an attribute
423 * Though, not so shallow that it doesn't copy the contents
424 * of the attr_extra pointed to by 'extra'
425 */
426void
427bgp_attr_dup (struct attr *new, struct attr *orig)
428{
Jorge Boncompte [DTI2]558d1fe2012-05-07 16:53:05 +0000429 struct attr_extra *extra = new->extra;
430
Paul Jakmafb982c22007-05-04 20:15:47 +0000431 *new = *orig;
Christian Frankea0de1d12012-12-07 16:35:00 +0000432 /* if caller provided attr_extra space, use it in any case.
433 *
434 * This is neccesary even if orig->extra equals NULL, because otherwise
435 * memory may be later allocated on the heap by bgp_attr_extra_get.
436 *
437 * That memory would eventually be leaked, because the caller must not
438 * call bgp_attr_extra_free if he provided attr_extra on the stack.
439 */
440 if (extra)
Paul Jakmafb982c22007-05-04 20:15:47 +0000441 {
Christian Frankea0de1d12012-12-07 16:35:00 +0000442 new->extra = extra;
443 memset(new->extra, 0, sizeof(struct attr_extra));
Lou Bergerc3741782016-01-12 13:42:01 -0500444 if (orig->extra) {
Christian Frankea0de1d12012-12-07 16:35:00 +0000445 *new->extra = *orig->extra;
Lou Bergerc3741782016-01-12 13:42:01 -0500446 if (orig->extra->encap_subtlvs) {
447 new->extra->encap_subtlvs = encap_tlv_dup(orig->extra->encap_subtlvs);
448 }
449 }
Christian Frankea0de1d12012-12-07 16:35:00 +0000450 }
451 else if (orig->extra)
452 {
453 new->extra = bgp_attr_extra_new();
Paul Jakmafb982c22007-05-04 20:15:47 +0000454 *new->extra = *orig->extra;
Lou Bergerc3741782016-01-12 13:42:01 -0500455 if (orig->extra->encap_subtlvs) {
456 new->extra->encap_subtlvs = encap_tlv_dup(orig->extra->encap_subtlvs);
457 }
Paul Jakmafb982c22007-05-04 20:15:47 +0000458 }
459}
460
Paul Jakmacbdfbaa2006-03-30 13:20:48 +0000461unsigned long int
462attr_count (void)
463{
464 return attrhash->count;
465}
466
467unsigned long int
468attr_unknown_count (void)
469{
470 return transit_hash->count;
471}
472
paul718e3742002-12-13 20:15:29 +0000473unsigned int
Paul Jakma923de652007-04-29 18:25:17 +0000474attrhash_key_make (void *p)
paul718e3742002-12-13 20:15:29 +0000475{
Jorge Boncompte [DTI2]7fb0cd82012-05-07 16:52:58 +0000476 const struct attr *attr = (struct attr *) p;
477 const struct attr_extra *extra = attr->extra;
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -0700478 uint32_t key = 0;
479#define MIX(val) key = jhash_1word(val, key)
paul718e3742002-12-13 20:15:29 +0000480
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -0700481 MIX(attr->origin);
482 MIX(attr->nexthop.s_addr);
483 MIX(attr->med);
484 MIX(attr->local_pref);
485
Paul Jakmac8f3fe32010-12-05 20:28:02 +0000486 key += attr->origin;
487 key += attr->nexthop.s_addr;
488 key += attr->med;
489 key += attr->local_pref;
Paul Jakmafb982c22007-05-04 20:15:47 +0000490
Jorge Boncompte [DTI2]7fb0cd82012-05-07 16:52:58 +0000491 if (extra)
Paul Jakmafb982c22007-05-04 20:15:47 +0000492 {
Jorge Boncompte [DTI2]7fb0cd82012-05-07 16:52:58 +0000493 MIX(extra->aggregator_as);
494 MIX(extra->aggregator_addr.s_addr);
495 MIX(extra->weight);
496 MIX(extra->mp_nexthop_global_in.s_addr);
Pradosh Mohapatra689bb662013-09-07 07:13:37 +0000497 MIX(extra->originator_id.s_addr);
Piotr Chytła605aa332015-12-01 10:03:54 -0500498 MIX(extra->tag);
Paul Jakmafb982c22007-05-04 20:15:47 +0000499 }
500
paul718e3742002-12-13 20:15:29 +0000501 if (attr->aspath)
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -0700502 MIX(aspath_key_make (attr->aspath));
paul718e3742002-12-13 20:15:29 +0000503 if (attr->community)
Stephen Hemmingerc8e7b892010-08-27 14:12:54 -0700504 MIX(community_hash_make (attr->community));
Paul Jakmafb982c22007-05-04 20:15:47 +0000505
Jorge Boncompte [DTI2]7fb0cd82012-05-07 16:52:58 +0000506 if (extra)
Paul Jakmafb982c22007-05-04 20:15:47 +0000507 {
Jorge Boncompte [DTI2]7fb0cd82012-05-07 16:52:58 +0000508 if (extra->ecommunity)
509 MIX(ecommunity_hash_make (extra->ecommunity));
510 if (extra->cluster)
511 MIX(cluster_hash_key_make (extra->cluster));
512 if (extra->transit)
513 MIX(transit_hash_key_make (extra->transit));
paul718e3742002-12-13 20:15:29 +0000514
Jorge Boncompte [DTI2]7fb0cd82012-05-07 16:52:58 +0000515 MIX(extra->mp_nexthop_len);
516 key = jhash(extra->mp_nexthop_global.s6_addr, 16, key);
517 key = jhash(extra->mp_nexthop_local.s6_addr, 16, key);
Paul Jakmafb982c22007-05-04 20:15:47 +0000518 }
paul718e3742002-12-13 20:15:29 +0000519
520 return key;
521}
522
523int
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100524attrhash_cmp (const void *p1, const void *p2)
paul718e3742002-12-13 20:15:29 +0000525{
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100526 const struct attr * attr1 = p1;
527 const struct attr * attr2 = p2;
Paul Jakma923de652007-04-29 18:25:17 +0000528
paul718e3742002-12-13 20:15:29 +0000529 if (attr1->flag == attr2->flag
530 && attr1->origin == attr2->origin
531 && attr1->nexthop.s_addr == attr2->nexthop.s_addr
paul718e3742002-12-13 20:15:29 +0000532 && attr1->aspath == attr2->aspath
533 && attr1->community == attr2->community
Paul Jakmafb982c22007-05-04 20:15:47 +0000534 && attr1->med == attr2->med
Paul Jakmac8f3fe32010-12-05 20:28:02 +0000535 && attr1->local_pref == attr2->local_pref)
Paul Jakmafb982c22007-05-04 20:15:47 +0000536 {
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100537 const struct attr_extra *ae1 = attr1->extra;
538 const struct attr_extra *ae2 = attr2->extra;
Paul Jakmafb982c22007-05-04 20:15:47 +0000539
540 if (ae1 && ae2
541 && ae1->aggregator_as == ae2->aggregator_as
542 && ae1->aggregator_addr.s_addr == ae2->aggregator_addr.s_addr
543 && ae1->weight == ae2->weight
Piotr Chytła605aa332015-12-01 10:03:54 -0500544 && ae1->tag == ae2->tag
Paul Jakmafb982c22007-05-04 20:15:47 +0000545 && ae1->mp_nexthop_len == ae2->mp_nexthop_len
546 && IPV6_ADDR_SAME (&ae1->mp_nexthop_global, &ae2->mp_nexthop_global)
547 && IPV6_ADDR_SAME (&ae1->mp_nexthop_local, &ae2->mp_nexthop_local)
Paul Jakmafb982c22007-05-04 20:15:47 +0000548 && IPV4_ADDR_SAME (&ae1->mp_nexthop_global_in, &ae2->mp_nexthop_global_in)
549 && ae1->ecommunity == ae2->ecommunity
550 && ae1->cluster == ae2->cluster
Pradosh Mohapatra689bb662013-09-07 07:13:37 +0000551 && ae1->transit == ae2->transit
Lou Bergerc3741782016-01-12 13:42:01 -0500552 && (ae1->encap_tunneltype == ae2->encap_tunneltype)
553 && encap_same(ae1->encap_subtlvs, ae2->encap_subtlvs)
Pradosh Mohapatra689bb662013-09-07 07:13:37 +0000554 && IPV4_ADDR_SAME (&ae1->originator_id, &ae2->originator_id))
Paul Jakmafb982c22007-05-04 20:15:47 +0000555 return 1;
556 else if (ae1 || ae2)
557 return 0;
558 /* neither attribute has extra attributes, so they're same */
559 return 1;
560 }
paul718e3742002-12-13 20:15:29 +0000561 else
562 return 0;
563}
564
paul94f2b392005-06-28 12:44:16 +0000565static void
Stephen Hemmingerffe11cf2008-08-14 16:25:25 +0100566attrhash_init (void)
paul718e3742002-12-13 20:15:29 +0000567{
568 attrhash = hash_create (attrhash_key_make, attrhash_cmp);
569}
570
Lou Berger056f3762013-04-10 12:30:04 -0700571/*
572 * special for hash_clean below
573 */
574static void
575attr_vfree (void *attr)
576{
577 bgp_attr_extra_free ((struct attr *)attr);
578 XFREE (MTYPE_ATTR, attr);
579}
580
paul94f2b392005-06-28 12:44:16 +0000581static void
Chris Caputo228da422009-07-18 05:44:03 +0000582attrhash_finish (void)
583{
Lou Berger056f3762013-04-10 12:30:04 -0700584 hash_clean(attrhash, attr_vfree);
Chris Caputo228da422009-07-18 05:44:03 +0000585 hash_free (attrhash);
586 attrhash = NULL;
587}
588
589static void
paul718e3742002-12-13 20:15:29 +0000590attr_show_all_iterator (struct hash_backet *backet, struct vty *vty)
591{
592 struct attr *attr = backet->data;
593
594 vty_out (vty, "attr[%ld] nexthop %s%s", attr->refcnt,
595 inet_ntoa (attr->nexthop), VTY_NEWLINE);
596}
597
598void
599attr_show_all (struct vty *vty)
600{
601 hash_iterate (attrhash,
602 (void (*)(struct hash_backet *, void *))
603 attr_show_all_iterator,
604 vty);
605}
606
paul94f2b392005-06-28 12:44:16 +0000607static void *
Paul Jakma923de652007-04-29 18:25:17 +0000608bgp_attr_hash_alloc (void *p)
paul718e3742002-12-13 20:15:29 +0000609{
Paul Jakma923de652007-04-29 18:25:17 +0000610 struct attr * val = (struct attr *) p;
paul718e3742002-12-13 20:15:29 +0000611 struct attr *attr;
612
613 attr = XMALLOC (MTYPE_ATTR, sizeof (struct attr));
614 *attr = *val;
Paul Jakmafb982c22007-05-04 20:15:47 +0000615 if (val->extra)
616 {
617 attr->extra = bgp_attr_extra_new ();
618 *attr->extra = *val->extra;
Lou Bergerc3741782016-01-12 13:42:01 -0500619
620 if (attr->extra->encap_subtlvs) {
621 attr->extra->encap_subtlvs = encap_tlv_dup(attr->extra->encap_subtlvs);
622 }
Paul Jakmafb982c22007-05-04 20:15:47 +0000623 }
paul718e3742002-12-13 20:15:29 +0000624 attr->refcnt = 0;
625 return attr;
626}
627
628/* Internet argument attribute. */
629struct attr *
630bgp_attr_intern (struct attr *attr)
631{
632 struct attr *find;
633
634 /* Intern referenced strucutre. */
635 if (attr->aspath)
636 {
637 if (! attr->aspath->refcnt)
638 attr->aspath = aspath_intern (attr->aspath);
639 else
640 attr->aspath->refcnt++;
641 }
642 if (attr->community)
643 {
644 if (! attr->community->refcnt)
645 attr->community = community_intern (attr->community);
646 else
647 attr->community->refcnt++;
648 }
Paul Jakmafb982c22007-05-04 20:15:47 +0000649 if (attr->extra)
paul718e3742002-12-13 20:15:29 +0000650 {
Paul Jakmafb982c22007-05-04 20:15:47 +0000651 struct attr_extra *attre = attr->extra;
652
653 if (attre->ecommunity)
654 {
655 if (! attre->ecommunity->refcnt)
656 attre->ecommunity = ecommunity_intern (attre->ecommunity);
657 else
658 attre->ecommunity->refcnt++;
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000659
Paul Jakmafb982c22007-05-04 20:15:47 +0000660 }
661 if (attre->cluster)
662 {
663 if (! attre->cluster->refcnt)
664 attre->cluster = cluster_intern (attre->cluster);
665 else
666 attre->cluster->refcnt++;
667 }
668 if (attre->transit)
669 {
670 if (! attre->transit->refcnt)
671 attre->transit = transit_intern (attre->transit);
672 else
673 attre->transit->refcnt++;
674 }
paul718e3742002-12-13 20:15:29 +0000675 }
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000676
paul718e3742002-12-13 20:15:29 +0000677 find = (struct attr *) hash_get (attrhash, attr, bgp_attr_hash_alloc);
678 find->refcnt++;
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000679
paul718e3742002-12-13 20:15:29 +0000680 return find;
681}
682
Paul Jakma03e214c2007-04-29 18:31:07 +0000683
paul718e3742002-12-13 20:15:29 +0000684/* Make network statement's attribute. */
685struct attr *
686bgp_attr_default_set (struct attr *attr, u_char origin)
687{
688 memset (attr, 0, sizeof (struct attr));
Paul Jakmafb982c22007-05-04 20:15:47 +0000689 bgp_attr_extra_get (attr);
690
paul718e3742002-12-13 20:15:29 +0000691 attr->origin = origin;
692 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
693 attr->aspath = aspath_empty ();
694 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
Paul Jakmafb982c22007-05-04 20:15:47 +0000695 attr->extra->weight = BGP_ATTR_DEFAULT_WEIGHT;
Piotr Chytła605aa332015-12-01 10:03:54 -0500696 attr->extra->tag = 0;
paul718e3742002-12-13 20:15:29 +0000697 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
Paul Jakmafb982c22007-05-04 20:15:47 +0000698 attr->extra->mp_nexthop_len = IPV6_MAX_BYTELEN;
Paul Jakma03e214c2007-04-29 18:31:07 +0000699
paul718e3742002-12-13 20:15:29 +0000700 return attr;
701}
702
Paul Jakma03e214c2007-04-29 18:31:07 +0000703
paul718e3742002-12-13 20:15:29 +0000704/* Make network statement's attribute. */
705struct attr *
706bgp_attr_default_intern (u_char origin)
707{
708 struct attr attr;
709 struct attr *new;
Jorge Boncompte [DTI2]e16a4132012-05-07 16:52:57 +0000710
Lou Bergerc3741782016-01-12 13:42:01 -0500711 memset (&attr, 0, sizeof (struct attr));
712 bgp_attr_extra_get (&attr);
713
Paul Jakma03e214c2007-04-29 18:31:07 +0000714 bgp_attr_default_set(&attr, origin);
paul718e3742002-12-13 20:15:29 +0000715
716 new = bgp_attr_intern (&attr);
Paul Jakmafb982c22007-05-04 20:15:47 +0000717 bgp_attr_extra_free (&attr);
718
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000719 aspath_unintern (&new->aspath);
paul718e3742002-12-13 20:15:29 +0000720 return new;
721}
722
Daniel Walton76a72802015-05-19 17:47:24 -0700723/* Create the attributes for an aggregate */
paul718e3742002-12-13 20:15:29 +0000724struct attr *
725bgp_attr_aggregate_intern (struct bgp *bgp, u_char origin,
726 struct aspath *aspath,
727 struct community *community, int as_set)
728{
729 struct attr attr;
730 struct attr *new;
Jorge Boncompte [DTI2]938ef3a2012-05-07 16:52:59 +0000731 struct attr_extra attre;
paul718e3742002-12-13 20:15:29 +0000732
733 memset (&attr, 0, sizeof (struct attr));
Jorge Boncompte [DTI2]938ef3a2012-05-07 16:52:59 +0000734 memset (&attre, 0, sizeof (struct attr_extra));
735 attr.extra = &attre;
736
paul718e3742002-12-13 20:15:29 +0000737 /* Origin attribute. */
738 attr.origin = origin;
739 attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
740
741 /* AS path attribute. */
742 if (aspath)
743 attr.aspath = aspath_intern (aspath);
744 else
745 attr.aspath = aspath_empty ();
746 attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
747
748 /* Next hop attribute. */
749 attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
750
751 if (community)
752 {
753 attr.community = community;
754 attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES);
755 }
756
Jorge Boncompte [DTI2]938ef3a2012-05-07 16:52:59 +0000757 attre.weight = BGP_ATTR_DEFAULT_WEIGHT;
Jorge Boncompte [DTI2]938ef3a2012-05-07 16:52:59 +0000758 attre.mp_nexthop_len = IPV6_MAX_BYTELEN;
Lou Berger205e6742016-01-12 13:42:11 -0500759
paul718e3742002-12-13 20:15:29 +0000760 if (! as_set)
761 attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE);
762 attr.flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR);
763 if (CHECK_FLAG (bgp->config, BGP_CONFIG_CONFEDERATION))
Jorge Boncompte [DTI2]938ef3a2012-05-07 16:52:59 +0000764 attre.aggregator_as = bgp->confed_id;
paul718e3742002-12-13 20:15:29 +0000765 else
Jorge Boncompte [DTI2]938ef3a2012-05-07 16:52:59 +0000766 attre.aggregator_as = bgp->as;
767 attre.aggregator_addr = bgp->router_id;
paul718e3742002-12-13 20:15:29 +0000768
769 new = bgp_attr_intern (&attr);
Jorge Boncompte [DTI2]938ef3a2012-05-07 16:52:59 +0000770
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000771 aspath_unintern (&new->aspath);
paul718e3742002-12-13 20:15:29 +0000772 return new;
773}
774
Paul Jakmab881c702010-11-23 16:35:42 +0000775/* Unintern just the sub-components of the attr, but not the attr */
776void
777bgp_attr_unintern_sub (struct attr *attr)
778{
779 /* aspath refcount shoud be decrement. */
780 if (attr->aspath)
781 aspath_unintern (&attr->aspath);
Jorge Boncompte [DTI2]d92a2f32013-07-31 16:36:08 +0000782 UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH));
Paul Jakmab881c702010-11-23 16:35:42 +0000783
784 if (attr->community)
785 community_unintern (&attr->community);
Jorge Boncompte [DTI2]d92a2f32013-07-31 16:36:08 +0000786 UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES));
Paul Jakmab881c702010-11-23 16:35:42 +0000787
788 if (attr->extra)
789 {
790 if (attr->extra->ecommunity)
791 ecommunity_unintern (&attr->extra->ecommunity);
Jorge Boncompte [DTI2]d92a2f32013-07-31 16:36:08 +0000792 UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES));
Paul Jakmab881c702010-11-23 16:35:42 +0000793
794 if (attr->extra->cluster)
795 cluster_unintern (attr->extra->cluster);
Jorge Boncompte [DTI2]d92a2f32013-07-31 16:36:08 +0000796 UNSET_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST));
Paul Jakmab881c702010-11-23 16:35:42 +0000797
798 if (attr->extra->transit)
799 transit_unintern (attr->extra->transit);
800 }
801}
802
paul718e3742002-12-13 20:15:29 +0000803/* Free bgp attribute and aspath. */
804void
Jorge Boncompte [DTI2]1a2fd702012-05-07 16:53:00 +0000805bgp_attr_unintern (struct attr **pattr)
paul718e3742002-12-13 20:15:29 +0000806{
Jorge Boncompte [DTI2]1a2fd702012-05-07 16:53:00 +0000807 struct attr *attr = *pattr;
paul718e3742002-12-13 20:15:29 +0000808 struct attr *ret;
Paul Jakmab881c702010-11-23 16:35:42 +0000809 struct attr tmp;
Jorge Boncompte [DTI2]b9f1dca2012-05-07 16:53:01 +0000810 struct attr_extra tmp_extra;
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000811
paul718e3742002-12-13 20:15:29 +0000812 /* Decrement attribute reference. */
Jorge Boncompte [DTI2]1a2fd702012-05-07 16:53:00 +0000813 attr->refcnt--;
Paul Jakmab881c702010-11-23 16:35:42 +0000814
Jorge Boncompte [DTI2]1a2fd702012-05-07 16:53:00 +0000815 tmp = *attr;
Paul Jakmab881c702010-11-23 16:35:42 +0000816
Jorge Boncompte [DTI2]1a2fd702012-05-07 16:53:00 +0000817 if (attr->extra)
Paul Jakmafb982c22007-05-04 20:15:47 +0000818 {
Jorge Boncompte [DTI2]b9f1dca2012-05-07 16:53:01 +0000819 tmp.extra = &tmp_extra;
Jorge Boncompte [DTI2]1a2fd702012-05-07 16:53:00 +0000820 memcpy (tmp.extra, attr->extra, sizeof (struct attr_extra));
Paul Jakmafb982c22007-05-04 20:15:47 +0000821 }
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000822
paul718e3742002-12-13 20:15:29 +0000823 /* If reference becomes zero then free attribute object. */
Jorge Boncompte [DTI2]1a2fd702012-05-07 16:53:00 +0000824 if (attr->refcnt == 0)
825 {
826 ret = hash_release (attrhash, attr);
paul718e3742002-12-13 20:15:29 +0000827 assert (ret != NULL);
Jorge Boncompte [DTI2]1a2fd702012-05-07 16:53:00 +0000828 bgp_attr_extra_free (attr);
829 XFREE (MTYPE_ATTR, attr);
830 *pattr = NULL;
paul718e3742002-12-13 20:15:29 +0000831 }
832
Paul Jakmab881c702010-11-23 16:35:42 +0000833 bgp_attr_unintern_sub (&tmp);
paul718e3742002-12-13 20:15:29 +0000834}
835
836void
837bgp_attr_flush (struct attr *attr)
838{
839 if (attr->aspath && ! attr->aspath->refcnt)
Lou Berger370b7e52016-02-04 21:29:49 -0500840 {
841 aspath_free (attr->aspath);
842 attr->aspath = NULL;
843 }
paul718e3742002-12-13 20:15:29 +0000844 if (attr->community && ! attr->community->refcnt)
Lou Berger370b7e52016-02-04 21:29:49 -0500845 {
846 community_free (attr->community);
847 attr->community = NULL;
848 }
Paul Jakmafb982c22007-05-04 20:15:47 +0000849 if (attr->extra)
850 {
851 struct attr_extra *attre = attr->extra;
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000852
Paul Jakmafb982c22007-05-04 20:15:47 +0000853 if (attre->ecommunity && ! attre->ecommunity->refcnt)
Paul Jakmaf6f434b2010-11-23 21:28:03 +0000854 ecommunity_free (&attre->ecommunity);
Paul Jakmafb982c22007-05-04 20:15:47 +0000855 if (attre->cluster && ! attre->cluster->refcnt)
Lou Berger370b7e52016-02-04 21:29:49 -0500856 {
857 cluster_free (attre->cluster);
858 attre->cluster = NULL;
859 }
Paul Jakmafb982c22007-05-04 20:15:47 +0000860 if (attre->transit && ! attre->transit->refcnt)
Lou Berger370b7e52016-02-04 21:29:49 -0500861 {
862 transit_free (attre->transit);
863 attre->transit = NULL;
864 }
Lou Bergerc3741782016-01-12 13:42:01 -0500865 encap_free(attre->encap_subtlvs);
866 attre->encap_subtlvs = NULL;
Paul Jakmafb982c22007-05-04 20:15:47 +0000867 }
paul718e3742002-12-13 20:15:29 +0000868}
869
Paul Jakmab881c702010-11-23 16:35:42 +0000870/* Implement draft-scudder-idr-optional-transitive behaviour and
871 * avoid resetting sessions for malformed attributes which are
872 * are partial/optional and hence where the error likely was not
873 * introduced by the sending neighbour.
874 */
875static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +0000876bgp_attr_malformed (struct bgp_attr_parser_args *args, u_char subcode,
877 bgp_size_t length)
Paul Jakmab881c702010-11-23 16:35:42 +0000878{
Paul Jakma835315b2012-01-18 12:28:30 +0000879 struct peer *const peer = args->peer;
880 const u_int8_t flags = args->flags;
881 /* startp and length must be special-cased, as whether or not to
882 * send the attribute data with the NOTIFY depends on the error,
883 * the caller therefore signals this with the seperate length argument
884 */
Paul Jakmabd471fe2012-03-15 11:30:00 +0000885 u_char *notify_datap = (length > 0 ? args->startp : NULL);
Paul Jakma835315b2012-01-18 12:28:30 +0000886
Paul Jakmab881c702010-11-23 16:35:42 +0000887 /* Only relax error handling for eBGP peers */
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +0000888 if (peer->sort != BGP_PEER_EBGP)
Paul Jakmab881c702010-11-23 16:35:42 +0000889 {
890 bgp_notify_send_with_data (peer, BGP_NOTIFY_UPDATE_ERR, subcode,
Paul Jakmabd471fe2012-03-15 11:30:00 +0000891 notify_datap, length);
Paul Jakmab881c702010-11-23 16:35:42 +0000892 return BGP_ATTR_PARSE_ERROR;
893
894 }
895
Paul Jakmabd471fe2012-03-15 11:30:00 +0000896 /* Adjust the stream getp to the end of the attribute, in case we can
897 * still proceed but the caller hasn't read all the attribute.
898 */
899 stream_set_getp (BGP_INPUT (peer),
900 (args->startp - STREAM_DATA (BGP_INPUT (peer)))
901 + args->total);
902
Paul Jakma835315b2012-01-18 12:28:30 +0000903 switch (args->type) {
Paul Jakmafa61e162012-03-25 21:31:47 +0100904 /* where an attribute is relatively inconsequential, e.g. it does not
905 * affect route selection, and can be safely ignored, then any such
906 * attributes which are malformed should just be ignored and the route
907 * processed as normal.
Paul Jakmab881c702010-11-23 16:35:42 +0000908 */
909 case BGP_ATTR_AS4_AGGREGATOR:
910 case BGP_ATTR_AGGREGATOR:
911 case BGP_ATTR_ATOMIC_AGGREGATE:
912 return BGP_ATTR_PARSE_PROCEED;
913
914 /* Core attributes, particularly ones which may influence route
Paul Jakmafa61e162012-03-25 21:31:47 +0100915 * selection, should always cause session resets
Paul Jakmab881c702010-11-23 16:35:42 +0000916 */
917 case BGP_ATTR_ORIGIN:
918 case BGP_ATTR_AS_PATH:
919 case BGP_ATTR_NEXT_HOP:
920 case BGP_ATTR_MULTI_EXIT_DISC:
921 case BGP_ATTR_LOCAL_PREF:
922 case BGP_ATTR_COMMUNITIES:
923 case BGP_ATTR_ORIGINATOR_ID:
924 case BGP_ATTR_CLUSTER_LIST:
925 case BGP_ATTR_MP_REACH_NLRI:
926 case BGP_ATTR_MP_UNREACH_NLRI:
927 case BGP_ATTR_EXT_COMMUNITIES:
928 bgp_notify_send_with_data (peer, BGP_NOTIFY_UPDATE_ERR, subcode,
Paul Jakmabd471fe2012-03-15 11:30:00 +0000929 notify_datap, length);
Paul Jakmab881c702010-11-23 16:35:42 +0000930 return BGP_ATTR_PARSE_ERROR;
931 }
932
933 /* Partial optional attributes that are malformed should not cause
934 * the whole session to be reset. Instead treat it as a withdrawal
935 * of the routes, if possible.
936 */
Paul Jakma835315b2012-01-18 12:28:30 +0000937 if (CHECK_FLAG (flags, BGP_ATTR_FLAG_TRANS)
938 && CHECK_FLAG (flags, BGP_ATTR_FLAG_OPTIONAL)
939 && CHECK_FLAG (flags, BGP_ATTR_FLAG_PARTIAL))
Paul Jakmab881c702010-11-23 16:35:42 +0000940 return BGP_ATTR_PARSE_WITHDRAW;
941
942 /* default to reset */
David Lamparterf57000c2014-06-04 01:01:10 +0200943 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS;
Paul Jakmab881c702010-11-23 16:35:42 +0000944}
945
Denis Ovsienkoafcb7672011-10-23 22:32:44 +0400946/* Find out what is wrong with the path attribute flag bits and log the error.
947 "Flag bits" here stand for Optional, Transitive and Partial, but not for
948 Extended Length. Checking O/T/P bits at once implies, that the attribute
949 being diagnosed is defined by RFC as either a "well-known" or an "optional,
950 non-transitive" attribute. */
951static void
Paul Jakma835315b2012-01-18 12:28:30 +0000952bgp_attr_flags_diagnose (struct bgp_attr_parser_args *args,
953 u_int8_t desired_flags /* how RFC says it must be */
Denis Ovsienkoafcb7672011-10-23 22:32:44 +0400954)
955{
956 u_char seen = 0, i;
Paul Jakma835315b2012-01-18 12:28:30 +0000957 u_char real_flags = args->flags;
958 const u_int8_t attr_code = args->type;
959
Denis Ovsienkoafcb7672011-10-23 22:32:44 +0400960 desired_flags &= ~BGP_ATTR_FLAG_EXTLEN;
961 real_flags &= ~BGP_ATTR_FLAG_EXTLEN;
962 for (i = 0; i <= 2; i++) /* O,T,P, but not E */
963 if
964 (
965 CHECK_FLAG (desired_flags, attr_flag_str[i].key) !=
966 CHECK_FLAG (real_flags, attr_flag_str[i].key)
967 )
968 {
Paul Jakma835315b2012-01-18 12:28:30 +0000969 zlog (args->peer->log, LOG_ERR, "%s attribute must%s be flagged as \"%s\"",
Denis Ovsienkoafcb7672011-10-23 22:32:44 +0400970 LOOKUP (attr_str, attr_code),
971 CHECK_FLAG (desired_flags, attr_flag_str[i].key) ? "" : " not",
972 attr_flag_str[i].str);
973 seen = 1;
974 }
Paul Jakmafa5831e2012-03-27 11:54:04 +0100975 if (!seen)
976 {
977 zlog (args->peer->log, LOG_DEBUG,
978 "Strange, %s called for attr %s, but no problem found with flags"
979 " (real flags 0x%x, desired 0x%x)",
980 __func__, LOOKUP (attr_str, attr_code),
981 real_flags, desired_flags);
982 }
Denis Ovsienkoafcb7672011-10-23 22:32:44 +0400983}
984
Paul Jakma3ecab4c2012-01-17 13:31:33 +0000985/* Required flags for attributes. EXTLEN will be masked off when testing,
986 * as will PARTIAL for optional+transitive attributes.
987 */
988const u_int8_t attr_flags_values [] = {
989 [BGP_ATTR_ORIGIN] = BGP_ATTR_FLAG_TRANS,
990 [BGP_ATTR_AS_PATH] = BGP_ATTR_FLAG_TRANS,
991 [BGP_ATTR_NEXT_HOP] = BGP_ATTR_FLAG_TRANS,
992 [BGP_ATTR_MULTI_EXIT_DISC] = BGP_ATTR_FLAG_OPTIONAL,
993 [BGP_ATTR_LOCAL_PREF] = BGP_ATTR_FLAG_TRANS,
994 [BGP_ATTR_ATOMIC_AGGREGATE] = BGP_ATTR_FLAG_TRANS,
995 [BGP_ATTR_AGGREGATOR] = BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL,
996 [BGP_ATTR_COMMUNITIES] = BGP_ATTR_FLAG_TRANS | BGP_ATTR_FLAG_OPTIONAL,
997 [BGP_ATTR_ORIGINATOR_ID] = BGP_ATTR_FLAG_OPTIONAL,
998 [BGP_ATTR_CLUSTER_LIST] = BGP_ATTR_FLAG_OPTIONAL,
999 [BGP_ATTR_MP_REACH_NLRI] = BGP_ATTR_FLAG_OPTIONAL,
1000 [BGP_ATTR_MP_UNREACH_NLRI] = BGP_ATTR_FLAG_OPTIONAL,
1001 [BGP_ATTR_EXT_COMMUNITIES] = BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
1002 [BGP_ATTR_AS4_PATH] = BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
1003 [BGP_ATTR_AS4_AGGREGATOR] = BGP_ATTR_FLAG_OPTIONAL | BGP_ATTR_FLAG_TRANS,
1004};
1005static const size_t attr_flags_values_max =
1006 sizeof (attr_flags_values) / sizeof (attr_flags_values[0]);
1007
1008static int
Paul Jakma835315b2012-01-18 12:28:30 +00001009bgp_attr_flag_invalid (struct bgp_attr_parser_args *args)
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001010{
1011 u_int8_t mask = BGP_ATTR_FLAG_EXTLEN;
Paul Jakma835315b2012-01-18 12:28:30 +00001012 const u_int8_t flags = args->flags;
1013 const u_int8_t attr_code = args->type;
1014 struct peer *const peer = args->peer;
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001015
1016 /* there may be attributes we don't know about */
1017 if (attr_code > attr_flags_values_max)
1018 return 0;
1019 if (attr_flags_values[attr_code] == 0)
1020 return 0;
1021
1022 /* RFC4271, "For well-known attributes, the Transitive bit MUST be set to
1023 * 1."
1024 */
1025 if (!CHECK_FLAG (BGP_ATTR_FLAG_OPTIONAL, flags)
1026 && !CHECK_FLAG (BGP_ATTR_FLAG_TRANS, flags))
1027 {
1028 zlog (peer->log, LOG_ERR,
1029 "%s well-known attributes must have transitive flag set (%x)",
1030 LOOKUP (attr_str, attr_code), flags);
1031 return 1;
1032 }
1033
1034 /* "For well-known attributes and for optional non-transitive attributes,
1035 * the Partial bit MUST be set to 0."
1036 */
1037 if (CHECK_FLAG (flags, BGP_ATTR_FLAG_PARTIAL))
1038 {
1039 if (!CHECK_FLAG (flags, BGP_ATTR_FLAG_OPTIONAL))
1040 {
1041 zlog (peer->log, LOG_ERR,
1042 "%s well-known attribute "
1043 "must NOT have the partial flag set (%x)",
1044 LOOKUP (attr_str, attr_code), flags);
1045 return 1;
1046 }
1047 if (CHECK_FLAG (flags, BGP_ATTR_FLAG_OPTIONAL)
1048 && !CHECK_FLAG (flags, BGP_ATTR_FLAG_TRANS))
1049 {
1050 zlog (peer->log, LOG_ERR,
1051 "%s optional + transitive attribute "
1052 "must NOT have the partial flag set (%x)",
1053 LOOKUP (attr_str, attr_code), flags);
1054 return 1;
1055 }
1056 }
1057
1058 /* Optional transitive attributes may go through speakers that don't
1059 * reocgnise them and set the Partial bit.
1060 */
1061 if (CHECK_FLAG (flags, BGP_ATTR_FLAG_OPTIONAL)
1062 && CHECK_FLAG (flags, BGP_ATTR_FLAG_TRANS))
1063 SET_FLAG (mask, BGP_ATTR_FLAG_PARTIAL);
1064
Paul Jakma683f2b82012-03-23 14:58:45 +00001065 if ((flags & ~mask)
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001066 == attr_flags_values[attr_code])
1067 return 0;
1068
Paul Jakma835315b2012-01-18 12:28:30 +00001069 bgp_attr_flags_diagnose (args, attr_flags_values[attr_code]);
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001070 return 1;
1071}
1072
paul718e3742002-12-13 20:15:29 +00001073/* Get origin attribute of the update message. */
Paul Jakmab881c702010-11-23 16:35:42 +00001074static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001075bgp_attr_origin (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001076{
Paul Jakma835315b2012-01-18 12:28:30 +00001077 struct peer *const peer = args->peer;
1078 struct attr *const attr = args->attr;
1079 const bgp_size_t length = args->length;
1080
paul718e3742002-12-13 20:15:29 +00001081 /* If any recognized attribute has Attribute Length that conflicts
1082 with the expected length (based on the attribute type code), then
1083 the Error Subcode is set to Attribute Length Error. The Data
1084 field contains the erroneous attribute (type, length and
1085 value). */
1086 if (length != 1)
1087 {
1088 zlog (peer->log, LOG_ERR, "Origin attribute length is not one %d",
1089 length);
Paul Jakma835315b2012-01-18 12:28:30 +00001090 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001091 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001092 args->total);
paul718e3742002-12-13 20:15:29 +00001093 }
1094
1095 /* Fetch origin attribute. */
1096 attr->origin = stream_getc (BGP_INPUT (peer));
1097
1098 /* If the ORIGIN attribute has an undefined value, then the Error
1099 Subcode is set to Invalid Origin Attribute. The Data field
1100 contains the unrecognized attribute (type, length and value). */
1101 if ((attr->origin != BGP_ORIGIN_IGP)
1102 && (attr->origin != BGP_ORIGIN_EGP)
1103 && (attr->origin != BGP_ORIGIN_INCOMPLETE))
1104 {
1105 zlog (peer->log, LOG_ERR, "Origin attribute value is invalid %d",
1106 attr->origin);
Paul Jakma835315b2012-01-18 12:28:30 +00001107 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001108 BGP_NOTIFY_UPDATE_INVAL_ORIGIN,
Paul Jakma835315b2012-01-18 12:28:30 +00001109 args->total);
paul718e3742002-12-13 20:15:29 +00001110 }
1111
1112 /* Set oring attribute flag. */
1113 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGIN);
1114
1115 return 0;
1116}
Paul Jakmaab005292010-11-27 22:48:34 +00001117
1118/* Parse AS path information. This function is wrapper of
1119 aspath_parse. */
1120static int
Paul Jakma835315b2012-01-18 12:28:30 +00001121bgp_attr_aspath (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001122{
Paul Jakma835315b2012-01-18 12:28:30 +00001123 struct attr *const attr = args->attr;
1124 struct peer *const peer = args->peer;
1125 const bgp_size_t length = args->length;
Paul Jakma83a9a222012-01-08 14:15:03 +00001126
Paul Jakmaab005292010-11-27 22:48:34 +00001127 /*
1128 * peer with AS4 => will get 4Byte ASnums
1129 * otherwise, will get 16 Bit
1130 */
1131 attr->aspath = aspath_parse (peer->ibuf, length,
1132 CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV));
1133
1134 /* In case of IBGP, length will be zero. */
1135 if (! attr->aspath)
paul718e3742002-12-13 20:15:29 +00001136 {
Paul Jakmab881c702010-11-23 16:35:42 +00001137 zlog (peer->log, LOG_ERR,
1138 "Malformed AS path from %s, length is %d",
1139 peer->host, length);
Paul Jakma835315b2012-01-18 12:28:30 +00001140 return bgp_attr_malformed (args, BGP_NOTIFY_UPDATE_MAL_AS_PATH, 0);
Paul Jakmaab005292010-11-27 22:48:34 +00001141 }
Chris Hallcddb8112010-08-09 22:31:37 +04001142
Paul Jakmaab005292010-11-27 22:48:34 +00001143 /* Set aspath attribute flag. */
1144 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS_PATH);
paul718e3742002-12-13 20:15:29 +00001145
Paul Jakmab881c702010-11-23 16:35:42 +00001146 return BGP_ATTR_PARSE_PROCEED;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001147}
1148
Paul Jakmab881c702010-11-23 16:35:42 +00001149static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001150bgp_attr_aspath_check (struct peer *const peer, struct attr *const attr)
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001151{
1152 /* These checks were part of bgp_attr_aspath, but with
1153 * as4 we should to check aspath things when
1154 * aspath synthesizing with as4_path has already taken place.
1155 * Otherwise we check ASPATH and use the synthesized thing, and that is
1156 * not right.
1157 * So do the checks later, i.e. here
1158 */
1159 struct bgp *bgp = peer->bgp;
1160 struct aspath *aspath;
1161
Vasilis Tsiligiannisca87e1d2009-07-20 01:28:35 +03001162 /* Confederation sanity check. */
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00001163 if ((peer->sort == BGP_PEER_CONFED && ! aspath_left_confed_check (attr->aspath)) ||
1164 (peer->sort == BGP_PEER_EBGP && aspath_confed_check (attr->aspath)))
Vasilis Tsiligiannisca87e1d2009-07-20 01:28:35 +03001165 {
1166 zlog (peer->log, LOG_ERR, "Malformed AS path from %s", peer->host);
Paul Jakma835315b2012-01-18 12:28:30 +00001167 bgp_notify_send (peer, BGP_NOTIFY_UPDATE_ERR,
1168 BGP_NOTIFY_UPDATE_MAL_AS_PATH);
1169 return BGP_ATTR_PARSE_ERROR;
Vasilis Tsiligiannisca87e1d2009-07-20 01:28:35 +03001170 }
1171
paul718e3742002-12-13 20:15:29 +00001172 /* First AS check for EBGP. */
1173 if (bgp != NULL && bgp_flag_check (bgp, BGP_FLAG_ENFORCE_FIRST_AS))
1174 {
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00001175 if (peer->sort == BGP_PEER_EBGP
paul718e3742002-12-13 20:15:29 +00001176 && ! aspath_firstas_check (attr->aspath, peer->as))
1177 {
1178 zlog (peer->log, LOG_ERR,
Denis Ovsienkoaea339f2009-04-30 17:16:22 +04001179 "%s incorrect first AS (must be %u)", peer->host, peer->as);
Paul Jakma835315b2012-01-18 12:28:30 +00001180 bgp_notify_send (peer, BGP_NOTIFY_UPDATE_ERR,
1181 BGP_NOTIFY_UPDATE_MAL_AS_PATH);
1182 return BGP_ATTR_PARSE_ERROR;
paul718e3742002-12-13 20:15:29 +00001183 }
1184 }
1185
1186 /* local-as prepend */
1187 if (peer->change_local_as &&
1188 ! CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_NO_PREPEND))
1189 {
1190 aspath = aspath_dup (attr->aspath);
1191 aspath = aspath_add_seq (aspath, peer->change_local_as);
Paul Jakmaf6f434b2010-11-23 21:28:03 +00001192 aspath_unintern (&attr->aspath);
paul718e3742002-12-13 20:15:29 +00001193 attr->aspath = aspath_intern (aspath);
1194 }
1195
Paul Jakmab881c702010-11-23 16:35:42 +00001196 return BGP_ATTR_PARSE_PROCEED;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001197}
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001198
Paul Jakmaab005292010-11-27 22:48:34 +00001199/* Parse AS4 path information. This function is another wrapper of
1200 aspath_parse. */
1201static int
Paul Jakma835315b2012-01-18 12:28:30 +00001202bgp_attr_as4_path (struct bgp_attr_parser_args *args, struct aspath **as4_path)
Paul Jakmaab005292010-11-27 22:48:34 +00001203{
Paul Jakma835315b2012-01-18 12:28:30 +00001204 struct peer *const peer = args->peer;
1205 struct attr *const attr = args->attr;
1206 const bgp_size_t length = args->length;
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001207
Paul Jakmaab005292010-11-27 22:48:34 +00001208 *as4_path = aspath_parse (peer->ibuf, length, 1);
1209
Paul Jakmab881c702010-11-23 16:35:42 +00001210 /* In case of IBGP, length will be zero. */
1211 if (!*as4_path)
1212 {
1213 zlog (peer->log, LOG_ERR,
1214 "Malformed AS4 path from %s, length is %d",
1215 peer->host, length);
Paul Jakma835315b2012-01-18 12:28:30 +00001216 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001217 BGP_NOTIFY_UPDATE_MAL_AS_PATH,
Paul Jakma835315b2012-01-18 12:28:30 +00001218 0);
Paul Jakmab881c702010-11-23 16:35:42 +00001219 }
1220
Paul Jakmaab005292010-11-27 22:48:34 +00001221 /* Set aspath attribute flag. */
1222 if (as4_path)
1223 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS4_PATH);
1224
Paul Jakmab881c702010-11-23 16:35:42 +00001225 return BGP_ATTR_PARSE_PROCEED;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001226}
1227
paul718e3742002-12-13 20:15:29 +00001228/* Nexthop attribute. */
Paul Jakmab881c702010-11-23 16:35:42 +00001229static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001230bgp_attr_nexthop (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001231{
Paul Jakma835315b2012-01-18 12:28:30 +00001232 struct peer *const peer = args->peer;
1233 struct attr *const attr = args->attr;
1234 const bgp_size_t length = args->length;
1235
Denis Ovsienkobc3443e2011-09-22 12:48:14 +04001236 in_addr_t nexthop_h, nexthop_n;
paul718e3742002-12-13 20:15:29 +00001237
paul718e3742002-12-13 20:15:29 +00001238 /* Check nexthop attribute length. */
1239 if (length != 4)
1240 {
1241 zlog (peer->log, LOG_ERR, "Nexthop attribute length isn't four [%d]",
1242 length);
1243
Paul Jakma835315b2012-01-18 12:28:30 +00001244 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001245 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001246 args->total);
paul718e3742002-12-13 20:15:29 +00001247 }
1248
Denis Ovsienkobc3443e2011-09-22 12:48:14 +04001249 /* According to section 6.3 of RFC4271, syntactically incorrect NEXT_HOP
1250 attribute must result in a NOTIFICATION message (this is implemented below).
1251 At the same time, semantically incorrect NEXT_HOP is more likely to be just
1252 logged locally (this is implemented somewhere else). The UPDATE message
1253 gets ignored in any of these cases. */
1254 nexthop_n = stream_get_ipv4 (peer->ibuf);
1255 nexthop_h = ntohl (nexthop_n);
Lou Bergerf53585d2016-05-17 07:10:36 -04001256 if ((IPV4_NET0 (nexthop_h) || IPV4_NET127 (nexthop_h) || IPV4_CLASS_DE (nexthop_h))
1257 && !BGP_DEBUG (allow_martians, ALLOW_MARTIANS)) /* loopbacks may be used in testing */
Denis Ovsienkobc3443e2011-09-22 12:48:14 +04001258 {
1259 char buf[INET_ADDRSTRLEN];
David Lamparterbb02b822014-06-04 01:01:00 +02001260 inet_ntop (AF_INET, &nexthop_n, buf, INET_ADDRSTRLEN);
Denis Ovsienkobc3443e2011-09-22 12:48:14 +04001261 zlog (peer->log, LOG_ERR, "Martian nexthop %s", buf);
Paul Jakma835315b2012-01-18 12:28:30 +00001262 return bgp_attr_malformed (args,
Denis Ovsienkobc3443e2011-09-22 12:48:14 +04001263 BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP,
Paul Jakma835315b2012-01-18 12:28:30 +00001264 args->total);
Denis Ovsienkobc3443e2011-09-22 12:48:14 +04001265 }
1266
1267 attr->nexthop.s_addr = nexthop_n;
paul718e3742002-12-13 20:15:29 +00001268 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP);
1269
Paul Jakmab881c702010-11-23 16:35:42 +00001270 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001271}
1272
1273/* MED atrribute. */
Paul Jakmab881c702010-11-23 16:35:42 +00001274static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001275bgp_attr_med (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001276{
Paul Jakma835315b2012-01-18 12:28:30 +00001277 struct peer *const peer = args->peer;
1278 struct attr *const attr = args->attr;
1279 const bgp_size_t length = args->length;
1280
paul718e3742002-12-13 20:15:29 +00001281 /* Length check. */
1282 if (length != 4)
1283 {
1284 zlog (peer->log, LOG_ERR,
1285 "MED attribute length isn't four [%d]", length);
Paul Jakmab881c702010-11-23 16:35:42 +00001286
Paul Jakma835315b2012-01-18 12:28:30 +00001287 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001288 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001289 args->total);
paul718e3742002-12-13 20:15:29 +00001290 }
1291
1292 attr->med = stream_getl (peer->ibuf);
1293
1294 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC);
1295
Paul Jakmab881c702010-11-23 16:35:42 +00001296 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001297}
1298
1299/* Local preference attribute. */
Paul Jakmab881c702010-11-23 16:35:42 +00001300static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001301bgp_attr_local_pref (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001302{
Paul Jakma835315b2012-01-18 12:28:30 +00001303 struct peer *const peer = args->peer;
1304 struct attr *const attr = args->attr;
1305 const bgp_size_t length = args->length;
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001306
Denis Ovsienkoa624cae2011-10-08 13:54:48 +04001307 /* Length check. */
1308 if (length != 4)
1309 {
Paul Jakma835315b2012-01-18 12:28:30 +00001310 zlog (peer->log, LOG_ERR, "LOCAL_PREF attribute length isn't 4 [%u]",
1311 length);
1312 return bgp_attr_malformed (args,
Denis Ovsienkoa624cae2011-10-08 13:54:48 +04001313 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001314 args->total);
Denis Ovsienkoa624cae2011-10-08 13:54:48 +04001315 }
Denis Ovsienko0ea968d2011-09-19 16:30:47 +04001316
paul718e3742002-12-13 20:15:29 +00001317 /* If it is contained in an UPDATE message that is received from an
1318 external peer, then this attribute MUST be ignored by the
1319 receiving speaker. */
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00001320 if (peer->sort == BGP_PEER_EBGP)
paul718e3742002-12-13 20:15:29 +00001321 {
paul9985f832005-02-09 15:51:56 +00001322 stream_forward_getp (peer->ibuf, length);
Paul Jakmab881c702010-11-23 16:35:42 +00001323 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001324 }
1325
Denis Ovsienkoa624cae2011-10-08 13:54:48 +04001326 attr->local_pref = stream_getl (peer->ibuf);
paul718e3742002-12-13 20:15:29 +00001327
1328 /* Set atomic aggregate flag. */
1329 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF);
1330
Paul Jakmab881c702010-11-23 16:35:42 +00001331 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001332}
1333
1334/* Atomic aggregate. */
paul94f2b392005-06-28 12:44:16 +00001335static int
Paul Jakma835315b2012-01-18 12:28:30 +00001336bgp_attr_atomic (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001337{
Paul Jakma835315b2012-01-18 12:28:30 +00001338 struct peer *const peer = args->peer;
1339 struct attr *const attr = args->attr;
1340 const bgp_size_t length = args->length;
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001341
Denis Ovsienko9eba2ad2011-09-20 14:43:50 +04001342 /* Length check. */
paul718e3742002-12-13 20:15:29 +00001343 if (length != 0)
1344 {
Paul Jakma835315b2012-01-18 12:28:30 +00001345 zlog (peer->log, LOG_ERR, "ATOMIC_AGGREGATE attribute length isn't 0 [%u]",
1346 length);
1347 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001348 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001349 args->total);
paul718e3742002-12-13 20:15:29 +00001350 }
1351
1352 /* Set atomic aggregate flag. */
1353 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE);
1354
Paul Jakmab881c702010-11-23 16:35:42 +00001355 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001356}
1357
1358/* Aggregator attribute */
paul94f2b392005-06-28 12:44:16 +00001359static int
Paul Jakma835315b2012-01-18 12:28:30 +00001360bgp_attr_aggregator (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001361{
Paul Jakma835315b2012-01-18 12:28:30 +00001362 struct peer *const peer = args->peer;
1363 struct attr *const attr = args->attr;
1364 const bgp_size_t length = args->length;
1365
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001366 int wantedlen = 6;
Paul Jakmafb982c22007-05-04 20:15:47 +00001367 struct attr_extra *attre = bgp_attr_extra_get (attr);
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001368
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001369 /* peer with AS4 will send 4 Byte AS, peer without will send 2 Byte */
Paul Jakmab881c702010-11-23 16:35:42 +00001370 if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV))
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001371 wantedlen = 8;
1372
1373 if (length != wantedlen)
paul718e3742002-12-13 20:15:29 +00001374 {
Paul Jakma835315b2012-01-18 12:28:30 +00001375 zlog (peer->log, LOG_ERR, "AGGREGATOR attribute length isn't %u [%u]",
1376 wantedlen, length);
1377 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001378 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001379 args->total);
paul718e3742002-12-13 20:15:29 +00001380 }
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001381
1382 if ( CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV ) )
1383 attre->aggregator_as = stream_getl (peer->ibuf);
1384 else
1385 attre->aggregator_as = stream_getw (peer->ibuf);
Paul Jakmafb982c22007-05-04 20:15:47 +00001386 attre->aggregator_addr.s_addr = stream_get_ipv4 (peer->ibuf);
paul718e3742002-12-13 20:15:29 +00001387
1388 /* Set atomic aggregate flag. */
1389 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR);
1390
Paul Jakmab881c702010-11-23 16:35:42 +00001391 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001392}
1393
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001394/* New Aggregator attribute */
Paul Jakmab881c702010-11-23 16:35:42 +00001395static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001396bgp_attr_as4_aggregator (struct bgp_attr_parser_args *args,
1397 as_t *as4_aggregator_as,
1398 struct in_addr *as4_aggregator_addr)
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001399{
Paul Jakma835315b2012-01-18 12:28:30 +00001400 struct peer *const peer = args->peer;
1401 struct attr *const attr = args->attr;
1402 const bgp_size_t length = args->length;
1403
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001404 if (length != 8)
1405 {
Paul Jakma835315b2012-01-18 12:28:30 +00001406 zlog (peer->log, LOG_ERR, "New Aggregator length is not 8 [%d]",
1407 length);
1408 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001409 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001410 0);
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001411 }
Paul Jakma3ecab4c2012-01-17 13:31:33 +00001412
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001413 *as4_aggregator_as = stream_getl (peer->ibuf);
1414 as4_aggregator_addr->s_addr = stream_get_ipv4 (peer->ibuf);
1415
1416 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_AS4_AGGREGATOR);
1417
Paul Jakmab881c702010-11-23 16:35:42 +00001418 return BGP_ATTR_PARSE_PROCEED;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001419}
1420
1421/* Munge Aggregator and New-Aggregator, AS_PATH and NEW_AS_PATH.
1422 */
Paul Jakmab881c702010-11-23 16:35:42 +00001423static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001424bgp_attr_munge_as4_attrs (struct peer *const peer,
1425 struct attr *const attr,
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001426 struct aspath *as4_path, as_t as4_aggregator,
1427 struct in_addr *as4_aggregator_addr)
1428{
1429 int ignore_as4_path = 0;
1430 struct aspath *newpath;
1431 struct attr_extra *attre = attr->extra;
Paul Jakma055086f2014-09-23 15:23:01 +01001432
1433 if (!attr->aspath)
1434 {
1435 /* NULL aspath shouldn't be possible as bgp_attr_parse should have
1436 * checked that all well-known, mandatory attributes were present.
1437 *
1438 * Can only be a problem with peer itself - hard error
1439 */
1440 return BGP_ATTR_PARSE_ERROR;
1441 }
1442
Paul Jakmab881c702010-11-23 16:35:42 +00001443 if (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV))
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001444 {
1445 /* peer can do AS4, so we ignore AS4_PATH and AS4_AGGREGATOR
1446 * if given.
1447 * It is worth a warning though, because the peer really
1448 * should not send them
1449 */
1450 if (BGP_DEBUG(as4, AS4))
1451 {
1452 if (attr->flag & (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH)))
1453 zlog_debug ("[AS4] %s %s AS4_PATH",
1454 peer->host, "AS4 capable peer, yet it sent");
1455
1456 if (attr->flag & (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR)))
1457 zlog_debug ("[AS4] %s %s AS4_AGGREGATOR",
1458 peer->host, "AS4 capable peer, yet it sent");
1459 }
1460
Paul Jakmab881c702010-11-23 16:35:42 +00001461 return BGP_ATTR_PARSE_PROCEED;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001462 }
1463
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001464 /* We have a asn16 peer. First, look for AS4_AGGREGATOR
1465 * because that may override AS4_PATH
1466 */
1467 if (attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AS4_AGGREGATOR) ) )
1468 {
Paul Jakmab881c702010-11-23 16:35:42 +00001469 if (attr->flag & (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR) ) )
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001470 {
Paul Jakma370b64a2007-12-22 16:49:52 +00001471 assert (attre);
1472
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001473 /* received both.
1474 * if the as_number in aggregator is not AS_TRANS,
1475 * then AS4_AGGREGATOR and AS4_PATH shall be ignored
1476 * and the Aggregator shall be taken as
1477 * info on the aggregating node, and the AS_PATH
1478 * shall be taken as the AS_PATH
1479 * otherwise
1480 * the Aggregator shall be ignored and the
1481 * AS4_AGGREGATOR shall be taken as the
1482 * Aggregating node and the AS_PATH is to be
1483 * constructed "as in all other cases"
1484 */
Paul Jakmab881c702010-11-23 16:35:42 +00001485 if (attre->aggregator_as != BGP_AS_TRANS)
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001486 {
1487 /* ignore */
1488 if ( BGP_DEBUG(as4, AS4))
1489 zlog_debug ("[AS4] %s BGP not AS4 capable peer"
1490 " send AGGREGATOR != AS_TRANS and"
1491 " AS4_AGGREGATOR, so ignore"
1492 " AS4_AGGREGATOR and AS4_PATH", peer->host);
1493 ignore_as4_path = 1;
1494 }
1495 else
1496 {
1497 /* "New_aggregator shall be taken as aggregator" */
1498 attre->aggregator_as = as4_aggregator;
1499 attre->aggregator_addr.s_addr = as4_aggregator_addr->s_addr;
1500 }
1501 }
1502 else
1503 {
1504 /* We received a AS4_AGGREGATOR but no AGGREGATOR.
1505 * That is bogus - but reading the conditions
1506 * we have to handle AS4_AGGREGATOR as if it were
1507 * AGGREGATOR in that case
1508 */
1509 if ( BGP_DEBUG(as4, AS4))
1510 zlog_debug ("[AS4] %s BGP not AS4 capable peer send"
1511 " AS4_AGGREGATOR but no AGGREGATOR, will take"
1512 " it as if AGGREGATOR with AS_TRANS had been there", peer->host);
Paul Jakma370b64a2007-12-22 16:49:52 +00001513 (attre = bgp_attr_extra_get (attr))->aggregator_as = as4_aggregator;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001514 /* sweep it under the carpet and simulate a "good" AGGREGATOR */
1515 attr->flag |= (ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR));
1516 }
1517 }
1518
1519 /* need to reconcile NEW_AS_PATH and AS_PATH */
Paul Jakmab881c702010-11-23 16:35:42 +00001520 if (!ignore_as4_path && (attr->flag & (ATTR_FLAG_BIT( BGP_ATTR_AS4_PATH))))
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001521 {
Paul Jakma055086f2014-09-23 15:23:01 +01001522 newpath = aspath_reconcile_as4 (attr->aspath, as4_path);
1523 aspath_unintern (&attr->aspath);
1524 attr->aspath = aspath_intern (newpath);
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001525 }
Paul Jakmab881c702010-11-23 16:35:42 +00001526 return BGP_ATTR_PARSE_PROCEED;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00001527}
1528
paul718e3742002-12-13 20:15:29 +00001529/* Community attribute. */
Paul Jakmab881c702010-11-23 16:35:42 +00001530static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001531bgp_attr_community (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001532{
Paul Jakma835315b2012-01-18 12:28:30 +00001533 struct peer *const peer = args->peer;
1534 struct attr *const attr = args->attr;
1535 const bgp_size_t length = args->length;
Paul Jakmab881c702010-11-23 16:35:42 +00001536
paul718e3742002-12-13 20:15:29 +00001537 if (length == 0)
Paul Jakmab2ceea12007-09-07 14:24:55 +00001538 {
1539 attr->community = NULL;
Paul Jakmab881c702010-11-23 16:35:42 +00001540 return BGP_ATTR_PARSE_PROCEED;
Paul Jakmab2ceea12007-09-07 14:24:55 +00001541 }
Paul Jakma0c466382010-12-05 17:17:26 +00001542
1543 attr->community =
1544 community_parse ((u_int32_t *)stream_pnt (peer->ibuf), length);
1545
1546 /* XXX: fix community_parse to use stream API and remove this */
1547 stream_forward_getp (peer->ibuf, length);
paul718e3742002-12-13 20:15:29 +00001548
Paul Jakma0c466382010-12-05 17:17:26 +00001549 if (!attr->community)
Paul Jakma835315b2012-01-18 12:28:30 +00001550 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001551 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001552 args->total);
Paul Jakma0c466382010-12-05 17:17:26 +00001553
paul718e3742002-12-13 20:15:29 +00001554 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES);
1555
Paul Jakmab881c702010-11-23 16:35:42 +00001556 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001557}
1558
1559/* Originator ID attribute. */
Paul Jakmab881c702010-11-23 16:35:42 +00001560static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001561bgp_attr_originator_id (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001562{
Paul Jakma835315b2012-01-18 12:28:30 +00001563 struct peer *const peer = args->peer;
1564 struct attr *const attr = args->attr;
1565 const bgp_size_t length = args->length;
1566
Denis Ovsienkod595b562011-09-30 15:08:54 +04001567 /* Length check. */
paul718e3742002-12-13 20:15:29 +00001568 if (length != 4)
1569 {
1570 zlog (peer->log, LOG_ERR, "Bad originator ID length %d", length);
1571
Paul Jakma835315b2012-01-18 12:28:30 +00001572 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001573 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
Paul Jakma835315b2012-01-18 12:28:30 +00001574 args->total);
paul718e3742002-12-13 20:15:29 +00001575 }
1576
Paul Jakmafb982c22007-05-04 20:15:47 +00001577 (bgp_attr_extra_get (attr))->originator_id.s_addr
1578 = stream_get_ipv4 (peer->ibuf);
paul718e3742002-12-13 20:15:29 +00001579
1580 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_ORIGINATOR_ID);
1581
Paul Jakmab881c702010-11-23 16:35:42 +00001582 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001583}
1584
1585/* Cluster list attribute. */
Paul Jakmab881c702010-11-23 16:35:42 +00001586static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001587bgp_attr_cluster_list (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001588{
Paul Jakma835315b2012-01-18 12:28:30 +00001589 struct peer *const peer = args->peer;
1590 struct attr *const attr = args->attr;
1591 const bgp_size_t length = args->length;
1592
paul718e3742002-12-13 20:15:29 +00001593 /* Check length. */
1594 if (length % 4)
1595 {
1596 zlog (peer->log, LOG_ERR, "Bad cluster list length %d", length);
1597
Paul Jakma835315b2012-01-18 12:28:30 +00001598 return bgp_attr_malformed (args, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR,
1599 args->total);
paul718e3742002-12-13 20:15:29 +00001600 }
1601
Paul Jakmafb982c22007-05-04 20:15:47 +00001602 (bgp_attr_extra_get (attr))->cluster
1603 = cluster_parse ((struct in_addr *)stream_pnt (peer->ibuf), length);
Paul Jakmab881c702010-11-23 16:35:42 +00001604
1605 /* XXX: Fix cluster_parse to use stream API and then remove this */
1606 stream_forward_getp (peer->ibuf, length);
paul718e3742002-12-13 20:15:29 +00001607
1608 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_CLUSTER_LIST);
1609
Paul Jakmab881c702010-11-23 16:35:42 +00001610 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001611}
1612
1613/* Multiprotocol reachability information parse. */
Paul Jakma03292802008-06-07 20:37:10 +00001614int
Paul Jakma835315b2012-01-18 12:28:30 +00001615bgp_mp_reach_parse (struct bgp_attr_parser_args *args,
1616 struct bgp_nlri *mp_update)
paul718e3742002-12-13 20:15:29 +00001617{
Michael Lambert4c9641b2010-07-22 13:20:55 -04001618 afi_t afi;
1619 safi_t safi;
paul718e3742002-12-13 20:15:29 +00001620 bgp_size_t nlri_len;
Paul Jakma6e4ab122007-04-10 19:36:48 +00001621 size_t start;
paul718e3742002-12-13 20:15:29 +00001622 struct stream *s;
Paul Jakma835315b2012-01-18 12:28:30 +00001623 struct peer *const peer = args->peer;
1624 struct attr *const attr = args->attr;
1625 const bgp_size_t length = args->length;
Paul Jakmafb982c22007-05-04 20:15:47 +00001626 struct attr_extra *attre = bgp_attr_extra_get(attr);
Paul Jakma835315b2012-01-18 12:28:30 +00001627
paul718e3742002-12-13 20:15:29 +00001628 /* Set end of packet. */
Paul Jakma6e4ab122007-04-10 19:36:48 +00001629 s = BGP_INPUT(peer);
1630 start = stream_get_getp(s);
1631
1632 /* safe to read statically sized header? */
1633#define BGP_MP_REACH_MIN_SIZE 5
Paul Jakma03292802008-06-07 20:37:10 +00001634#define LEN_LEFT (length - (stream_get_getp(s) - start))
Paul Jakma6e4ab122007-04-10 19:36:48 +00001635 if ((length > STREAM_READABLE(s)) || (length < BGP_MP_REACH_MIN_SIZE))
Paul Jakma03292802008-06-07 20:37:10 +00001636 {
1637 zlog_info ("%s: %s sent invalid length, %lu",
1638 __func__, peer->host, (unsigned long)length);
David Lamparterf57000c2014-06-04 01:01:10 +02001639 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS;
Paul Jakma03292802008-06-07 20:37:10 +00001640 }
Paul Jakma6e4ab122007-04-10 19:36:48 +00001641
paul718e3742002-12-13 20:15:29 +00001642 /* Load AFI, SAFI. */
1643 afi = stream_getw (s);
1644 safi = stream_getc (s);
1645
1646 /* Get nexthop length. */
Paul Jakmafb982c22007-05-04 20:15:47 +00001647 attre->mp_nexthop_len = stream_getc (s);
Paul Jakma6e4ab122007-04-10 19:36:48 +00001648
Paul Jakma03292802008-06-07 20:37:10 +00001649 if (LEN_LEFT < attre->mp_nexthop_len)
1650 {
1651 zlog_info ("%s: %s, MP nexthop length, %u, goes past end of attribute",
1652 __func__, peer->host, attre->mp_nexthop_len);
David Lamparterf57000c2014-06-04 01:01:10 +02001653 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS;
Paul Jakma03292802008-06-07 20:37:10 +00001654 }
Paul Jakma6e4ab122007-04-10 19:36:48 +00001655
paul718e3742002-12-13 20:15:29 +00001656 /* Nexthop length check. */
Paul Jakmafb982c22007-05-04 20:15:47 +00001657 switch (attre->mp_nexthop_len)
paul718e3742002-12-13 20:15:29 +00001658 {
1659 case 4:
Paul Jakmafb982c22007-05-04 20:15:47 +00001660 stream_get (&attre->mp_nexthop_global_in, s, 4);
Michael Lambert66bed4f2009-07-28 11:26:14 -04001661 /* Probably needed for RFC 2283 */
1662 if (attr->nexthop.s_addr == 0)
1663 memcpy(&attr->nexthop.s_addr, &attre->mp_nexthop_global_in, 4);
paul718e3742002-12-13 20:15:29 +00001664 break;
1665 case 12:
Stephen Hemminger9206f9e2011-12-18 19:43:40 +04001666 stream_getl (s); /* RD high */
1667 stream_getl (s); /* RD low */
1668 stream_get (&attre->mp_nexthop_global_in, s, 4);
paul718e3742002-12-13 20:15:29 +00001669 break;
Lou Berger9da04bc2016-01-12 13:41:55 -05001670 case 24:
1671 {
1672 u_int32_t rd_high __attribute__((unused));
1673 u_int32_t rd_low __attribute__((unused));
1674
1675 rd_high = stream_getl (s);
1676 rd_low = stream_getl (s);
1677 }
1678 /* fall through */
paul718e3742002-12-13 20:15:29 +00001679 case 16:
Paul Jakmafb982c22007-05-04 20:15:47 +00001680 stream_get (&attre->mp_nexthop_global, s, 16);
paul718e3742002-12-13 20:15:29 +00001681 break;
1682 case 32:
Lou Berger9da04bc2016-01-12 13:41:55 -05001683 case 48:
1684 if (attre->mp_nexthop_len == 48) {
1685 u_int32_t rd_high __attribute__((unused));
1686 u_int32_t rd_low __attribute__((unused));
1687
1688 rd_high = stream_getl (s);
1689 rd_low = stream_getl (s);
1690 }
Paul Jakmafb982c22007-05-04 20:15:47 +00001691 stream_get (&attre->mp_nexthop_global, s, 16);
Lou Berger9da04bc2016-01-12 13:41:55 -05001692
1693 if (attre->mp_nexthop_len == 48) {
1694 u_int32_t rd_high __attribute__((unused));
1695 u_int32_t rd_low __attribute__((unused));
1696
1697 rd_high = stream_getl (s);
1698 rd_low = stream_getl (s);
1699 }
Paul Jakmafb982c22007-05-04 20:15:47 +00001700 stream_get (&attre->mp_nexthop_local, s, 16);
1701 if (! IN6_IS_ADDR_LINKLOCAL (&attre->mp_nexthop_local))
paul718e3742002-12-13 20:15:29 +00001702 {
1703 char buf1[INET6_ADDRSTRLEN];
1704 char buf2[INET6_ADDRSTRLEN];
1705
1706 if (BGP_DEBUG (update, UPDATE_IN))
ajs557865c2004-12-08 19:59:11 +00001707 zlog_debug ("%s got two nexthop %s %s but second one is not a link-local nexthop", peer->host,
Paul Jakmafb982c22007-05-04 20:15:47 +00001708 inet_ntop (AF_INET6, &attre->mp_nexthop_global,
paul718e3742002-12-13 20:15:29 +00001709 buf1, INET6_ADDRSTRLEN),
Paul Jakmafb982c22007-05-04 20:15:47 +00001710 inet_ntop (AF_INET6, &attre->mp_nexthop_local,
paul718e3742002-12-13 20:15:29 +00001711 buf2, INET6_ADDRSTRLEN));
1712
Paul Jakmafb982c22007-05-04 20:15:47 +00001713 attre->mp_nexthop_len = 16;
paul718e3742002-12-13 20:15:29 +00001714 }
1715 break;
paul718e3742002-12-13 20:15:29 +00001716 default:
Paul Jakma03292802008-06-07 20:37:10 +00001717 zlog_info ("%s: (%s) Wrong multiprotocol next hop length: %d",
1718 __func__, peer->host, attre->mp_nexthop_len);
David Lamparterf57000c2014-06-04 01:01:10 +02001719 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS;
paul718e3742002-12-13 20:15:29 +00001720 }
1721
Paul Jakma03292802008-06-07 20:37:10 +00001722 if (!LEN_LEFT)
1723 {
1724 zlog_info ("%s: (%s) Failed to read SNPA and NLRI(s)",
1725 __func__, peer->host);
David Lamparterf57000c2014-06-04 01:01:10 +02001726 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS;
Paul Jakma03292802008-06-07 20:37:10 +00001727 }
paul718e3742002-12-13 20:15:29 +00001728
Paul Jakma6e4ab122007-04-10 19:36:48 +00001729 {
1730 u_char val;
1731 if ((val = stream_getc (s)))
1732 zlog_warn ("%s sent non-zero value, %u, for defunct SNPA-length field",
1733 peer->host, val);
1734 }
1735
1736 /* must have nrli_len, what is left of the attribute */
Paul Jakma03292802008-06-07 20:37:10 +00001737 nlri_len = LEN_LEFT;
Paul Jakma6e4ab122007-04-10 19:36:48 +00001738 if ((!nlri_len) || (nlri_len > STREAM_READABLE(s)))
Paul Jakma03292802008-06-07 20:37:10 +00001739 {
1740 zlog_info ("%s: (%s) Failed to read NLRI",
1741 __func__, peer->host);
David Lamparterf57000c2014-06-04 01:01:10 +02001742 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS;
Paul Jakma03292802008-06-07 20:37:10 +00001743 }
Paul Jakma18ab08b2016-01-27 16:37:33 +00001744
paul718e3742002-12-13 20:15:29 +00001745 mp_update->afi = afi;
1746 mp_update->safi = safi;
1747 mp_update->nlri = stream_pnt (s);
1748 mp_update->length = nlri_len;
1749
paul9985f832005-02-09 15:51:56 +00001750 stream_forward_getp (s, nlri_len);
paul718e3742002-12-13 20:15:29 +00001751
David Lamparterdaefeb82014-12-08 17:42:12 +01001752 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_MP_REACH_NLRI);
1753
Paul Jakmab881c702010-11-23 16:35:42 +00001754 return BGP_ATTR_PARSE_PROCEED;
Paul Jakma03292802008-06-07 20:37:10 +00001755#undef LEN_LEFT
paul718e3742002-12-13 20:15:29 +00001756}
1757
1758/* Multiprotocol unreachable parse */
Paul Jakma03292802008-06-07 20:37:10 +00001759int
Paul Jakma835315b2012-01-18 12:28:30 +00001760bgp_mp_unreach_parse (struct bgp_attr_parser_args *args,
paul718e3742002-12-13 20:15:29 +00001761 struct bgp_nlri *mp_withdraw)
1762{
1763 struct stream *s;
Michael Lambert4c9641b2010-07-22 13:20:55 -04001764 afi_t afi;
1765 safi_t safi;
paul718e3742002-12-13 20:15:29 +00001766 u_int16_t withdraw_len;
Paul Jakma835315b2012-01-18 12:28:30 +00001767 struct peer *const peer = args->peer;
David Lamparterdaefeb82014-12-08 17:42:12 +01001768 struct attr *const attr = args->attr;
Paul Jakma835315b2012-01-18 12:28:30 +00001769 const bgp_size_t length = args->length;
paul718e3742002-12-13 20:15:29 +00001770
1771 s = peer->ibuf;
Paul Jakma6e4ab122007-04-10 19:36:48 +00001772
1773#define BGP_MP_UNREACH_MIN_SIZE 3
1774 if ((length > STREAM_READABLE(s)) || (length < BGP_MP_UNREACH_MIN_SIZE))
David Lamparterf57000c2014-06-04 01:01:10 +02001775 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS;
Paul Jakma6e4ab122007-04-10 19:36:48 +00001776
paul718e3742002-12-13 20:15:29 +00001777 afi = stream_getw (s);
1778 safi = stream_getc (s);
Paul Jakma6e4ab122007-04-10 19:36:48 +00001779
1780 withdraw_len = length - BGP_MP_UNREACH_MIN_SIZE;
paul718e3742002-12-13 20:15:29 +00001781
paul718e3742002-12-13 20:15:29 +00001782 mp_withdraw->afi = afi;
1783 mp_withdraw->safi = safi;
1784 mp_withdraw->nlri = stream_pnt (s);
1785 mp_withdraw->length = withdraw_len;
1786
paul9985f832005-02-09 15:51:56 +00001787 stream_forward_getp (s, withdraw_len);
paul718e3742002-12-13 20:15:29 +00001788
David Lamparterdaefeb82014-12-08 17:42:12 +01001789 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_MP_UNREACH_NLRI);
1790
Paul Jakmab881c702010-11-23 16:35:42 +00001791 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001792}
1793
1794/* Extended Community attribute. */
Paul Jakmab881c702010-11-23 16:35:42 +00001795static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001796bgp_attr_ext_communities (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001797{
Paul Jakma835315b2012-01-18 12:28:30 +00001798 struct peer *const peer = args->peer;
1799 struct attr *const attr = args->attr;
1800 const bgp_size_t length = args->length;
Paul Jakmab881c702010-11-23 16:35:42 +00001801
paul718e3742002-12-13 20:15:29 +00001802 if (length == 0)
Paul Jakmafb982c22007-05-04 20:15:47 +00001803 {
1804 if (attr->extra)
1805 attr->extra->ecommunity = NULL;
Paul Jakma0c466382010-12-05 17:17:26 +00001806 /* Empty extcomm doesn't seem to be invalid per se */
Paul Jakmab881c702010-11-23 16:35:42 +00001807 return BGP_ATTR_PARSE_PROCEED;
Paul Jakmafb982c22007-05-04 20:15:47 +00001808 }
Paul Jakma0c466382010-12-05 17:17:26 +00001809
1810 (bgp_attr_extra_get (attr))->ecommunity =
1811 ecommunity_parse ((u_int8_t *)stream_pnt (peer->ibuf), length);
1812 /* XXX: fix ecommunity_parse to use stream API */
1813 stream_forward_getp (peer->ibuf, length);
1814
1815 if (!attr->extra->ecommunity)
Paul Jakma835315b2012-01-18 12:28:30 +00001816 return bgp_attr_malformed (args,
1817 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR,
1818 args->total);
Paul Jakma0c466382010-12-05 17:17:26 +00001819
paul718e3742002-12-13 20:15:29 +00001820 attr->flag |= ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES);
1821
Paul Jakmab881c702010-11-23 16:35:42 +00001822 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001823}
1824
Lou Bergerc3741782016-01-12 13:42:01 -05001825/* Parse Tunnel Encap attribute in an UPDATE */
1826static int
1827bgp_attr_encap(
1828 uint8_t type,
1829 struct peer *peer, /* IN */
1830 bgp_size_t length, /* IN: attr's length field */
1831 struct attr *attr, /* IN: caller already allocated */
1832 u_char flag, /* IN: attr's flags field */
1833 u_char *startp)
1834{
1835 bgp_size_t total;
1836 struct attr_extra *attre = NULL;
1837 struct bgp_attr_encap_subtlv *stlv_last = NULL;
1838 uint16_t tunneltype;
1839
1840 total = length + (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN) ? 4 : 3);
1841
1842 if (!CHECK_FLAG(flag, BGP_ATTR_FLAG_TRANS)
1843 || !CHECK_FLAG(flag, BGP_ATTR_FLAG_OPTIONAL))
1844 {
1845 zlog (peer->log, LOG_ERR,
1846 "Tunnel Encap attribute flag isn't optional and transitive %d", flag);
1847 bgp_notify_send_with_data (peer,
1848 BGP_NOTIFY_UPDATE_ERR,
1849 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
1850 startp, total);
1851 return -1;
1852 }
1853
1854 if (BGP_ATTR_ENCAP == type) {
1855 /* read outer TLV type and length */
1856 uint16_t tlv_length;
1857
1858 if (length < 4) {
1859 zlog (peer->log, LOG_ERR,
1860 "Tunnel Encap attribute not long enough to contain outer T,L");
1861 bgp_notify_send_with_data(peer,
1862 BGP_NOTIFY_UPDATE_ERR,
1863 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR,
1864 startp, total);
1865 return -1;
1866 }
1867 tunneltype = stream_getw (BGP_INPUT (peer));
1868 tlv_length = stream_getw (BGP_INPUT (peer));
1869 length -= 4;
1870
1871 if (tlv_length != length) {
1872 zlog (peer->log, LOG_ERR, "%s: tlv_length(%d) != length(%d)",
1873 __func__, tlv_length, length);
1874 }
1875 }
1876
1877 while (length >= 4) {
Donald Sharp985c3552016-03-10 20:16:47 -05001878 uint16_t subtype = 0;
1879 uint16_t sublength = 0;
Lou Bergerc3741782016-01-12 13:42:01 -05001880 struct bgp_attr_encap_subtlv *tlv;
1881
Lou Berger298cc2f2016-01-12 13:42:02 -05001882 if (BGP_ATTR_ENCAP == type) {
1883 subtype = stream_getc (BGP_INPUT (peer));
1884 sublength = stream_getc (BGP_INPUT (peer));
1885 length -= 2;
1886 }
Lou Bergerc3741782016-01-12 13:42:01 -05001887
1888 if (sublength > length) {
1889 zlog (peer->log, LOG_ERR,
1890 "Tunnel Encap attribute sub-tlv length %d exceeds remaining length %d",
1891 sublength, length);
1892 bgp_notify_send_with_data (peer,
1893 BGP_NOTIFY_UPDATE_ERR,
1894 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR,
1895 startp, total);
1896 return -1;
1897 }
1898
1899 /* alloc and copy sub-tlv */
1900 /* TBD make sure these are freed when attributes are released */
1901 tlv = XCALLOC (MTYPE_ENCAP_TLV, sizeof(struct bgp_attr_encap_subtlv)-1+sublength);
1902 tlv->type = subtype;
1903 tlv->length = sublength;
1904 stream_get(tlv->value, peer->ibuf, sublength);
1905 length -= sublength;
1906
1907 /* attach tlv to encap chain */
1908 if (!attre) {
1909 attre = bgp_attr_extra_get(attr);
1910 if (BGP_ATTR_ENCAP == type) {
1911 for (stlv_last = attre->encap_subtlvs; stlv_last && stlv_last->next;
1912 stlv_last = stlv_last->next);
1913 if (stlv_last) {
1914 stlv_last->next = tlv;
1915 } else {
1916 attre->encap_subtlvs = tlv;
1917 }
1918 }
1919 } else {
1920 stlv_last->next = tlv;
1921 }
1922 stlv_last = tlv;
1923 }
1924
1925 if (attre && (BGP_ATTR_ENCAP == type)) {
1926 attre->encap_tunneltype = tunneltype;
1927 }
1928
1929 if (length) {
1930 /* spurious leftover data */
1931 zlog (peer->log, LOG_ERR,
1932 "Tunnel Encap attribute length is bad: %d leftover octets", length);
1933 bgp_notify_send_with_data (peer,
1934 BGP_NOTIFY_UPDATE_ERR,
1935 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR,
1936 startp, total);
1937 return -1;
1938 }
1939
1940 return 0;
1941}
1942
paul718e3742002-12-13 20:15:29 +00001943/* BGP unknown attribute treatment. */
Paul Jakmab881c702010-11-23 16:35:42 +00001944static bgp_attr_parse_ret_t
Paul Jakma835315b2012-01-18 12:28:30 +00001945bgp_attr_unknown (struct bgp_attr_parser_args *args)
paul718e3742002-12-13 20:15:29 +00001946{
Paul Jakma8794e8d2012-02-13 13:53:07 +00001947 bgp_size_t total = args->total;
paul718e3742002-12-13 20:15:29 +00001948 struct transit *transit;
Paul Jakmafb982c22007-05-04 20:15:47 +00001949 struct attr_extra *attre;
Paul Jakma835315b2012-01-18 12:28:30 +00001950 struct peer *const peer = args->peer;
1951 struct attr *const attr = args->attr;
1952 u_char *const startp = args->startp;
1953 const u_char type = args->type;
1954 const u_char flag = args->flags;
1955 const bgp_size_t length = args->length;
1956
paul718e3742002-12-13 20:15:29 +00001957
hassof4184462005-02-01 20:13:16 +00001958 if (BGP_DEBUG (normal, NORMAL))
1959 zlog_debug ("%s Unknown attribute is received (type %d, length %d)",
1960 peer->host, type, length);
1961
paul718e3742002-12-13 20:15:29 +00001962 if (BGP_DEBUG (events, EVENTS))
ajs557865c2004-12-08 19:59:11 +00001963 zlog (peer->log, LOG_DEBUG,
paul718e3742002-12-13 20:15:29 +00001964 "Unknown attribute type %d length %d is received", type, length);
1965
1966 /* Forward read pointer of input stream. */
paul9985f832005-02-09 15:51:56 +00001967 stream_forward_getp (peer->ibuf, length);
paul718e3742002-12-13 20:15:29 +00001968
paul718e3742002-12-13 20:15:29 +00001969 /* If any of the mandatory well-known attributes are not recognized,
1970 then the Error Subcode is set to Unrecognized Well-known
1971 Attribute. The Data field contains the unrecognized attribute
1972 (type, length and value). */
Paul Jakmab881c702010-11-23 16:35:42 +00001973 if (!CHECK_FLAG (flag, BGP_ATTR_FLAG_OPTIONAL))
paul718e3742002-12-13 20:15:29 +00001974 {
Paul Jakma835315b2012-01-18 12:28:30 +00001975 return bgp_attr_malformed (args,
Paul Jakmab881c702010-11-23 16:35:42 +00001976 BGP_NOTIFY_UPDATE_UNREC_ATTR,
Paul Jakma835315b2012-01-18 12:28:30 +00001977 args->total);
paul718e3742002-12-13 20:15:29 +00001978 }
1979
1980 /* Unrecognized non-transitive optional attributes must be quietly
1981 ignored and not passed along to other BGP peers. */
1982 if (! CHECK_FLAG (flag, BGP_ATTR_FLAG_TRANS))
Paul Jakmab881c702010-11-23 16:35:42 +00001983 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00001984
1985 /* If a path with recognized transitive optional attribute is
1986 accepted and passed along to other BGP peers and the Partial bit
1987 in the Attribute Flags octet is set to 1 by some previous AS, it
1988 is not set back to 0 by the current AS. */
1989 SET_FLAG (*startp, BGP_ATTR_FLAG_PARTIAL);
1990
1991 /* Store transitive attribute to the end of attr->transit. */
Paul Jakmafb982c22007-05-04 20:15:47 +00001992 if (! ((attre = bgp_attr_extra_get(attr))->transit) )
Stephen Hemminger393deb92008-08-18 14:13:29 -07001993 attre->transit = XCALLOC (MTYPE_TRANSIT, sizeof (struct transit));
paul718e3742002-12-13 20:15:29 +00001994
Paul Jakmafb982c22007-05-04 20:15:47 +00001995 transit = attre->transit;
paul718e3742002-12-13 20:15:29 +00001996
1997 if (transit->val)
1998 transit->val = XREALLOC (MTYPE_TRANSIT_VAL, transit->val,
1999 transit->length + total);
2000 else
2001 transit->val = XMALLOC (MTYPE_TRANSIT_VAL, total);
2002
2003 memcpy (transit->val + transit->length, startp, total);
2004 transit->length += total;
2005
Paul Jakmab881c702010-11-23 16:35:42 +00002006 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00002007}
2008
Paul Jakma055086f2014-09-23 15:23:01 +01002009/* Well-known attribute check. */
2010static int
2011bgp_attr_check (struct peer *peer, struct attr *attr)
2012{
2013 u_char type = 0;
2014
Paul Jakmaaed1b552014-10-21 16:59:01 +01002015 /* BGP Graceful-Restart End-of-RIB for IPv4 unicast is signaled as an
2016 * empty UPDATE. */
2017 if (CHECK_FLAG (peer->cap, PEER_CAP_RESTART_RCV) && !attr->flag)
2018 return BGP_ATTR_PARSE_PROCEED;
2019
2020 /* "An UPDATE message that contains the MP_UNREACH_NLRI is not required
2021 to carry any other path attributes.", though if MP_REACH_NLRI or NLRI
2022 are present, it should. Check for any other attribute being present
2023 instead.
2024 */
2025 if (attr->flag == ATTR_FLAG_BIT (BGP_ATTR_MP_UNREACH_NLRI))
2026 return BGP_ATTR_PARSE_PROCEED;
2027
Paul Jakma055086f2014-09-23 15:23:01 +01002028 if (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_ORIGIN)))
2029 type = BGP_ATTR_ORIGIN;
2030
2031 if (! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH)))
2032 type = BGP_ATTR_AS_PATH;
Paul Jakmaaed1b552014-10-21 16:59:01 +01002033
2034 /* RFC 2858 makes Next-Hop optional/ignored, if MP_REACH_NLRI is present and
2035 * NLRI is empty. We can't easily check NLRI empty here though.
2036 */
Paul Jakma1a211cb2014-11-01 17:21:47 +00002037 if (!CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP))
2038 && !CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_MP_REACH_NLRI)))
Paul Jakma055086f2014-09-23 15:23:01 +01002039 type = BGP_ATTR_NEXT_HOP;
Paul Jakmaaed1b552014-10-21 16:59:01 +01002040
Paul Jakma055086f2014-09-23 15:23:01 +01002041 if (peer->sort == BGP_PEER_IBGP
2042 && ! CHECK_FLAG (attr->flag, ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF)))
2043 type = BGP_ATTR_LOCAL_PREF;
2044
2045 if (type)
2046 {
2047 zlog (peer->log, LOG_WARNING,
Paul Jakmaaed1b552014-10-21 16:59:01 +01002048 "%s Missing well-known attribute %d / %s",
2049 peer->host, type, LOOKUP (attr_str, type));
Paul Jakma055086f2014-09-23 15:23:01 +01002050 bgp_notify_send_with_data (peer,
2051 BGP_NOTIFY_UPDATE_ERR,
2052 BGP_NOTIFY_UPDATE_MISS_ATTR,
2053 &type, 1);
2054 return BGP_ATTR_PARSE_ERROR;
2055 }
2056 return BGP_ATTR_PARSE_PROCEED;
2057}
2058
paul718e3742002-12-13 20:15:29 +00002059/* Read attribute of update packet. This function is called from
Andrew Certain8b366b92012-11-07 23:50:08 +00002060 bgp_update_receive() in bgp_packet.c. */
Paul Jakmab881c702010-11-23 16:35:42 +00002061bgp_attr_parse_ret_t
paul718e3742002-12-13 20:15:29 +00002062bgp_attr_parse (struct peer *peer, struct attr *attr, bgp_size_t size,
2063 struct bgp_nlri *mp_update, struct bgp_nlri *mp_withdraw)
2064{
2065 int ret;
Paul Jakmab881c702010-11-23 16:35:42 +00002066 u_char flag = 0;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002067 u_char type = 0;
paul718e3742002-12-13 20:15:29 +00002068 bgp_size_t length;
2069 u_char *startp, *endp;
2070 u_char *attr_endp;
2071 u_char seen[BGP_ATTR_BITMAP_SIZE];
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002072 /* we need the as4_path only until we have synthesized the as_path with it */
2073 /* same goes for as4_aggregator */
2074 struct aspath *as4_path = NULL;
2075 as_t as4_aggregator = 0;
David Lamparter5181a022015-09-15 03:00:09 -07002076 struct in_addr as4_aggregator_addr = { .s_addr = 0 };
paul718e3742002-12-13 20:15:29 +00002077
2078 /* Initialize bitmap. */
2079 memset (seen, 0, BGP_ATTR_BITMAP_SIZE);
2080
2081 /* End pointer of BGP attribute. */
2082 endp = BGP_INPUT_PNT (peer) + size;
Paul Jakmab881c702010-11-23 16:35:42 +00002083
paul718e3742002-12-13 20:15:29 +00002084 /* Get attributes to the end of attribute length. */
2085 while (BGP_INPUT_PNT (peer) < endp)
2086 {
2087 /* Check remaining length check.*/
2088 if (endp - BGP_INPUT_PNT (peer) < BGP_ATTR_MIN_LEN)
2089 {
gdtc29fdba2004-12-09 14:46:46 +00002090 /* XXX warning: long int format, int arg (arg 5) */
paul718e3742002-12-13 20:15:29 +00002091 zlog (peer->log, LOG_WARNING,
heasleyd68ab102011-07-12 20:09:18 +04002092 "%s: error BGP attribute length %lu is smaller than min len",
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002093 peer->host,
2094 (unsigned long) (endp - STREAM_PNT (BGP_INPUT (peer))));
paul718e3742002-12-13 20:15:29 +00002095
2096 bgp_notify_send (peer,
2097 BGP_NOTIFY_UPDATE_ERR,
2098 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
Paul Jakmab881c702010-11-23 16:35:42 +00002099 return BGP_ATTR_PARSE_ERROR;
paul718e3742002-12-13 20:15:29 +00002100 }
2101
2102 /* Fetch attribute flag and type. */
2103 startp = BGP_INPUT_PNT (peer);
Denis Ovsienko2d42e682011-09-27 15:35:39 +04002104 /* "The lower-order four bits of the Attribute Flags octet are
2105 unused. They MUST be zero when sent and MUST be ignored when
2106 received." */
2107 flag = 0xF0 & stream_getc (BGP_INPUT (peer));
paul718e3742002-12-13 20:15:29 +00002108 type = stream_getc (BGP_INPUT (peer));
2109
Paul Jakma370b64a2007-12-22 16:49:52 +00002110 /* Check whether Extended-Length applies and is in bounds */
2111 if (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN)
2112 && ((endp - startp) < (BGP_ATTR_MIN_LEN + 1)))
2113 {
2114 zlog (peer->log, LOG_WARNING,
heasleyd68ab102011-07-12 20:09:18 +04002115 "%s: Extended length set, but just %lu bytes of attr header",
Paul Jakma370b64a2007-12-22 16:49:52 +00002116 peer->host,
2117 (unsigned long) (endp - STREAM_PNT (BGP_INPUT (peer))));
2118
2119 bgp_notify_send (peer,
2120 BGP_NOTIFY_UPDATE_ERR,
2121 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
Paul Jakmab881c702010-11-23 16:35:42 +00002122 return BGP_ATTR_PARSE_ERROR;
Paul Jakma370b64a2007-12-22 16:49:52 +00002123 }
Paul Jakma835315b2012-01-18 12:28:30 +00002124
paul718e3742002-12-13 20:15:29 +00002125 /* Check extended attribue length bit. */
2126 if (CHECK_FLAG (flag, BGP_ATTR_FLAG_EXTLEN))
2127 length = stream_getw (BGP_INPUT (peer));
2128 else
2129 length = stream_getc (BGP_INPUT (peer));
2130
2131 /* If any attribute appears more than once in the UPDATE
2132 message, then the Error Subcode is set to Malformed Attribute
2133 List. */
2134
2135 if (CHECK_BITMAP (seen, type))
2136 {
2137 zlog (peer->log, LOG_WARNING,
heasleyd68ab102011-07-12 20:09:18 +04002138 "%s: error BGP attribute type %d appears twice in a message",
paul718e3742002-12-13 20:15:29 +00002139 peer->host, type);
2140
2141 bgp_notify_send (peer,
2142 BGP_NOTIFY_UPDATE_ERR,
2143 BGP_NOTIFY_UPDATE_MAL_ATTR);
Paul Jakmab881c702010-11-23 16:35:42 +00002144 return BGP_ATTR_PARSE_ERROR;
paul718e3742002-12-13 20:15:29 +00002145 }
2146
2147 /* Set type to bitmap to check duplicate attribute. `type' is
2148 unsigned char so it never overflow bitmap range. */
2149
2150 SET_BITMAP (seen, type);
2151
2152 /* Overflow check. */
2153 attr_endp = BGP_INPUT_PNT (peer) + length;
2154
2155 if (attr_endp > endp)
2156 {
2157 zlog (peer->log, LOG_WARNING,
heasleyd68ab102011-07-12 20:09:18 +04002158 "%s: BGP type %d length %d is too large, attribute total length is %d. attr_endp is %p. endp is %p", peer->host, type, length, size, attr_endp, endp);
paul718e3742002-12-13 20:15:29 +00002159 bgp_notify_send (peer,
2160 BGP_NOTIFY_UPDATE_ERR,
2161 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
Paul Jakmab881c702010-11-23 16:35:42 +00002162 return BGP_ATTR_PARSE_ERROR;
paul718e3742002-12-13 20:15:29 +00002163 }
Paul Jakma835315b2012-01-18 12:28:30 +00002164
2165 struct bgp_attr_parser_args attr_args = {
2166 .peer = peer,
2167 .length = length,
2168 .attr = attr,
2169 .type = type,
2170 .flags = flag,
2171 .startp = startp,
2172 .total = attr_endp - startp,
2173 };
2174
2175
2176 /* If any recognized attribute has Attribute Flags that conflict
2177 with the Attribute Type Code, then the Error Subcode is set to
2178 Attribute Flags Error. The Data field contains the erroneous
2179 attribute (type, length and value). */
2180 if (bgp_attr_flag_invalid (&attr_args))
Paul Jakmafa61e162012-03-25 21:31:47 +01002181 {
2182 bgp_attr_parse_ret_t ret;
2183 ret = bgp_attr_malformed (&attr_args,
2184 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR,
2185 attr_args.total);
2186 if (ret == BGP_ATTR_PARSE_PROCEED)
2187 continue;
2188 return ret;
2189 }
paul718e3742002-12-13 20:15:29 +00002190
2191 /* OK check attribute and store it's value. */
2192 switch (type)
2193 {
2194 case BGP_ATTR_ORIGIN:
Paul Jakma835315b2012-01-18 12:28:30 +00002195 ret = bgp_attr_origin (&attr_args);
paul718e3742002-12-13 20:15:29 +00002196 break;
2197 case BGP_ATTR_AS_PATH:
Paul Jakma835315b2012-01-18 12:28:30 +00002198 ret = bgp_attr_aspath (&attr_args);
paul718e3742002-12-13 20:15:29 +00002199 break;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002200 case BGP_ATTR_AS4_PATH:
Paul Jakma835315b2012-01-18 12:28:30 +00002201 ret = bgp_attr_as4_path (&attr_args, &as4_path);
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002202 break;
paul718e3742002-12-13 20:15:29 +00002203 case BGP_ATTR_NEXT_HOP:
Paul Jakma835315b2012-01-18 12:28:30 +00002204 ret = bgp_attr_nexthop (&attr_args);
paul718e3742002-12-13 20:15:29 +00002205 break;
2206 case BGP_ATTR_MULTI_EXIT_DISC:
Paul Jakma835315b2012-01-18 12:28:30 +00002207 ret = bgp_attr_med (&attr_args);
paul718e3742002-12-13 20:15:29 +00002208 break;
2209 case BGP_ATTR_LOCAL_PREF:
Paul Jakma835315b2012-01-18 12:28:30 +00002210 ret = bgp_attr_local_pref (&attr_args);
paul718e3742002-12-13 20:15:29 +00002211 break;
2212 case BGP_ATTR_ATOMIC_AGGREGATE:
Paul Jakma835315b2012-01-18 12:28:30 +00002213 ret = bgp_attr_atomic (&attr_args);
paul718e3742002-12-13 20:15:29 +00002214 break;
2215 case BGP_ATTR_AGGREGATOR:
Paul Jakma835315b2012-01-18 12:28:30 +00002216 ret = bgp_attr_aggregator (&attr_args);
paul718e3742002-12-13 20:15:29 +00002217 break;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002218 case BGP_ATTR_AS4_AGGREGATOR:
Paul Jakma835315b2012-01-18 12:28:30 +00002219 ret = bgp_attr_as4_aggregator (&attr_args,
2220 &as4_aggregator,
2221 &as4_aggregator_addr);
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002222 break;
paul718e3742002-12-13 20:15:29 +00002223 case BGP_ATTR_COMMUNITIES:
Paul Jakma835315b2012-01-18 12:28:30 +00002224 ret = bgp_attr_community (&attr_args);
paul718e3742002-12-13 20:15:29 +00002225 break;
2226 case BGP_ATTR_ORIGINATOR_ID:
Paul Jakma835315b2012-01-18 12:28:30 +00002227 ret = bgp_attr_originator_id (&attr_args);
paul718e3742002-12-13 20:15:29 +00002228 break;
2229 case BGP_ATTR_CLUSTER_LIST:
Paul Jakma835315b2012-01-18 12:28:30 +00002230 ret = bgp_attr_cluster_list (&attr_args);
paul718e3742002-12-13 20:15:29 +00002231 break;
2232 case BGP_ATTR_MP_REACH_NLRI:
Paul Jakma835315b2012-01-18 12:28:30 +00002233 ret = bgp_mp_reach_parse (&attr_args, mp_update);
paul718e3742002-12-13 20:15:29 +00002234 break;
2235 case BGP_ATTR_MP_UNREACH_NLRI:
Paul Jakma835315b2012-01-18 12:28:30 +00002236 ret = bgp_mp_unreach_parse (&attr_args, mp_withdraw);
paul718e3742002-12-13 20:15:29 +00002237 break;
2238 case BGP_ATTR_EXT_COMMUNITIES:
Paul Jakma835315b2012-01-18 12:28:30 +00002239 ret = bgp_attr_ext_communities (&attr_args);
paul718e3742002-12-13 20:15:29 +00002240 break;
Lou Bergerc3741782016-01-12 13:42:01 -05002241 case BGP_ATTR_ENCAP:
2242 ret = bgp_attr_encap (type, peer, length, attr, flag, startp);
2243 break;
paul718e3742002-12-13 20:15:29 +00002244 default:
Paul Jakma835315b2012-01-18 12:28:30 +00002245 ret = bgp_attr_unknown (&attr_args);
paul718e3742002-12-13 20:15:29 +00002246 break;
2247 }
Paul Jakmab881c702010-11-23 16:35:42 +00002248
David Lamparterf57000c2014-06-04 01:01:10 +02002249 if (ret == BGP_ATTR_PARSE_ERROR_NOTIFYPLS)
2250 {
2251 bgp_notify_send (peer,
2252 BGP_NOTIFY_UPDATE_ERR,
2253 BGP_NOTIFY_UPDATE_MAL_ATTR);
2254 ret = BGP_ATTR_PARSE_ERROR;
2255 }
2256
Paul Jakmab881c702010-11-23 16:35:42 +00002257 /* If hard error occured immediately return to the caller. */
2258 if (ret == BGP_ATTR_PARSE_ERROR)
Paul Jakma6e4ab122007-04-10 19:36:48 +00002259 {
2260 zlog (peer->log, LOG_WARNING,
2261 "%s: Attribute %s, parse error",
2262 peer->host,
2263 LOOKUP (attr_str, type));
Paul Jakmab881c702010-11-23 16:35:42 +00002264 if (as4_path)
2265 aspath_unintern (&as4_path);
2266 return ret;
Paul Jakma6e4ab122007-04-10 19:36:48 +00002267 }
Paul Jakmab881c702010-11-23 16:35:42 +00002268 if (ret == BGP_ATTR_PARSE_WITHDRAW)
2269 {
2270
2271 zlog (peer->log, LOG_WARNING,
2272 "%s: Attribute %s, parse error - treating as withdrawal",
2273 peer->host,
2274 LOOKUP (attr_str, type));
2275 if (as4_path)
2276 aspath_unintern (&as4_path);
2277 return ret;
2278 }
2279
paul718e3742002-12-13 20:15:29 +00002280 /* Check the fetched length. */
2281 if (BGP_INPUT_PNT (peer) != attr_endp)
2282 {
2283 zlog (peer->log, LOG_WARNING,
Paul Jakma6e4ab122007-04-10 19:36:48 +00002284 "%s: BGP attribute %s, fetch error",
2285 peer->host, LOOKUP (attr_str, type));
paul718e3742002-12-13 20:15:29 +00002286 bgp_notify_send (peer,
2287 BGP_NOTIFY_UPDATE_ERR,
2288 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
Paul Jakmab881c702010-11-23 16:35:42 +00002289 if (as4_path)
2290 aspath_unintern (&as4_path);
2291 return BGP_ATTR_PARSE_ERROR;
paul718e3742002-12-13 20:15:29 +00002292 }
2293 }
paul718e3742002-12-13 20:15:29 +00002294 /* Check final read pointer is same as end pointer. */
2295 if (BGP_INPUT_PNT (peer) != endp)
2296 {
2297 zlog (peer->log, LOG_WARNING,
heasleyd68ab102011-07-12 20:09:18 +04002298 "%s: BGP attribute %s, length mismatch",
Paul Jakma6e4ab122007-04-10 19:36:48 +00002299 peer->host, LOOKUP (attr_str, type));
paul718e3742002-12-13 20:15:29 +00002300 bgp_notify_send (peer,
2301 BGP_NOTIFY_UPDATE_ERR,
2302 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR);
Paul Jakmab881c702010-11-23 16:35:42 +00002303 if (as4_path)
2304 aspath_unintern (&as4_path);
2305 return BGP_ATTR_PARSE_ERROR;
paul718e3742002-12-13 20:15:29 +00002306 }
Paul Jakma055086f2014-09-23 15:23:01 +01002307
2308 /* Check all mandatory well-known attributes are present */
2309 {
2310 bgp_attr_parse_ret_t ret;
2311 if ((ret = bgp_attr_check (peer, attr)) < 0)
2312 {
2313 if (as4_path)
2314 aspath_unintern (&as4_path);
2315 return ret;
2316 }
2317 }
2318
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002319 /*
2320 * At this place we can see whether we got AS4_PATH and/or
2321 * AS4_AGGREGATOR from a 16Bit peer and act accordingly.
2322 * We can not do this before we've read all attributes because
2323 * the as4 handling does not say whether AS4_PATH has to be sent
2324 * after AS_PATH or not - and when AS4_AGGREGATOR will be send
2325 * in relationship to AGGREGATOR.
2326 * So, to be defensive, we are not relying on any order and read
2327 * all attributes first, including these 32bit ones, and now,
2328 * afterwards, we look what and if something is to be done for as4.
Paul Jakmaaed1b552014-10-21 16:59:01 +01002329 *
2330 * It is possible to not have AS_PATH, e.g. GR EoR and sole
2331 * MP_UNREACH_NLRI.
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002332 */
David Lamparterf57000c2014-06-04 01:01:10 +02002333 /* actually... this doesn't ever return failure currently, but
2334 * better safe than sorry */
Paul Jakmaaed1b552014-10-21 16:59:01 +01002335 if (CHECK_FLAG(attr->flag, ATTR_FLAG_BIT (BGP_ATTR_AS_PATH))
2336 && bgp_attr_munge_as4_attrs (peer, attr, as4_path,
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002337 as4_aggregator, &as4_aggregator_addr))
Paul Jakmab881c702010-11-23 16:35:42 +00002338 {
David Lamparterf57000c2014-06-04 01:01:10 +02002339 bgp_notify_send (peer,
2340 BGP_NOTIFY_UPDATE_ERR,
2341 BGP_NOTIFY_UPDATE_MAL_ATTR);
Paul Jakmab881c702010-11-23 16:35:42 +00002342 if (as4_path)
2343 aspath_unintern (&as4_path);
2344 return BGP_ATTR_PARSE_ERROR;
2345 }
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002346
2347 /* At this stage, we have done all fiddling with as4, and the
2348 * resulting info is in attr->aggregator resp. attr->aspath
2349 * so we can chuck as4_aggregator and as4_path alltogether in
2350 * order to save memory
2351 */
Paul Jakmab881c702010-11-23 16:35:42 +00002352 if (as4_path)
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002353 {
Paul Jakmaf6f434b2010-11-23 21:28:03 +00002354 aspath_unintern (&as4_path); /* unintern - it is in the hash */
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002355 /* The flag that we got this is still there, but that does not
2356 * do any trouble
2357 */
2358 }
2359 /*
2360 * The "rest" of the code does nothing with as4_aggregator.
2361 * there is no memory attached specifically which is not part
2362 * of the attr.
2363 * so ignoring just means do nothing.
2364 */
2365 /*
2366 * Finally do the checks on the aspath we did not do yet
2367 * because we waited for a potentially synthesized aspath.
2368 */
Paul Jakmab881c702010-11-23 16:35:42 +00002369 if (attr->flag & (ATTR_FLAG_BIT(BGP_ATTR_AS_PATH)))
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002370 {
Paul Jakma835315b2012-01-18 12:28:30 +00002371 ret = bgp_attr_aspath_check (peer, attr);
Paul Jakmab881c702010-11-23 16:35:42 +00002372 if (ret != BGP_ATTR_PARSE_PROCEED)
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002373 return ret;
2374 }
2375
paul718e3742002-12-13 20:15:29 +00002376 /* Finally intern unknown attribute. */
Paul Jakmafb982c22007-05-04 20:15:47 +00002377 if (attr->extra && attr->extra->transit)
2378 attr->extra->transit = transit_intern (attr->extra->transit);
paul718e3742002-12-13 20:15:29 +00002379
Paul Jakmab881c702010-11-23 16:35:42 +00002380 return BGP_ATTR_PARSE_PROCEED;
paul718e3742002-12-13 20:15:29 +00002381}
2382
paul718e3742002-12-13 20:15:29 +00002383int stream_put_prefix (struct stream *, struct prefix *);
2384
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002385size_t
2386bgp_packet_mpattr_start (struct stream *s, afi_t afi, safi_t safi,
2387 struct attr *attr)
2388{
2389 size_t sizep;
2390
2391 /* Set extended bit always to encode the attribute length as 2 bytes */
2392 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_EXTLEN);
2393 stream_putc (s, BGP_ATTR_MP_REACH_NLRI);
2394 sizep = stream_get_endp (s);
2395 stream_putw (s, 0); /* Marker: Attribute length. */
Lou Berger050defe2016-01-12 13:41:59 -05002396
2397 stream_putw (s, afi);
2398 stream_putc (s, (safi == SAFI_MPLS_VPN) ? SAFI_MPLS_LABELED_VPN : safi);
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002399
2400 /* Nexthop */
2401 switch (afi)
2402 {
2403 case AFI_IP:
2404 switch (safi)
2405 {
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002406 case SAFI_MULTICAST:
2407 stream_putc (s, 4);
2408 stream_put_ipv4 (s, attr->nexthop.s_addr);
2409 break;
2410 case SAFI_MPLS_VPN:
2411 stream_putc (s, 12);
Lou Berger050defe2016-01-12 13:41:59 -05002412 stream_putl (s, 0); /* RD = 0, per RFC */
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002413 stream_putl (s, 0);
2414 stream_put (s, &attr->extra->mp_nexthop_global_in, 4);
2415 break;
Lou Berger298cc2f2016-01-12 13:42:02 -05002416 case SAFI_ENCAP:
2417 stream_putc (s, 4);
2418 stream_put (s, &attr->extra->mp_nexthop_global_in, 4);
2419 break;
Lou Berger050defe2016-01-12 13:41:59 -05002420 case SAFI_UNICAST: /* invalid for IPv4 */
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002421 default:
2422 break;
2423 }
2424 break;
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002425 case AFI_IP6:
2426 switch (safi)
2427 {
2428 case SAFI_UNICAST:
2429 case SAFI_MULTICAST:
2430 {
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002431 struct attr_extra *attre = attr->extra;
2432
2433 assert (attr->extra);
2434 stream_putc (s, attre->mp_nexthop_len);
2435 stream_put (s, &attre->mp_nexthop_global, 16);
2436 if (attre->mp_nexthop_len == 32)
2437 stream_put (s, &attre->mp_nexthop_local, 16);
2438 }
Lou Berger050defe2016-01-12 13:41:59 -05002439 break;
2440 case SAFI_MPLS_VPN:
2441 {
2442 struct attr_extra *attre = attr->extra;
2443
2444 assert (attr->extra);
2445 if (attre->mp_nexthop_len == 16) {
2446 stream_putc (s, 24);
2447 stream_putl (s, 0); /* RD = 0, per RFC */
2448 stream_putl (s, 0);
2449 stream_put (s, &attre->mp_nexthop_global, 16);
2450 } else if (attre->mp_nexthop_len == 32) {
2451 stream_putc (s, 48);
2452 stream_putl (s, 0); /* RD = 0, per RFC */
2453 stream_putl (s, 0);
2454 stream_put (s, &attre->mp_nexthop_global, 16);
2455 stream_putl (s, 0); /* RD = 0, per RFC */
2456 stream_putl (s, 0);
2457 stream_put (s, &attre->mp_nexthop_local, 16);
2458 }
2459 }
2460 break;
Lou Berger298cc2f2016-01-12 13:42:02 -05002461 case SAFI_ENCAP:
2462 assert (attr->extra);
2463 stream_putc (s, 16);
2464 stream_put (s, &attr->extra->mp_nexthop_global, 16);
2465 break;
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002466 default:
2467 break;
2468 }
2469 break;
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002470 default:
2471 break;
2472 }
2473
2474 /* SNPA */
2475 stream_putc (s, 0);
2476 return sizep;
2477}
2478
2479void
2480bgp_packet_mpattr_prefix (struct stream *s, afi_t afi, safi_t safi,
2481 struct prefix *p, struct prefix_rd *prd,
2482 u_char *tag)
2483{
Lou Berger050defe2016-01-12 13:41:59 -05002484 if (safi == SAFI_MPLS_VPN)
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002485 {
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002486 /* Tag, RD, Prefix write. */
2487 stream_putc (s, p->prefixlen + 88);
2488 stream_put (s, tag, 3);
2489 stream_put (s, prd->val, 8);
2490 stream_put (s, &p->u.prefix, PSIZE (p->prefixlen));
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002491 }
Lou Berger050defe2016-01-12 13:41:59 -05002492 else
2493 stream_put_prefix (s, p);
2494}
2495
2496size_t
2497bgp_packet_mpattr_prefix_size (afi_t afi, safi_t safi, struct prefix *p)
2498{
2499 int size = PSIZE (p->prefixlen);
2500 if (safi == SAFI_MPLS_VPN)
2501 size += 88;
2502 return size;
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002503}
2504
Lou Bergerc3741782016-01-12 13:42:01 -05002505/*
2506 * Encodes the tunnel encapsulation attribute
2507 */
2508static void
2509bgp_packet_mpattr_tea(
2510 struct bgp *bgp,
2511 struct peer *peer,
2512 struct stream *s,
2513 struct attr *attr,
2514 uint8_t attrtype)
2515{
2516 unsigned int attrlenfield = 0;
Lou Berger298cc2f2016-01-12 13:42:02 -05002517 unsigned int attrhdrlen = 0;
Lou Bergerc3741782016-01-12 13:42:01 -05002518 struct bgp_attr_encap_subtlv *subtlvs;
2519 struct bgp_attr_encap_subtlv *st;
2520 const char *attrname;
2521
2522 if (!attr || !attr->extra)
2523 return;
2524
2525 switch (attrtype) {
2526 case BGP_ATTR_ENCAP:
2527 attrname = "Tunnel Encap";
2528 subtlvs = attr->extra->encap_subtlvs;
2529
2530 /*
2531 * The tunnel encap attr has an "outer" tlv.
2532 * T = tunneltype,
2533 * L = total length of subtlvs,
2534 * V = concatenated subtlvs.
2535 */
2536 attrlenfield = 2 + 2; /* T + L */
Lou Berger298cc2f2016-01-12 13:42:02 -05002537 attrhdrlen = 1 + 1; /* subTLV T + L */
Lou Bergerc3741782016-01-12 13:42:01 -05002538 break;
2539
2540 default:
2541 assert(0);
2542 }
2543
2544
Lou Berger298cc2f2016-01-12 13:42:02 -05002545 /* if no tlvs, don't make attr */
2546 if (subtlvs == NULL)
2547 return;
2548
Lou Bergerc3741782016-01-12 13:42:01 -05002549 /* compute attr length */
2550 for (st = subtlvs; st; st = st->next) {
Lou Berger298cc2f2016-01-12 13:42:02 -05002551 attrlenfield += (attrhdrlen + st->length);
Lou Bergerc3741782016-01-12 13:42:01 -05002552 }
2553
Lou Bergerc3741782016-01-12 13:42:01 -05002554 if (attrlenfield > 0xffff) {
2555 zlog (peer->log, LOG_ERR,
2556 "%s attribute is too long (length=%d), can't send it",
2557 attrname,
2558 attrlenfield);
2559 return;
2560 }
2561
2562 if (attrlenfield > 0xff) {
2563 /* 2-octet length field */
2564 stream_putc (s,
2565 BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_EXTLEN);
2566 stream_putc (s, attrtype);
2567 stream_putw (s, attrlenfield & 0xffff);
2568 } else {
2569 /* 1-octet length field */
2570 stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL);
2571 stream_putc (s, attrtype);
2572 stream_putc (s, attrlenfield & 0xff);
2573 }
2574
2575 if (attrtype == BGP_ATTR_ENCAP) {
2576 /* write outer T+L */
2577 stream_putw(s, attr->extra->encap_tunneltype);
2578 stream_putw(s, attrlenfield - 4);
2579 }
2580
2581 /* write each sub-tlv */
2582 for (st = subtlvs; st; st = st->next) {
Lou Berger298cc2f2016-01-12 13:42:02 -05002583 if (attrtype == BGP_ATTR_ENCAP) {
2584 stream_putc (s, st->type);
2585 stream_putc (s, st->length);
2586 }
Lou Bergerc3741782016-01-12 13:42:01 -05002587 stream_put (s, st->value, st->length);
2588 }
2589}
2590
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002591void
2592bgp_packet_mpattr_end (struct stream *s, size_t sizep)
2593{
2594 /* Set MP attribute length. Don't count the (2) bytes used to encode
2595 the attr length */
2596 stream_putw_at (s, sizep, (stream_get_endp (s) - sizep) - 2);
2597}
2598
paul718e3742002-12-13 20:15:29 +00002599/* Make attribute packet. */
2600bgp_size_t
2601bgp_packet_attribute (struct bgp *bgp, struct peer *peer,
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002602 struct stream *s, struct attr *attr,
2603 struct prefix *p, afi_t afi, safi_t safi,
2604 struct peer *from, struct prefix_rd *prd, u_char *tag)
paul718e3742002-12-13 20:15:29 +00002605{
paulfe69a502005-09-10 16:55:02 +00002606 size_t cp;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002607 size_t aspath_sizep;
paul718e3742002-12-13 20:15:29 +00002608 struct aspath *aspath;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002609 int send_as4_path = 0;
2610 int send_as4_aggregator = 0;
2611 int use32bit = (CHECK_FLAG (peer->cap, PEER_CAP_AS4_RCV)) ? 1 : 0;
paul718e3742002-12-13 20:15:29 +00002612
2613 if (! bgp)
2614 bgp = bgp_get_default ();
2615
2616 /* Remember current pointer. */
paul9985f832005-02-09 15:51:56 +00002617 cp = stream_get_endp (s);
paul718e3742002-12-13 20:15:29 +00002618
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002619 if (p && !(afi == AFI_IP && safi == SAFI_UNICAST))
2620 {
Lou Berger050defe2016-01-12 13:41:59 -05002621 size_t mpattrlen_pos = 0;
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002622 mpattrlen_pos = bgp_packet_mpattr_start(s, afi, safi, attr);
2623 bgp_packet_mpattr_prefix(s, afi, safi, p, prd, tag);
2624 bgp_packet_mpattr_end(s, mpattrlen_pos);
2625 }
2626
paul718e3742002-12-13 20:15:29 +00002627 /* Origin attribute. */
2628 stream_putc (s, BGP_ATTR_FLAG_TRANS);
2629 stream_putc (s, BGP_ATTR_ORIGIN);
2630 stream_putc (s, 1);
2631 stream_putc (s, attr->origin);
2632
2633 /* AS path attribute. */
2634
2635 /* If remote-peer is EBGP */
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00002636 if (peer->sort == BGP_PEER_EBGP
paul718e3742002-12-13 20:15:29 +00002637 && (! CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_AS_PATH_UNCHANGED)
paulfe69a502005-09-10 16:55:02 +00002638 || attr->aspath->segments == NULL)
paulfee0f4c2004-09-13 05:12:46 +00002639 && (! CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_RSERVER_CLIENT)))
paul718e3742002-12-13 20:15:29 +00002640 {
2641 aspath = aspath_dup (attr->aspath);
2642
2643 if (CHECK_FLAG(bgp->config, BGP_CONFIG_CONFEDERATION))
2644 {
2645 /* Strip the confed info, and then stuff our path CONFED_ID
2646 on the front */
2647 aspath = aspath_delete_confed_seq (aspath);
2648 aspath = aspath_add_seq (aspath, bgp->confed_id);
2649 }
2650 else
2651 {
Andrew Certain9d3f9702012-11-07 23:50:07 +00002652 if (peer->change_local_as) {
2653 /* If replace-as is specified, we only use the change_local_as when
2654 advertising routes. */
2655 if( ! CHECK_FLAG (peer->flags, PEER_FLAG_LOCAL_AS_REPLACE_AS) ) {
2656 aspath = aspath_add_seq (aspath, peer->local_as);
2657 }
paul718e3742002-12-13 20:15:29 +00002658 aspath = aspath_add_seq (aspath, peer->change_local_as);
Andrew Certain9d3f9702012-11-07 23:50:07 +00002659 } else {
2660 aspath = aspath_add_seq (aspath, peer->local_as);
2661 }
paul718e3742002-12-13 20:15:29 +00002662 }
2663 }
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00002664 else if (peer->sort == BGP_PEER_CONFED)
paul718e3742002-12-13 20:15:29 +00002665 {
2666 /* A confed member, so we need to do the AS_CONFED_SEQUENCE thing */
2667 aspath = aspath_dup (attr->aspath);
2668 aspath = aspath_add_confed_seq (aspath, peer->local_as);
2669 }
2670 else
2671 aspath = attr->aspath;
2672
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002673 /* If peer is not AS4 capable, then:
2674 * - send the created AS_PATH out as AS4_PATH (optional, transitive),
2675 * but ensure that no AS_CONFED_SEQUENCE and AS_CONFED_SET path segment
2676 * types are in it (i.e. exclude them if they are there)
2677 * AND do this only if there is at least one asnum > 65535 in the path!
2678 * - send an AS_PATH out, but put 16Bit ASnums in it, not 32bit, and change
2679 * all ASnums > 65535 to BGP_AS_TRANS
2680 */
paul718e3742002-12-13 20:15:29 +00002681
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002682 stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
2683 stream_putc (s, BGP_ATTR_AS_PATH);
2684 aspath_sizep = stream_get_endp (s);
2685 stream_putw (s, 0);
2686 stream_putw_at (s, aspath_sizep, aspath_put (s, aspath, use32bit));
2687
2688 /* OLD session may need NEW_AS_PATH sent, if there are 4-byte ASNs
2689 * in the path
2690 */
2691 if (!use32bit && aspath_has_as4 (aspath))
2692 send_as4_path = 1; /* we'll do this later, at the correct place */
2693
paul718e3742002-12-13 20:15:29 +00002694 /* Nexthop attribute. */
Lou Berger050defe2016-01-12 13:41:59 -05002695 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_NEXT_HOP) && afi == AFI_IP &&
2696 safi == SAFI_UNICAST) /* only write NH attr for unicast safi */
paul718e3742002-12-13 20:15:29 +00002697 {
2698 stream_putc (s, BGP_ATTR_FLAG_TRANS);
2699 stream_putc (s, BGP_ATTR_NEXT_HOP);
2700 stream_putc (s, 4);
2701 if (safi == SAFI_MPLS_VPN)
2702 {
2703 if (attr->nexthop.s_addr == 0)
2704 stream_put_ipv4 (s, peer->nexthop.v4.s_addr);
2705 else
2706 stream_put_ipv4 (s, attr->nexthop.s_addr);
2707 }
2708 else
2709 stream_put_ipv4 (s, attr->nexthop.s_addr);
2710 }
2711
2712 /* MED attribute. */
2713 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC))
2714 {
2715 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
2716 stream_putc (s, BGP_ATTR_MULTI_EXIT_DISC);
2717 stream_putc (s, 4);
2718 stream_putl (s, attr->med);
2719 }
2720
2721 /* Local preference. */
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00002722 if (peer->sort == BGP_PEER_IBGP ||
2723 peer->sort == BGP_PEER_CONFED)
paul718e3742002-12-13 20:15:29 +00002724 {
2725 stream_putc (s, BGP_ATTR_FLAG_TRANS);
2726 stream_putc (s, BGP_ATTR_LOCAL_PREF);
2727 stream_putc (s, 4);
2728 stream_putl (s, attr->local_pref);
2729 }
2730
2731 /* Atomic aggregate. */
2732 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE))
2733 {
2734 stream_putc (s, BGP_ATTR_FLAG_TRANS);
2735 stream_putc (s, BGP_ATTR_ATOMIC_AGGREGATE);
2736 stream_putc (s, 0);
2737 }
2738
2739 /* Aggregator. */
2740 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR))
2741 {
Paul Jakmafb982c22007-05-04 20:15:47 +00002742 assert (attr->extra);
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002743
2744 /* Common to BGP_ATTR_AGGREGATOR, regardless of ASN size */
paul718e3742002-12-13 20:15:29 +00002745 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
2746 stream_putc (s, BGP_ATTR_AGGREGATOR);
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002747
2748 if (use32bit)
2749 {
2750 /* AS4 capable peer */
2751 stream_putc (s, 8);
2752 stream_putl (s, attr->extra->aggregator_as);
2753 }
2754 else
2755 {
2756 /* 2-byte AS peer */
2757 stream_putc (s, 6);
2758
2759 /* Is ASN representable in 2-bytes? Or must AS_TRANS be used? */
2760 if ( attr->extra->aggregator_as > 65535 )
2761 {
2762 stream_putw (s, BGP_AS_TRANS);
2763
2764 /* we have to send AS4_AGGREGATOR, too.
2765 * we'll do that later in order to send attributes in ascending
2766 * order.
2767 */
2768 send_as4_aggregator = 1;
2769 }
2770 else
2771 stream_putw (s, (u_int16_t) attr->extra->aggregator_as);
2772 }
Paul Jakmafb982c22007-05-04 20:15:47 +00002773 stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
paul718e3742002-12-13 20:15:29 +00002774 }
2775
2776 /* Community attribute. */
2777 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_COMMUNITY)
2778 && (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES)))
2779 {
2780 if (attr->community->size * 4 > 255)
2781 {
2782 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
2783 stream_putc (s, BGP_ATTR_COMMUNITIES);
2784 stream_putw (s, attr->community->size * 4);
2785 }
2786 else
2787 {
2788 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
2789 stream_putc (s, BGP_ATTR_COMMUNITIES);
2790 stream_putc (s, attr->community->size * 4);
2791 }
2792 stream_put (s, attr->community->val, attr->community->size * 4);
2793 }
2794
2795 /* Route Reflector. */
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00002796 if (peer->sort == BGP_PEER_IBGP
paul718e3742002-12-13 20:15:29 +00002797 && from
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00002798 && from->sort == BGP_PEER_IBGP)
paul718e3742002-12-13 20:15:29 +00002799 {
2800 /* Originator ID. */
2801 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
2802 stream_putc (s, BGP_ATTR_ORIGINATOR_ID);
2803 stream_putc (s, 4);
2804
2805 if (attr->flag & ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID))
Paul Jakmafb982c22007-05-04 20:15:47 +00002806 stream_put_in_addr (s, &attr->extra->originator_id);
Paul Jakma34c3f812006-05-12 23:25:37 +00002807 else
2808 stream_put_in_addr (s, &from->remote_id);
paul718e3742002-12-13 20:15:29 +00002809
2810 /* Cluster list. */
2811 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
2812 stream_putc (s, BGP_ATTR_CLUSTER_LIST);
2813
Paul Jakma9eda90c2007-08-30 13:36:17 +00002814 if (attr->extra && attr->extra->cluster)
paul718e3742002-12-13 20:15:29 +00002815 {
Paul Jakmafb982c22007-05-04 20:15:47 +00002816 stream_putc (s, attr->extra->cluster->length + 4);
paul718e3742002-12-13 20:15:29 +00002817 /* If this peer configuration's parent BGP has cluster_id. */
2818 if (bgp->config & BGP_CONFIG_CLUSTER_ID)
2819 stream_put_in_addr (s, &bgp->cluster_id);
2820 else
2821 stream_put_in_addr (s, &bgp->router_id);
Paul Jakmafb982c22007-05-04 20:15:47 +00002822 stream_put (s, attr->extra->cluster->list,
2823 attr->extra->cluster->length);
paul718e3742002-12-13 20:15:29 +00002824 }
2825 else
2826 {
2827 stream_putc (s, 4);
2828 /* If this peer configuration's parent BGP has cluster_id. */
2829 if (bgp->config & BGP_CONFIG_CLUSTER_ID)
2830 stream_put_in_addr (s, &bgp->cluster_id);
2831 else
2832 stream_put_in_addr (s, &bgp->router_id);
2833 }
2834 }
2835
paul718e3742002-12-13 20:15:29 +00002836 /* Extended Communities attribute. */
2837 if (CHECK_FLAG (peer->af_flags[afi][safi], PEER_FLAG_SEND_EXT_COMMUNITY)
2838 && (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_EXT_COMMUNITIES)))
2839 {
Paul Jakmafb982c22007-05-04 20:15:47 +00002840 struct attr_extra *attre = attr->extra;
2841
2842 assert (attre);
2843
Jorge Boncompte [DTI2]6d85b152012-05-07 16:52:54 +00002844 if (peer->sort == BGP_PEER_IBGP
2845 || peer->sort == BGP_PEER_CONFED)
paul718e3742002-12-13 20:15:29 +00002846 {
Paul Jakmafb982c22007-05-04 20:15:47 +00002847 if (attre->ecommunity->size * 8 > 255)
hasso4372df72004-05-20 10:20:02 +00002848 {
2849 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
2850 stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
Paul Jakmafb982c22007-05-04 20:15:47 +00002851 stream_putw (s, attre->ecommunity->size * 8);
hasso4372df72004-05-20 10:20:02 +00002852 }
2853 else
2854 {
2855 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
2856 stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
Paul Jakmafb982c22007-05-04 20:15:47 +00002857 stream_putc (s, attre->ecommunity->size * 8);
hasso4372df72004-05-20 10:20:02 +00002858 }
Paul Jakmafb982c22007-05-04 20:15:47 +00002859 stream_put (s, attre->ecommunity->val, attre->ecommunity->size * 8);
paul718e3742002-12-13 20:15:29 +00002860 }
2861 else
2862 {
paul5228ad22004-06-04 17:58:18 +00002863 u_int8_t *pnt;
hasso4372df72004-05-20 10:20:02 +00002864 int tbit;
2865 int ecom_tr_size = 0;
2866 int i;
2867
Paul Jakmafb982c22007-05-04 20:15:47 +00002868 for (i = 0; i < attre->ecommunity->size; i++)
hasso4372df72004-05-20 10:20:02 +00002869 {
Paul Jakmafb982c22007-05-04 20:15:47 +00002870 pnt = attre->ecommunity->val + (i * 8);
hasso4372df72004-05-20 10:20:02 +00002871 tbit = *pnt;
2872
2873 if (CHECK_FLAG (tbit, ECOMMUNITY_FLAG_NON_TRANSITIVE))
2874 continue;
2875
2876 ecom_tr_size++;
2877 }
2878
2879 if (ecom_tr_size)
2880 {
2881 if (ecom_tr_size * 8 > 255)
2882 {
2883 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
2884 stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
2885 stream_putw (s, ecom_tr_size * 8);
2886 }
2887 else
2888 {
2889 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
2890 stream_putc (s, BGP_ATTR_EXT_COMMUNITIES);
2891 stream_putc (s, ecom_tr_size * 8);
2892 }
2893
Paul Jakmafb982c22007-05-04 20:15:47 +00002894 for (i = 0; i < attre->ecommunity->size; i++)
hasso4372df72004-05-20 10:20:02 +00002895 {
Paul Jakmafb982c22007-05-04 20:15:47 +00002896 pnt = attre->ecommunity->val + (i * 8);
hasso4372df72004-05-20 10:20:02 +00002897 tbit = *pnt;
2898
2899 if (CHECK_FLAG (tbit, ECOMMUNITY_FLAG_NON_TRANSITIVE))
2900 continue;
2901
2902 stream_put (s, pnt, 8);
2903 }
2904 }
paul718e3742002-12-13 20:15:29 +00002905 }
paul718e3742002-12-13 20:15:29 +00002906 }
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00002907
2908 if ( send_as4_path )
2909 {
2910 /* If the peer is NOT As4 capable, AND */
2911 /* there are ASnums > 65535 in path THEN
2912 * give out AS4_PATH */
2913
2914 /* Get rid of all AS_CONFED_SEQUENCE and AS_CONFED_SET
2915 * path segments!
2916 * Hm, I wonder... confederation things *should* only be at
2917 * the beginning of an aspath, right? Then we should use
2918 * aspath_delete_confed_seq for this, because it is already
2919 * there! (JK)
2920 * Folks, talk to me: what is reasonable here!?
2921 */
2922 aspath = aspath_delete_confed_seq (aspath);
2923
2924 stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_EXTLEN);
2925 stream_putc (s, BGP_ATTR_AS4_PATH);
2926 aspath_sizep = stream_get_endp (s);
2927 stream_putw (s, 0);
2928 stream_putw_at (s, aspath_sizep, aspath_put (s, aspath, 1));
2929 }
2930
2931 if (aspath != attr->aspath)
2932 aspath_free (aspath);
2933
2934 if ( send_as4_aggregator )
2935 {
2936 assert (attr->extra);
2937
2938 /* send AS4_AGGREGATOR, at this place */
2939 /* this section of code moved here in order to ensure the correct
2940 * *ascending* order of attributes
2941 */
2942 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
2943 stream_putc (s, BGP_ATTR_AS4_AGGREGATOR);
2944 stream_putc (s, 8);
2945 stream_putl (s, attr->extra->aggregator_as);
2946 stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
2947 }
Lou Berger298cc2f2016-01-12 13:42:02 -05002948
2949 if ((afi == AFI_IP || afi == AFI_IP6) &&
2950 (safi == SAFI_ENCAP || safi == SAFI_MPLS_VPN))
2951 {
2952 /* Tunnel Encap attribute */
2953 bgp_packet_mpattr_tea(bgp, peer, s, attr, BGP_ATTR_ENCAP);
2954 }
2955
paul718e3742002-12-13 20:15:29 +00002956 /* Unknown transit attribute. */
Paul Jakmafb982c22007-05-04 20:15:47 +00002957 if (attr->extra && attr->extra->transit)
2958 stream_put (s, attr->extra->transit->val, attr->extra->transit->length);
paul718e3742002-12-13 20:15:29 +00002959
2960 /* Return total size of attribute. */
paul9985f832005-02-09 15:51:56 +00002961 return stream_get_endp (s) - cp;
paul718e3742002-12-13 20:15:29 +00002962}
2963
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002964size_t
2965bgp_packet_mpunreach_start (struct stream *s, afi_t afi, safi_t safi)
paul718e3742002-12-13 20:15:29 +00002966{
paul718e3742002-12-13 20:15:29 +00002967 unsigned long attrlen_pnt;
paul718e3742002-12-13 20:15:29 +00002968
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002969 /* Set extended bit always to encode the attribute length as 2 bytes */
2970 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_EXTLEN);
paul718e3742002-12-13 20:15:29 +00002971 stream_putc (s, BGP_ATTR_MP_UNREACH_NLRI);
2972
paul9985f832005-02-09 15:51:56 +00002973 attrlen_pnt = stream_get_endp (s);
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002974 stream_putw (s, 0); /* Length of this attribute. */
paul718e3742002-12-13 20:15:29 +00002975
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002976 stream_putw (s, afi);
Lou Berger050defe2016-01-12 13:41:59 -05002977 stream_putc (s, (safi == SAFI_MPLS_VPN) ? SAFI_MPLS_LABELED_VPN : safi);
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002978 return attrlen_pnt;
2979}
paul718e3742002-12-13 20:15:29 +00002980
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002981void
2982bgp_packet_mpunreach_prefix (struct stream *s, struct prefix *p,
2983 afi_t afi, safi_t safi, struct prefix_rd *prd,
2984 u_char *tag)
2985{
Lou Berger050defe2016-01-12 13:41:59 -05002986 bgp_packet_mpattr_prefix (s, afi, safi, p, prd, tag);
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002987}
paul718e3742002-12-13 20:15:29 +00002988
Pradosh Mohapatra8c71e482014-01-15 06:57:57 +00002989void
2990bgp_packet_mpunreach_end (struct stream *s, size_t attrlen_pnt)
2991{
Lou Berger050defe2016-01-12 13:41:59 -05002992 bgp_packet_mpattr_end (s, attrlen_pnt);
paul718e3742002-12-13 20:15:29 +00002993}
2994
2995/* Initialization of attribute. */
2996void
paulfe69a502005-09-10 16:55:02 +00002997bgp_attr_init (void)
paul718e3742002-12-13 20:15:29 +00002998{
paul718e3742002-12-13 20:15:29 +00002999 aspath_init ();
3000 attrhash_init ();
3001 community_init ();
3002 ecommunity_init ();
3003 cluster_init ();
3004 transit_init ();
3005}
3006
Chris Caputo228da422009-07-18 05:44:03 +00003007void
3008bgp_attr_finish (void)
3009{
3010 aspath_finish ();
3011 attrhash_finish ();
3012 community_finish ();
3013 ecommunity_finish ();
3014 cluster_finish ();
3015 transit_finish ();
3016}
3017
paul718e3742002-12-13 20:15:29 +00003018/* Make attribute packet. */
3019void
paula3845922003-10-18 01:30:50 +00003020bgp_dump_routes_attr (struct stream *s, struct attr *attr,
3021 struct prefix *prefix)
paul718e3742002-12-13 20:15:29 +00003022{
3023 unsigned long cp;
3024 unsigned long len;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00003025 size_t aspath_lenp;
paul718e3742002-12-13 20:15:29 +00003026 struct aspath *aspath;
3027
3028 /* Remember current pointer. */
paul9985f832005-02-09 15:51:56 +00003029 cp = stream_get_endp (s);
paul718e3742002-12-13 20:15:29 +00003030
3031 /* Place holder of length. */
3032 stream_putw (s, 0);
3033
3034 /* Origin attribute. */
3035 stream_putc (s, BGP_ATTR_FLAG_TRANS);
3036 stream_putc (s, BGP_ATTR_ORIGIN);
3037 stream_putc (s, 1);
3038 stream_putc (s, attr->origin);
3039
3040 aspath = attr->aspath;
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00003041
3042 stream_putc (s, BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
3043 stream_putc (s, BGP_ATTR_AS_PATH);
3044 aspath_lenp = stream_get_endp (s);
3045 stream_putw (s, 0);
3046
3047 stream_putw_at (s, aspath_lenp, aspath_put (s, aspath, 1));
paul718e3742002-12-13 20:15:29 +00003048
3049 /* Nexthop attribute. */
paula3845922003-10-18 01:30:50 +00003050 /* If it's an IPv6 prefix, don't dump the IPv4 nexthop to save space */
3051 if(prefix != NULL
paula3845922003-10-18 01:30:50 +00003052 && prefix->family != AF_INET6
paula3845922003-10-18 01:30:50 +00003053 )
3054 {
3055 stream_putc (s, BGP_ATTR_FLAG_TRANS);
3056 stream_putc (s, BGP_ATTR_NEXT_HOP);
3057 stream_putc (s, 4);
3058 stream_put_ipv4 (s, attr->nexthop.s_addr);
3059 }
paul718e3742002-12-13 20:15:29 +00003060
3061 /* MED attribute. */
3062 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_MULTI_EXIT_DISC))
3063 {
3064 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL);
3065 stream_putc (s, BGP_ATTR_MULTI_EXIT_DISC);
3066 stream_putc (s, 4);
3067 stream_putl (s, attr->med);
3068 }
3069
3070 /* Local preference. */
3071 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_LOCAL_PREF))
3072 {
3073 stream_putc (s, BGP_ATTR_FLAG_TRANS);
3074 stream_putc (s, BGP_ATTR_LOCAL_PREF);
3075 stream_putc (s, 4);
3076 stream_putl (s, attr->local_pref);
3077 }
3078
3079 /* Atomic aggregate. */
3080 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_ATOMIC_AGGREGATE))
3081 {
3082 stream_putc (s, BGP_ATTR_FLAG_TRANS);
3083 stream_putc (s, BGP_ATTR_ATOMIC_AGGREGATE);
3084 stream_putc (s, 0);
3085 }
3086
3087 /* Aggregator. */
3088 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_AGGREGATOR))
3089 {
Paul Jakmafb982c22007-05-04 20:15:47 +00003090 assert (attr->extra);
paul718e3742002-12-13 20:15:29 +00003091 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
3092 stream_putc (s, BGP_ATTR_AGGREGATOR);
Paul Jakma0b2aa3a2007-10-14 22:32:21 +00003093 stream_putc (s, 8);
3094 stream_putl (s, attr->extra->aggregator_as);
Paul Jakmafb982c22007-05-04 20:15:47 +00003095 stream_put_ipv4 (s, attr->extra->aggregator_addr.s_addr);
paul718e3742002-12-13 20:15:29 +00003096 }
3097
3098 /* Community attribute. */
3099 if (attr->flag & ATTR_FLAG_BIT (BGP_ATTR_COMMUNITIES))
3100 {
3101 if (attr->community->size * 4 > 255)
3102 {
3103 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS|BGP_ATTR_FLAG_EXTLEN);
3104 stream_putc (s, BGP_ATTR_COMMUNITIES);
3105 stream_putw (s, attr->community->size * 4);
3106 }
3107 else
3108 {
3109 stream_putc (s, BGP_ATTR_FLAG_OPTIONAL|BGP_ATTR_FLAG_TRANS);
3110 stream_putc (s, BGP_ATTR_COMMUNITIES);
3111 stream_putc (s, attr->community->size * 4);
3112 }
3113 stream_put (s, attr->community->val, attr->community->size * 4);
3114 }
3115
paula3845922003-10-18 01:30:50 +00003116 /* Add a MP_NLRI attribute to dump the IPv6 next hop */
Paul Jakmafb982c22007-05-04 20:15:47 +00003117 if (prefix != NULL && prefix->family == AF_INET6 && attr->extra &&
3118 (attr->extra->mp_nexthop_len == 16 || attr->extra->mp_nexthop_len == 32) )
paula3845922003-10-18 01:30:50 +00003119 {
3120 int sizep;
Paul Jakmafb982c22007-05-04 20:15:47 +00003121 struct attr_extra *attre = attr->extra;
3122
paula3845922003-10-18 01:30:50 +00003123 stream_putc(s, BGP_ATTR_FLAG_OPTIONAL);
3124 stream_putc(s, BGP_ATTR_MP_REACH_NLRI);
paul9985f832005-02-09 15:51:56 +00003125 sizep = stream_get_endp (s);
paula3845922003-10-18 01:30:50 +00003126
3127 /* MP header */
Paul Jakmafb982c22007-05-04 20:15:47 +00003128 stream_putc (s, 0); /* Marker: Attribute length. */
paula3845922003-10-18 01:30:50 +00003129 stream_putw(s, AFI_IP6); /* AFI */
3130 stream_putc(s, SAFI_UNICAST); /* SAFI */
3131
3132 /* Next hop */
Paul Jakmafb982c22007-05-04 20:15:47 +00003133 stream_putc(s, attre->mp_nexthop_len);
3134 stream_put(s, &attre->mp_nexthop_global, 16);
3135 if (attre->mp_nexthop_len == 32)
3136 stream_put(s, &attre->mp_nexthop_local, 16);
paula3845922003-10-18 01:30:50 +00003137
3138 /* SNPA */
3139 stream_putc(s, 0);
3140
3141 /* Prefix */
3142 stream_put_prefix(s, prefix);
3143
3144 /* Set MP attribute length. */
paul9985f832005-02-09 15:51:56 +00003145 stream_putc_at (s, sizep, (stream_get_endp (s) - sizep) - 1);
paula3845922003-10-18 01:30:50 +00003146 }
paula3845922003-10-18 01:30:50 +00003147
paul718e3742002-12-13 20:15:29 +00003148 /* Return total size of attribute. */
paul9985f832005-02-09 15:51:56 +00003149 len = stream_get_endp (s) - cp - 2;
paul718e3742002-12-13 20:15:29 +00003150 stream_putw_at (s, cp, len);
3151}