1 /* BGP attributes management routines.
2 * Copyright (C) 1996, 97, 98, 1999 Kunihiro Ishiguro
4 * This file is part of GNU Zebra.
6 * GNU Zebra is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2, or (at your option) any
11 * GNU Zebra is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; see the file COPYING; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
37 #include "bgpd/bgpd.h"
38 #include "bgpd/bgp_attr.h"
39 #include "bgpd/bgp_route.h"
40 #include "bgpd/bgp_aspath.h"
41 #include "bgpd/bgp_community.h"
42 #include "bgpd/bgp_debug.h"
43 #include "bgpd/bgp_errors.h"
44 #include "bgpd/bgp_label.h"
45 #include "bgpd/bgp_packet.h"
46 #include "bgpd/bgp_ecommunity.h"
47 #include "bgpd/bgp_lcommunity.h"
48 #include "bgpd/bgp_updgrp.h"
49 #include "bgpd/bgp_encap_types.h"
51 #include "bgpd/rfapi/bgp_rfapi_cfg.h"
52 #include "bgp_encap_types.h"
53 #include "bgp_vnc_types.h"
56 #include "bgp_flowspec_private.h"
59 /* Attribute strings for logging. */
60 static const struct message attr_str
[] = {
61 {BGP_ATTR_ORIGIN
, "ORIGIN"},
62 {BGP_ATTR_AS_PATH
, "AS_PATH"},
63 {BGP_ATTR_NEXT_HOP
, "NEXT_HOP"},
64 {BGP_ATTR_MULTI_EXIT_DISC
, "MULTI_EXIT_DISC"},
65 {BGP_ATTR_LOCAL_PREF
, "LOCAL_PREF"},
66 {BGP_ATTR_ATOMIC_AGGREGATE
, "ATOMIC_AGGREGATE"},
67 {BGP_ATTR_AGGREGATOR
, "AGGREGATOR"},
68 {BGP_ATTR_COMMUNITIES
, "COMMUNITY"},
69 {BGP_ATTR_ORIGINATOR_ID
, "ORIGINATOR_ID"},
70 {BGP_ATTR_CLUSTER_LIST
, "CLUSTER_LIST"},
71 {BGP_ATTR_MP_REACH_NLRI
, "MP_REACH_NLRI"},
72 {BGP_ATTR_MP_UNREACH_NLRI
, "MP_UNREACH_NLRI"},
73 {BGP_ATTR_EXT_COMMUNITIES
, "EXT_COMMUNITIES"},
74 {BGP_ATTR_AS4_PATH
, "AS4_PATH"},
75 {BGP_ATTR_AS4_AGGREGATOR
, "AS4_AGGREGATOR"},
76 {BGP_ATTR_AS_PATHLIMIT
, "AS_PATHLIMIT"},
77 {BGP_ATTR_PMSI_TUNNEL
, "PMSI_TUNNEL_ATTRIBUTE"},
78 {BGP_ATTR_ENCAP
, "ENCAP"},
79 #ifdef ENABLE_BGP_VNC_ATTR
80 {BGP_ATTR_VNC
, "VNC"},
82 {BGP_ATTR_LARGE_COMMUNITIES
, "LARGE_COMMUNITY"},
83 {BGP_ATTR_PREFIX_SID
, "PREFIX_SID"},
84 {BGP_ATTR_IPV6_EXT_COMMUNITIES
, "IPV6_EXT_COMMUNITIES"},
87 static const struct message attr_flag_str
[] = {
88 {BGP_ATTR_FLAG_OPTIONAL
, "Optional"},
89 {BGP_ATTR_FLAG_TRANS
, "Transitive"},
90 {BGP_ATTR_FLAG_PARTIAL
, "Partial"},
91 /* bgp_attr_flags_diagnose() relies on this bit being last in
93 {BGP_ATTR_FLAG_EXTLEN
, "Extended Length"},
96 static struct hash
*cluster_hash
;
98 static void *cluster_hash_alloc(void *p
)
100 const struct cluster_list
*val
= (const struct cluster_list
*)p
;
101 struct cluster_list
*cluster
;
103 cluster
= XMALLOC(MTYPE_CLUSTER
, sizeof(struct cluster_list
));
104 cluster
->length
= val
->length
;
106 if (cluster
->length
) {
107 cluster
->list
= XMALLOC(MTYPE_CLUSTER_VAL
, val
->length
);
108 memcpy(cluster
->list
, val
->list
, val
->length
);
110 cluster
->list
= NULL
;
117 /* Cluster list related functions. */
118 static struct cluster_list
*cluster_parse(struct in_addr
*pnt
, int length
)
120 struct cluster_list tmp
= {};
121 struct cluster_list
*cluster
;
124 tmp
.list
= length
== 0 ? NULL
: pnt
;
126 cluster
= hash_get(cluster_hash
, &tmp
, cluster_hash_alloc
);
131 bool cluster_loop_check(struct cluster_list
*cluster
, struct in_addr originator
)
135 for (i
= 0; i
< cluster
->length
/ 4; i
++)
136 if (cluster
->list
[i
].s_addr
== originator
.s_addr
)
141 static unsigned int cluster_hash_key_make(const void *p
)
143 const struct cluster_list
*cluster
= p
;
145 return jhash(cluster
->list
, cluster
->length
, 0);
148 static bool cluster_hash_cmp(const void *p1
, const void *p2
)
150 const struct cluster_list
*cluster1
= p1
;
151 const struct cluster_list
*cluster2
= p2
;
153 if (cluster1
->list
== cluster2
->list
)
156 if (!cluster1
->list
|| !cluster2
->list
)
159 if (cluster1
->length
!= cluster2
->length
)
162 return (memcmp(cluster1
->list
, cluster2
->list
, cluster1
->length
) == 0);
165 static void cluster_free(struct cluster_list
*cluster
)
167 XFREE(MTYPE_CLUSTER_VAL
, cluster
->list
);
168 XFREE(MTYPE_CLUSTER
, cluster
);
171 static struct cluster_list
*cluster_intern(struct cluster_list
*cluster
)
173 struct cluster_list
*find
;
175 find
= hash_get(cluster_hash
, cluster
, cluster_hash_alloc
);
181 static void cluster_unintern(struct cluster_list
**cluster
)
183 if ((*cluster
)->refcnt
)
184 (*cluster
)->refcnt
--;
186 if ((*cluster
)->refcnt
== 0) {
187 void *p
= hash_release(cluster_hash
, *cluster
);
188 assert(p
== *cluster
);
189 cluster_free(*cluster
);
194 static void cluster_init(void)
196 cluster_hash
= hash_create(cluster_hash_key_make
, cluster_hash_cmp
,
200 static void cluster_finish(void)
202 hash_clean(cluster_hash
, (void (*)(void *))cluster_free
);
203 hash_free(cluster_hash
);
207 static struct hash
*encap_hash
= NULL
;
208 #ifdef ENABLE_BGP_VNC
209 static struct hash
*vnc_hash
= NULL
;
211 static struct hash
*srv6_l3vpn_hash
;
212 static struct hash
*srv6_vpn_hash
;
214 struct bgp_attr_encap_subtlv
*encap_tlv_dup(struct bgp_attr_encap_subtlv
*orig
)
216 struct bgp_attr_encap_subtlv
*new;
217 struct bgp_attr_encap_subtlv
*tail
;
218 struct bgp_attr_encap_subtlv
*p
;
220 for (p
= orig
, tail
= new = NULL
; p
; p
= p
->next
) {
221 int size
= sizeof(struct bgp_attr_encap_subtlv
) + p
->length
;
223 tail
->next
= XCALLOC(MTYPE_ENCAP_TLV
, size
);
226 tail
= new = XCALLOC(MTYPE_ENCAP_TLV
, size
);
229 memcpy(tail
, p
, size
);
236 static void encap_free(struct bgp_attr_encap_subtlv
*p
)
238 struct bgp_attr_encap_subtlv
*next
;
242 XFREE(MTYPE_ENCAP_TLV
, p
);
247 void bgp_attr_flush_encap(struct attr
*attr
)
252 if (attr
->encap_subtlvs
) {
253 encap_free(attr
->encap_subtlvs
);
254 attr
->encap_subtlvs
= NULL
;
256 #ifdef ENABLE_BGP_VNC
257 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
258 bgp_attr_get_vnc_subtlvs(attr
);
261 encap_free(vnc_subtlvs
);
262 bgp_attr_set_vnc_subtlvs(attr
, NULL
);
268 * Compare encap sub-tlv chains
273 * This algorithm could be made faster if needed
275 static bool encap_same(const struct bgp_attr_encap_subtlv
*h1
,
276 const struct bgp_attr_encap_subtlv
*h2
)
278 const struct bgp_attr_encap_subtlv
*p
;
279 const struct bgp_attr_encap_subtlv
*q
;
283 if (h1
== NULL
|| h2
== NULL
)
286 for (p
= h1
; p
; p
= p
->next
) {
287 for (q
= h2
; q
; q
= q
->next
) {
288 if ((p
->type
== q
->type
) && (p
->length
== q
->length
)
289 && !memcmp(p
->value
, q
->value
, p
->length
)) {
298 for (p
= h2
; p
; p
= p
->next
) {
299 for (q
= h1
; q
; q
= q
->next
) {
300 if ((p
->type
== q
->type
) && (p
->length
== q
->length
)
301 && !memcmp(p
->value
, q
->value
, p
->length
)) {
313 static void *encap_hash_alloc(void *p
)
315 /* Encap structure is already allocated. */
321 #ifdef ENABLE_BGP_VNC
326 static struct bgp_attr_encap_subtlv
*
327 encap_intern(struct bgp_attr_encap_subtlv
*encap
, encap_subtlv_type type
)
329 struct bgp_attr_encap_subtlv
*find
;
330 struct hash
*hash
= encap_hash
;
331 #ifdef ENABLE_BGP_VNC
332 if (type
== VNC_SUBTLV_TYPE
)
336 find
= hash_get(hash
, encap
, encap_hash_alloc
);
344 static void encap_unintern(struct bgp_attr_encap_subtlv
**encapp
,
345 encap_subtlv_type type
)
347 struct bgp_attr_encap_subtlv
*encap
= *encapp
;
351 if (encap
->refcnt
== 0) {
352 struct hash
*hash
= encap_hash
;
353 #ifdef ENABLE_BGP_VNC
354 if (type
== VNC_SUBTLV_TYPE
)
357 hash_release(hash
, encap
);
363 static unsigned int encap_hash_key_make(const void *p
)
365 const struct bgp_attr_encap_subtlv
*encap
= p
;
367 return jhash(encap
->value
, encap
->length
, 0);
370 static bool encap_hash_cmp(const void *p1
, const void *p2
)
372 return encap_same((const struct bgp_attr_encap_subtlv
*)p1
,
373 (const struct bgp_attr_encap_subtlv
*)p2
);
376 static void encap_init(void)
378 encap_hash
= hash_create(encap_hash_key_make
, encap_hash_cmp
,
380 #ifdef ENABLE_BGP_VNC
381 vnc_hash
= hash_create(encap_hash_key_make
, encap_hash_cmp
,
386 static void encap_finish(void)
388 hash_clean(encap_hash
, (void (*)(void *))encap_free
);
389 hash_free(encap_hash
);
391 #ifdef ENABLE_BGP_VNC
392 hash_clean(vnc_hash
, (void (*)(void *))encap_free
);
398 static bool overlay_index_same(const struct attr
*a1
, const struct attr
*a2
)
407 return bgp_route_evpn_same(bgp_attr_get_evpn_overlay(a1
),
408 bgp_attr_get_evpn_overlay(a2
));
411 /* Unknown transit attribute. */
412 static struct hash
*transit_hash
;
414 static void transit_free(struct transit
*transit
)
416 XFREE(MTYPE_TRANSIT_VAL
, transit
->val
);
417 XFREE(MTYPE_TRANSIT
, transit
);
420 static void *transit_hash_alloc(void *p
)
422 /* Transit structure is already allocated. */
426 static struct transit
*transit_intern(struct transit
*transit
)
428 struct transit
*find
;
430 find
= hash_get(transit_hash
, transit
, transit_hash_alloc
);
432 transit_free(transit
);
438 static void transit_unintern(struct transit
**transit
)
440 if ((*transit
)->refcnt
)
441 (*transit
)->refcnt
--;
443 if ((*transit
)->refcnt
== 0) {
444 hash_release(transit_hash
, *transit
);
445 transit_free(*transit
);
450 static void *srv6_l3vpn_hash_alloc(void *p
)
455 static void srv6_l3vpn_free(struct bgp_attr_srv6_l3vpn
*l3vpn
)
457 XFREE(MTYPE_BGP_SRV6_L3VPN
, l3vpn
);
460 static struct bgp_attr_srv6_l3vpn
*
461 srv6_l3vpn_intern(struct bgp_attr_srv6_l3vpn
*l3vpn
)
463 struct bgp_attr_srv6_l3vpn
*find
;
465 find
= hash_get(srv6_l3vpn_hash
, l3vpn
, srv6_l3vpn_hash_alloc
);
467 srv6_l3vpn_free(l3vpn
);
472 static void srv6_l3vpn_unintern(struct bgp_attr_srv6_l3vpn
**l3vpnp
)
474 struct bgp_attr_srv6_l3vpn
*l3vpn
= *l3vpnp
;
479 if (l3vpn
->refcnt
== 0) {
480 hash_release(srv6_l3vpn_hash
, l3vpn
);
481 srv6_l3vpn_free(l3vpn
);
486 static void *srv6_vpn_hash_alloc(void *p
)
491 static void srv6_vpn_free(struct bgp_attr_srv6_vpn
*vpn
)
493 XFREE(MTYPE_BGP_SRV6_VPN
, vpn
);
496 static struct bgp_attr_srv6_vpn
*srv6_vpn_intern(struct bgp_attr_srv6_vpn
*vpn
)
498 struct bgp_attr_srv6_vpn
*find
;
500 find
= hash_get(srv6_vpn_hash
, vpn
, srv6_vpn_hash_alloc
);
507 static void srv6_vpn_unintern(struct bgp_attr_srv6_vpn
**vpnp
)
509 struct bgp_attr_srv6_vpn
*vpn
= *vpnp
;
514 if (vpn
->refcnt
== 0) {
515 hash_release(srv6_vpn_hash
, vpn
);
521 static uint32_t srv6_l3vpn_hash_key_make(const void *p
)
523 const struct bgp_attr_srv6_l3vpn
*l3vpn
= p
;
526 key
= jhash(&l3vpn
->sid
, 16, key
);
527 key
= jhash_1word(l3vpn
->sid_flags
, key
);
528 key
= jhash_1word(l3vpn
->endpoint_behavior
, key
);
529 key
= jhash_1word(l3vpn
->loc_block_len
, key
);
530 key
= jhash_1word(l3vpn
->loc_node_len
, key
);
531 key
= jhash_1word(l3vpn
->func_len
, key
);
532 key
= jhash_1word(l3vpn
->arg_len
, key
);
533 key
= jhash_1word(l3vpn
->transposition_len
, key
);
534 key
= jhash_1word(l3vpn
->transposition_offset
, key
);
538 static bool srv6_l3vpn_hash_cmp(const void *p1
, const void *p2
)
540 const struct bgp_attr_srv6_l3vpn
*l3vpn1
= p1
;
541 const struct bgp_attr_srv6_l3vpn
*l3vpn2
= p2
;
543 return sid_same(&l3vpn1
->sid
, &l3vpn2
->sid
)
544 && l3vpn1
->sid_flags
== l3vpn2
->sid_flags
545 && l3vpn1
->endpoint_behavior
== l3vpn2
->endpoint_behavior
546 && l3vpn1
->loc_block_len
== l3vpn2
->loc_block_len
547 && l3vpn1
->loc_node_len
== l3vpn2
->loc_node_len
548 && l3vpn1
->func_len
== l3vpn2
->func_len
549 && l3vpn1
->arg_len
== l3vpn2
->arg_len
550 && l3vpn1
->transposition_len
== l3vpn2
->transposition_len
551 && l3vpn1
->transposition_offset
== l3vpn2
->transposition_offset
;
554 static bool srv6_l3vpn_same(const struct bgp_attr_srv6_l3vpn
*h1
,
555 const struct bgp_attr_srv6_l3vpn
*h2
)
559 else if (h1
== NULL
|| h2
== NULL
)
562 return srv6_l3vpn_hash_cmp((const void *)h1
, (const void *)h2
);
565 static unsigned int srv6_vpn_hash_key_make(const void *p
)
567 const struct bgp_attr_srv6_vpn
*vpn
= p
;
570 key
= jhash(&vpn
->sid
, 16, key
);
571 key
= jhash_1word(vpn
->sid_flags
, key
);
575 static bool srv6_vpn_hash_cmp(const void *p1
, const void *p2
)
577 const struct bgp_attr_srv6_vpn
*vpn1
= p1
;
578 const struct bgp_attr_srv6_vpn
*vpn2
= p2
;
580 return sid_same(&vpn1
->sid
, &vpn2
->sid
)
581 && vpn1
->sid_flags
== vpn2
->sid_flags
;
584 static bool srv6_vpn_same(const struct bgp_attr_srv6_vpn
*h1
,
585 const struct bgp_attr_srv6_vpn
*h2
)
589 else if (h1
== NULL
|| h2
== NULL
)
592 return srv6_vpn_hash_cmp((const void *)h1
, (const void *)h2
);
595 static void srv6_init(void)
598 hash_create(srv6_l3vpn_hash_key_make
, srv6_l3vpn_hash_cmp
,
599 "BGP Prefix-SID SRv6-L3VPN-Service-TLV");
600 srv6_vpn_hash
= hash_create(srv6_vpn_hash_key_make
, srv6_vpn_hash_cmp
,
601 "BGP Prefix-SID SRv6-VPN-Service-TLV");
604 static void srv6_finish(void)
606 hash_clean(srv6_l3vpn_hash
, (void (*)(void *))srv6_l3vpn_free
);
607 hash_free(srv6_l3vpn_hash
);
608 srv6_l3vpn_hash
= NULL
;
609 hash_clean(srv6_vpn_hash
, (void (*)(void *))srv6_vpn_free
);
610 hash_free(srv6_vpn_hash
);
611 srv6_vpn_hash
= NULL
;
614 static unsigned int transit_hash_key_make(const void *p
)
616 const struct transit
*transit
= p
;
618 return jhash(transit
->val
, transit
->length
, 0);
621 static bool transit_hash_cmp(const void *p1
, const void *p2
)
623 const struct transit
*transit1
= p1
;
624 const struct transit
*transit2
= p2
;
626 return (transit1
->length
== transit2
->length
627 && memcmp(transit1
->val
, transit2
->val
, transit1
->length
) == 0);
630 static void transit_init(void)
632 transit_hash
= hash_create(transit_hash_key_make
, transit_hash_cmp
,
636 static void transit_finish(void)
638 hash_clean(transit_hash
, (void (*)(void *))transit_free
);
639 hash_free(transit_hash
);
643 /* Attribute hash routines. */
644 static struct hash
*attrhash
;
646 unsigned long int attr_count(void)
648 return attrhash
->count
;
651 unsigned long int attr_unknown_count(void)
653 return transit_hash
->count
;
656 unsigned int attrhash_key_make(const void *p
)
658 const struct attr
*attr
= (struct attr
*)p
;
660 #define MIX(val) key = jhash_1word(val, key)
661 #define MIX3(a, b, c) key = jhash_3words((a), (b), (c), key)
663 MIX3(attr
->origin
, attr
->nexthop
.s_addr
, attr
->med
);
664 MIX3(attr
->local_pref
, attr
->aggregator_as
,
665 attr
->aggregator_addr
.s_addr
);
666 MIX3(attr
->weight
, attr
->mp_nexthop_global_in
.s_addr
,
667 attr
->originator_id
.s_addr
);
668 MIX3(attr
->tag
, attr
->label
, attr
->label_index
);
671 MIX(aspath_key_make(attr
->aspath
));
672 if (bgp_attr_get_community(attr
))
673 MIX(community_hash_make(bgp_attr_get_community(attr
)));
674 if (bgp_attr_get_lcommunity(attr
))
675 MIX(lcommunity_hash_make(bgp_attr_get_lcommunity(attr
)));
676 if (bgp_attr_get_ecommunity(attr
))
677 MIX(ecommunity_hash_make(bgp_attr_get_ecommunity(attr
)));
678 if (bgp_attr_get_ipv6_ecommunity(attr
))
679 MIX(ecommunity_hash_make(bgp_attr_get_ipv6_ecommunity(attr
)));
680 if (bgp_attr_get_cluster(attr
))
681 MIX(cluster_hash_key_make(bgp_attr_get_cluster(attr
)));
682 if (bgp_attr_get_transit(attr
))
683 MIX(transit_hash_key_make(bgp_attr_get_transit(attr
)));
684 if (attr
->encap_subtlvs
)
685 MIX(encap_hash_key_make(attr
->encap_subtlvs
));
686 if (attr
->srv6_l3vpn
)
687 MIX(srv6_l3vpn_hash_key_make(attr
->srv6_l3vpn
));
689 MIX(srv6_vpn_hash_key_make(attr
->srv6_vpn
));
690 #ifdef ENABLE_BGP_VNC
691 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
692 bgp_attr_get_vnc_subtlvs(attr
);
694 MIX(encap_hash_key_make(vnc_subtlvs
));
696 MIX(attr
->mp_nexthop_len
);
697 key
= jhash(attr
->mp_nexthop_global
.s6_addr
, IPV6_MAX_BYTELEN
, key
);
698 key
= jhash(attr
->mp_nexthop_local
.s6_addr
, IPV6_MAX_BYTELEN
, key
);
699 MIX3(attr
->nh_ifindex
, attr
->nh_lla_ifindex
, attr
->distance
);
700 MIX(attr
->rmap_table_id
);
707 bool attrhash_cmp(const void *p1
, const void *p2
)
709 const struct attr
*attr1
= p1
;
710 const struct attr
*attr2
= p2
;
712 if (attr1
->flag
== attr2
->flag
&& attr1
->origin
== attr2
->origin
713 && attr1
->nexthop
.s_addr
== attr2
->nexthop
.s_addr
714 && attr1
->aspath
== attr2
->aspath
715 && bgp_attr_get_community(attr1
)
716 == bgp_attr_get_community(attr2
)
717 && attr1
->med
== attr2
->med
718 && attr1
->local_pref
== attr2
->local_pref
719 && attr1
->rmap_change_flags
== attr2
->rmap_change_flags
) {
720 if (attr1
->aggregator_as
== attr2
->aggregator_as
721 && attr1
->aggregator_addr
.s_addr
722 == attr2
->aggregator_addr
.s_addr
723 && attr1
->weight
== attr2
->weight
724 && attr1
->tag
== attr2
->tag
725 && attr1
->label_index
== attr2
->label_index
726 && attr1
->mp_nexthop_len
== attr2
->mp_nexthop_len
727 && bgp_attr_get_ecommunity(attr1
)
728 == bgp_attr_get_ecommunity(attr2
)
729 && bgp_attr_get_ipv6_ecommunity(attr1
)
730 == bgp_attr_get_ipv6_ecommunity(attr2
)
731 && bgp_attr_get_lcommunity(attr1
)
732 == bgp_attr_get_lcommunity(attr2
)
733 && bgp_attr_get_cluster(attr1
)
734 == bgp_attr_get_cluster(attr2
)
735 && bgp_attr_get_transit(attr1
)
736 == bgp_attr_get_transit(attr2
)
737 && attr1
->rmap_table_id
== attr2
->rmap_table_id
738 && (attr1
->encap_tunneltype
== attr2
->encap_tunneltype
)
739 && encap_same(attr1
->encap_subtlvs
, attr2
->encap_subtlvs
)
740 #ifdef ENABLE_BGP_VNC
741 && encap_same(bgp_attr_get_vnc_subtlvs(attr1
),
742 bgp_attr_get_vnc_subtlvs(attr2
))
744 && IPV6_ADDR_SAME(&attr1
->mp_nexthop_global
,
745 &attr2
->mp_nexthop_global
)
746 && IPV6_ADDR_SAME(&attr1
->mp_nexthop_local
,
747 &attr2
->mp_nexthop_local
)
748 && IPV4_ADDR_SAME(&attr1
->mp_nexthop_global_in
,
749 &attr2
->mp_nexthop_global_in
)
750 && IPV4_ADDR_SAME(&attr1
->originator_id
,
751 &attr2
->originator_id
)
752 && overlay_index_same(attr1
, attr2
)
753 && !memcmp(&attr1
->esi
, &attr2
->esi
, sizeof(esi_t
))
754 && attr1
->es_flags
== attr2
->es_flags
755 && attr1
->mm_sync_seqnum
== attr2
->mm_sync_seqnum
756 && attr1
->df_pref
== attr2
->df_pref
757 && attr1
->df_alg
== attr2
->df_alg
758 && attr1
->nh_ifindex
== attr2
->nh_ifindex
759 && attr1
->nh_lla_ifindex
== attr2
->nh_lla_ifindex
760 && attr1
->distance
== attr2
->distance
761 && srv6_l3vpn_same(attr1
->srv6_l3vpn
, attr2
->srv6_l3vpn
)
762 && srv6_vpn_same(attr1
->srv6_vpn
, attr2
->srv6_vpn
)
763 && attr1
->srte_color
== attr2
->srte_color
764 && attr1
->nh_type
== attr2
->nh_type
765 && attr1
->bh_type
== attr2
->bh_type
)
772 static void attrhash_init(void)
775 hash_create(attrhash_key_make
, attrhash_cmp
, "BGP Attributes");
779 * special for hash_clean below
781 static void attr_vfree(void *attr
)
783 XFREE(MTYPE_ATTR
, attr
);
786 static void attrhash_finish(void)
788 hash_clean(attrhash
, attr_vfree
);
793 static void attr_show_all_iterator(struct hash_bucket
*bucket
, struct vty
*vty
)
795 struct attr
*attr
= bucket
->data
;
796 char sid_str
[BUFSIZ
];
798 vty_out(vty
, "attr[%ld] nexthop %pI4\n", attr
->refcnt
, &attr
->nexthop
);
801 if (attr
->srv6_l3vpn
)
802 inet_ntop(AF_INET6
, &attr
->srv6_l3vpn
->sid
, sid_str
, BUFSIZ
);
803 else if (attr
->srv6_vpn
)
804 inet_ntop(AF_INET6
, &attr
->srv6_vpn
->sid
, sid_str
, BUFSIZ
);
807 "\tflags: %" PRIu64
" distance: %u med: %u local_pref: %u origin: %u weight: %u label: %u sid: %s\n",
808 attr
->flag
, attr
->distance
, attr
->med
, attr
->local_pref
,
809 attr
->origin
, attr
->weight
, attr
->label
, sid_str
);
812 void attr_show_all(struct vty
*vty
)
814 hash_iterate(attrhash
, (void (*)(struct hash_bucket
*,
815 void *))attr_show_all_iterator
,
819 static void *bgp_attr_hash_alloc(void *p
)
821 struct attr
*val
= (struct attr
*)p
;
824 attr
= XMALLOC(MTYPE_ATTR
, sizeof(struct attr
));
826 if (val
->encap_subtlvs
) {
827 val
->encap_subtlvs
= NULL
;
829 #ifdef ENABLE_BGP_VNC
830 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
831 bgp_attr_get_vnc_subtlvs(val
);
834 bgp_attr_set_vnc_subtlvs(val
, NULL
);
841 /* Internet argument attribute. */
842 struct attr
*bgp_attr_intern(struct attr
*attr
)
845 struct ecommunity
*ecomm
= NULL
;
846 struct ecommunity
*ipv6_ecomm
= NULL
;
847 struct lcommunity
*lcomm
= NULL
;
848 struct community
*comm
= NULL
;
850 /* Intern referenced strucutre. */
852 if (!attr
->aspath
->refcnt
)
853 attr
->aspath
= aspath_intern(attr
->aspath
);
855 attr
->aspath
->refcnt
++;
858 comm
= bgp_attr_get_community(attr
);
861 bgp_attr_set_community(attr
, community_intern(comm
));
866 ecomm
= bgp_attr_get_ecommunity(attr
);
869 bgp_attr_set_ecommunity(attr
, ecommunity_intern(ecomm
));
874 ipv6_ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
876 if (!ipv6_ecomm
->refcnt
)
877 bgp_attr_set_ipv6_ecommunity(
878 attr
, ecommunity_intern(ipv6_ecomm
));
880 ipv6_ecomm
->refcnt
++;
883 lcomm
= bgp_attr_get_lcommunity(attr
);
886 bgp_attr_set_lcommunity(attr
, lcommunity_intern(lcomm
));
891 struct cluster_list
*cluster
= bgp_attr_get_cluster(attr
);
894 if (!cluster
->refcnt
)
895 bgp_attr_set_cluster(attr
, cluster_intern(cluster
));
900 struct transit
*transit
= bgp_attr_get_transit(attr
);
903 if (!transit
->refcnt
)
904 bgp_attr_set_transit(attr
, transit_intern(transit
));
908 if (attr
->encap_subtlvs
) {
909 if (!attr
->encap_subtlvs
->refcnt
)
910 attr
->encap_subtlvs
= encap_intern(attr
->encap_subtlvs
,
913 attr
->encap_subtlvs
->refcnt
++;
915 if (attr
->srv6_l3vpn
) {
916 if (!attr
->srv6_l3vpn
->refcnt
)
917 attr
->srv6_l3vpn
= srv6_l3vpn_intern(attr
->srv6_l3vpn
);
919 attr
->srv6_l3vpn
->refcnt
++;
921 if (attr
->srv6_vpn
) {
922 if (!attr
->srv6_vpn
->refcnt
)
923 attr
->srv6_vpn
= srv6_vpn_intern(attr
->srv6_vpn
);
925 attr
->srv6_vpn
->refcnt
++;
927 #ifdef ENABLE_BGP_VNC
928 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
929 bgp_attr_get_vnc_subtlvs(attr
);
932 if (!vnc_subtlvs
->refcnt
)
933 bgp_attr_set_vnc_subtlvs(
935 encap_intern(vnc_subtlvs
, VNC_SUBTLV_TYPE
));
937 vnc_subtlvs
->refcnt
++;
941 /* At this point, attr only contains intern'd pointers. that means
942 * if we find it in attrhash, it has all the same pointers and we
943 * correctly updated the refcounts on these.
944 * If we don't find it, we need to allocate a one because in all
945 * cases this returns a new reference to a hashed attr, but the input
947 find
= (struct attr
*)hash_get(attrhash
, attr
, bgp_attr_hash_alloc
);
953 /* Make network statement's attribute. */
954 struct attr
*bgp_attr_default_set(struct attr
*attr
, uint8_t origin
)
956 memset(attr
, 0, sizeof(struct attr
));
958 attr
->origin
= origin
;
959 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
960 attr
->aspath
= aspath_empty();
961 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
962 attr
->weight
= BGP_ATTR_DEFAULT_WEIGHT
;
964 attr
->label_index
= BGP_INVALID_LABEL_INDEX
;
965 attr
->label
= MPLS_INVALID_LABEL
;
966 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
967 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
972 /* Create the attributes for an aggregate */
973 struct attr
*bgp_attr_aggregate_intern(
974 struct bgp
*bgp
, uint8_t origin
, struct aspath
*aspath
,
975 struct community
*community
, struct ecommunity
*ecommunity
,
976 struct lcommunity
*lcommunity
, struct bgp_aggregate
*aggregate
,
977 uint8_t atomic_aggregate
, const struct prefix
*p
)
983 memset(&attr
, 0, sizeof(struct attr
));
985 /* Origin attribute. */
986 attr
.origin
= origin
;
987 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
989 /* AS path attribute. */
991 attr
.aspath
= aspath_intern(aspath
);
993 attr
.aspath
= aspath_empty();
994 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
996 /* Next hop attribute. */
997 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
1000 uint32_t gshut
= COMMUNITY_GSHUT
;
1002 /* If we are not shutting down ourselves and we are
1003 * aggregating a route that contains the GSHUT community we
1004 * need to remove that community when creating the aggregate */
1005 if (!bgp_in_graceful_shutdown(bgp
)
1006 && community_include(community
, gshut
)) {
1007 community_del_val(community
, &gshut
);
1010 bgp_attr_set_community(&attr
, community
);
1014 bgp_attr_set_ecommunity(&attr
, ecommunity
);
1015 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
1019 bgp_attr_set_lcommunity(&attr
, lcommunity
);
1021 if (bgp_in_graceful_shutdown(bgp
))
1022 bgp_attr_add_gshut_community(&attr
);
1024 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1025 attr
.label
= MPLS_INVALID_LABEL
;
1026 attr
.weight
= BGP_ATTR_DEFAULT_WEIGHT
;
1027 attr
.mp_nexthop_len
= IPV6_MAX_BYTELEN
;
1028 if (!aggregate
->as_set
|| atomic_aggregate
)
1029 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
);
1030 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
);
1031 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
))
1032 attr
.aggregator_as
= bgp
->confed_id
;
1034 attr
.aggregator_as
= bgp
->as
;
1035 attr
.aggregator_addr
= bgp
->router_id
;
1036 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1037 attr
.label
= MPLS_INVALID_LABEL
;
1039 /* Apply route-map */
1040 if (aggregate
->rmap
.name
) {
1041 struct attr attr_tmp
= attr
;
1042 struct bgp_path_info rmap_path
;
1044 memset(&rmap_path
, 0, sizeof(struct bgp_path_info
));
1045 rmap_path
.peer
= bgp
->peer_self
;
1046 rmap_path
.attr
= &attr_tmp
;
1048 SET_FLAG(bgp
->peer_self
->rmap_type
, PEER_RMAP_TYPE_AGGREGATE
);
1050 ret
= route_map_apply(aggregate
->rmap
.map
, p
, &rmap_path
);
1052 bgp
->peer_self
->rmap_type
= 0;
1054 if (ret
== RMAP_DENYMATCH
) {
1055 /* Free uninterned attribute. */
1056 bgp_attr_flush(&attr_tmp
);
1058 /* Unintern original. */
1059 aspath_unintern(&attr
.aspath
);
1063 if (bgp_in_graceful_shutdown(bgp
))
1064 bgp_attr_add_gshut_community(&attr_tmp
);
1066 new = bgp_attr_intern(&attr_tmp
);
1069 if (bgp_in_graceful_shutdown(bgp
))
1070 bgp_attr_add_gshut_community(&attr
);
1072 new = bgp_attr_intern(&attr
);
1075 /* Always release the 'intern()'ed AS Path. */
1076 aspath_unintern(&attr
.aspath
);
1081 /* Unintern just the sub-components of the attr, but not the attr */
1082 void bgp_attr_unintern_sub(struct attr
*attr
)
1084 struct ecommunity
*ecomm
= NULL
;
1085 struct ecommunity
*ipv6_ecomm
= NULL
;
1086 struct cluster_list
*cluster
;
1087 struct lcommunity
*lcomm
= NULL
;
1088 struct community
*comm
= NULL
;
1090 /* aspath refcount shoud be decrement. */
1091 aspath_unintern(&attr
->aspath
);
1092 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
));
1094 comm
= bgp_attr_get_community(attr
);
1095 community_unintern(&comm
);
1096 bgp_attr_set_community(attr
, NULL
);
1098 ecomm
= bgp_attr_get_ecommunity(attr
);
1099 ecommunity_unintern(&ecomm
);
1100 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
));
1101 bgp_attr_set_ecommunity(attr
, NULL
);
1103 ipv6_ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
1104 ecommunity_unintern(&ipv6_ecomm
);
1105 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_IPV6_EXT_COMMUNITIES
));
1106 bgp_attr_set_ipv6_ecommunity(attr
, NULL
);
1108 lcomm
= bgp_attr_get_lcommunity(attr
);
1109 lcommunity_unintern(&lcomm
);
1110 bgp_attr_set_lcommunity(attr
, NULL
);
1112 cluster
= bgp_attr_get_cluster(attr
);
1114 cluster_unintern(&cluster
);
1115 bgp_attr_set_cluster(attr
, cluster
);
1117 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST
));
1119 struct transit
*transit
= bgp_attr_get_transit(attr
);
1122 transit_unintern(&transit
);
1123 bgp_attr_set_transit(attr
, transit
);
1126 if (attr
->encap_subtlvs
)
1127 encap_unintern(&attr
->encap_subtlvs
, ENCAP_SUBTLV_TYPE
);
1129 #ifdef ENABLE_BGP_VNC
1130 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
1131 bgp_attr_get_vnc_subtlvs(attr
);
1134 encap_unintern(&vnc_subtlvs
, VNC_SUBTLV_TYPE
);
1135 bgp_attr_set_vnc_subtlvs(attr
, vnc_subtlvs
);
1139 if (attr
->srv6_l3vpn
)
1140 srv6_l3vpn_unintern(&attr
->srv6_l3vpn
);
1143 srv6_vpn_unintern(&attr
->srv6_vpn
);
1146 /* Free bgp attribute and aspath. */
1147 void bgp_attr_unintern(struct attr
**pattr
)
1149 struct attr
*attr
= *pattr
;
1153 /* Decrement attribute reference. */
1158 /* If reference becomes zero then free attribute object. */
1159 if (attr
->refcnt
== 0) {
1160 ret
= hash_release(attrhash
, attr
);
1161 assert(ret
!= NULL
);
1162 XFREE(MTYPE_ATTR
, attr
);
1166 bgp_attr_unintern_sub(&tmp
);
1169 void bgp_attr_flush(struct attr
*attr
)
1171 struct ecommunity
*ecomm
;
1172 struct ecommunity
*ipv6_ecomm
;
1173 struct cluster_list
*cluster
;
1174 struct lcommunity
*lcomm
;
1175 struct community
*comm
;
1177 if (attr
->aspath
&& !attr
->aspath
->refcnt
) {
1178 aspath_free(attr
->aspath
);
1179 attr
->aspath
= NULL
;
1181 comm
= bgp_attr_get_community(attr
);
1182 if (comm
&& !comm
->refcnt
)
1183 community_free(&comm
);
1184 bgp_attr_set_community(attr
, NULL
);
1186 ecomm
= bgp_attr_get_ecommunity(attr
);
1187 if (ecomm
&& !ecomm
->refcnt
)
1188 ecommunity_free(&ecomm
);
1189 bgp_attr_set_ecommunity(attr
, NULL
);
1191 ipv6_ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
1192 if (ipv6_ecomm
&& !ipv6_ecomm
->refcnt
)
1193 ecommunity_free(&ipv6_ecomm
);
1194 bgp_attr_set_ipv6_ecommunity(attr
, NULL
);
1196 lcomm
= bgp_attr_get_lcommunity(attr
);
1197 if (lcomm
&& !lcomm
->refcnt
)
1198 lcommunity_free(&lcomm
);
1199 bgp_attr_set_lcommunity(attr
, NULL
);
1201 cluster
= bgp_attr_get_cluster(attr
);
1202 if (cluster
&& !cluster
->refcnt
) {
1203 cluster_free(cluster
);
1204 bgp_attr_set_cluster(attr
, NULL
);
1207 struct transit
*transit
= bgp_attr_get_transit(attr
);
1209 if (transit
&& !transit
->refcnt
) {
1210 transit_free(transit
);
1211 bgp_attr_set_transit(attr
, NULL
);
1213 if (attr
->encap_subtlvs
&& !attr
->encap_subtlvs
->refcnt
) {
1214 encap_free(attr
->encap_subtlvs
);
1215 attr
->encap_subtlvs
= NULL
;
1217 if (attr
->srv6_l3vpn
&& !attr
->srv6_l3vpn
->refcnt
) {
1218 srv6_l3vpn_free(attr
->srv6_l3vpn
);
1219 attr
->srv6_l3vpn
= NULL
;
1221 if (attr
->srv6_vpn
&& !attr
->srv6_vpn
->refcnt
) {
1222 srv6_vpn_free(attr
->srv6_vpn
);
1223 attr
->srv6_vpn
= NULL
;
1225 #ifdef ENABLE_BGP_VNC
1226 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
1227 bgp_attr_get_vnc_subtlvs(attr
);
1229 if (vnc_subtlvs
&& !vnc_subtlvs
->refcnt
) {
1230 encap_free(vnc_subtlvs
);
1231 bgp_attr_set_vnc_subtlvs(attr
, NULL
);
1236 /* Implement draft-scudder-idr-optional-transitive behaviour and
1237 * avoid resetting sessions for malformed attributes which are
1238 * are partial/optional and hence where the error likely was not
1239 * introduced by the sending neighbour.
1241 static bgp_attr_parse_ret_t
1242 bgp_attr_malformed(struct bgp_attr_parser_args
*args
, uint8_t subcode
,
1245 struct peer
*const peer
= args
->peer
;
1246 struct attr
*const attr
= args
->attr
;
1247 const uint8_t flags
= args
->flags
;
1248 /* startp and length must be special-cased, as whether or not to
1249 * send the attribute data with the NOTIFY depends on the error,
1250 * the caller therefore signals this with the seperate length argument
1252 uint8_t *notify_datap
= (length
> 0 ? args
->startp
: NULL
);
1254 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1255 char attr_str
[BUFSIZ
] = {0};
1257 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1259 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1262 /* Only relax error handling for eBGP peers */
1263 if (peer
->sort
!= BGP_PEER_EBGP
) {
1264 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
, subcode
,
1265 notify_datap
, length
);
1266 return BGP_ATTR_PARSE_ERROR
;
1269 /* Adjust the stream getp to the end of the attribute, in case we can
1270 * still proceed but the caller hasn't read all the attribute.
1272 stream_set_getp(BGP_INPUT(peer
),
1273 (args
->startp
- STREAM_DATA(BGP_INPUT(peer
)))
1276 switch (args
->type
) {
1277 /* where an attribute is relatively inconsequential, e.g. it does not
1278 * affect route selection, and can be safely ignored, then any such
1279 * attributes which are malformed should just be ignored and the route
1280 * processed as normal.
1282 case BGP_ATTR_AS4_AGGREGATOR
:
1283 case BGP_ATTR_AGGREGATOR
:
1284 case BGP_ATTR_ATOMIC_AGGREGATE
:
1285 return BGP_ATTR_PARSE_PROCEED
;
1287 /* Core attributes, particularly ones which may influence route
1288 * selection, should be treat-as-withdraw.
1290 case BGP_ATTR_ORIGIN
:
1291 case BGP_ATTR_AS_PATH
:
1292 case BGP_ATTR_NEXT_HOP
:
1293 case BGP_ATTR_MULTI_EXIT_DISC
:
1294 case BGP_ATTR_LOCAL_PREF
:
1295 case BGP_ATTR_COMMUNITIES
:
1296 case BGP_ATTR_EXT_COMMUNITIES
:
1297 case BGP_ATTR_IPV6_EXT_COMMUNITIES
:
1298 case BGP_ATTR_LARGE_COMMUNITIES
:
1299 case BGP_ATTR_ORIGINATOR_ID
:
1300 case BGP_ATTR_CLUSTER_LIST
:
1301 return BGP_ATTR_PARSE_WITHDRAW
;
1302 case BGP_ATTR_MP_REACH_NLRI
:
1303 case BGP_ATTR_MP_UNREACH_NLRI
:
1304 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
, subcode
,
1305 notify_datap
, length
);
1306 return BGP_ATTR_PARSE_ERROR
;
1309 /* Partial optional attributes that are malformed should not cause
1310 * the whole session to be reset. Instead treat it as a withdrawal
1311 * of the routes, if possible.
1313 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
)
1314 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1315 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_PARTIAL
))
1316 return BGP_ATTR_PARSE_WITHDRAW
;
1318 /* default to reset */
1319 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
1322 /* Find out what is wrong with the path attribute flag bits and log the error.
1323 "Flag bits" here stand for Optional, Transitive and Partial, but not for
1324 Extended Length. Checking O/T/P bits at once implies, that the attribute
1325 being diagnosed is defined by RFC as either a "well-known" or an "optional,
1326 non-transitive" attribute. */
1328 bgp_attr_flags_diagnose(struct bgp_attr_parser_args
*args
,
1329 uint8_t desired_flags
/* how RFC says it must be */
1332 uint8_t seen
= 0, i
;
1333 uint8_t real_flags
= args
->flags
;
1334 const uint8_t attr_code
= args
->type
;
1336 desired_flags
&= ~BGP_ATTR_FLAG_EXTLEN
;
1337 real_flags
&= ~BGP_ATTR_FLAG_EXTLEN
;
1338 for (i
= 0; i
<= 2; i
++) /* O,T,P, but not E */
1339 if (CHECK_FLAG(desired_flags
, attr_flag_str
[i
].key
)
1340 != CHECK_FLAG(real_flags
, attr_flag_str
[i
].key
)) {
1341 flog_err(EC_BGP_ATTR_FLAG
,
1342 "%s attribute must%s be flagged as \"%s\"",
1343 lookup_msg(attr_str
, attr_code
, NULL
),
1344 CHECK_FLAG(desired_flags
, attr_flag_str
[i
].key
)
1347 attr_flag_str
[i
].str
);
1352 "Strange, %s called for attr %s, but no problem found with flags (real flags 0x%x, desired 0x%x)",
1353 __func__
, lookup_msg(attr_str
, attr_code
, NULL
),
1354 real_flags
, desired_flags
);
1358 /* Required flags for attributes. EXTLEN will be masked off when testing,
1359 * as will PARTIAL for optional+transitive attributes.
1361 const uint8_t attr_flags_values
[] = {
1362 [BGP_ATTR_ORIGIN
] = BGP_ATTR_FLAG_TRANS
,
1363 [BGP_ATTR_AS_PATH
] = BGP_ATTR_FLAG_TRANS
,
1364 [BGP_ATTR_NEXT_HOP
] = BGP_ATTR_FLAG_TRANS
,
1365 [BGP_ATTR_MULTI_EXIT_DISC
] = BGP_ATTR_FLAG_OPTIONAL
,
1366 [BGP_ATTR_LOCAL_PREF
] = BGP_ATTR_FLAG_TRANS
,
1367 [BGP_ATTR_ATOMIC_AGGREGATE
] = BGP_ATTR_FLAG_TRANS
,
1368 [BGP_ATTR_AGGREGATOR
] = BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
,
1369 [BGP_ATTR_COMMUNITIES
] = BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
,
1370 [BGP_ATTR_ORIGINATOR_ID
] = BGP_ATTR_FLAG_OPTIONAL
,
1371 [BGP_ATTR_CLUSTER_LIST
] = BGP_ATTR_FLAG_OPTIONAL
,
1372 [BGP_ATTR_MP_REACH_NLRI
] = BGP_ATTR_FLAG_OPTIONAL
,
1373 [BGP_ATTR_MP_UNREACH_NLRI
] = BGP_ATTR_FLAG_OPTIONAL
,
1374 [BGP_ATTR_EXT_COMMUNITIES
] =
1375 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1376 [BGP_ATTR_AS4_PATH
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1377 [BGP_ATTR_AS4_AGGREGATOR
] =
1378 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1379 [BGP_ATTR_PMSI_TUNNEL
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1380 [BGP_ATTR_LARGE_COMMUNITIES
] =
1381 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1382 [BGP_ATTR_PREFIX_SID
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1383 [BGP_ATTR_IPV6_EXT_COMMUNITIES
] =
1384 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1386 static const size_t attr_flags_values_max
= array_size(attr_flags_values
) - 1;
1388 static bool bgp_attr_flag_invalid(struct bgp_attr_parser_args
*args
)
1390 uint8_t mask
= BGP_ATTR_FLAG_EXTLEN
;
1391 const uint8_t flags
= args
->flags
;
1392 const uint8_t attr_code
= args
->type
;
1394 /* there may be attributes we don't know about */
1395 if (attr_code
> attr_flags_values_max
)
1397 if (attr_flags_values
[attr_code
] == 0)
1400 /* RFC4271, "For well-known attributes, the Transitive bit MUST be set
1404 if (!CHECK_FLAG(BGP_ATTR_FLAG_OPTIONAL
, flags
)
1405 && !CHECK_FLAG(BGP_ATTR_FLAG_TRANS
, flags
)) {
1408 "%s well-known attributes must have transitive flag set (%x)",
1409 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1413 /* "For well-known attributes and for optional non-transitive
1415 * the Partial bit MUST be set to 0."
1417 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_PARTIAL
)) {
1418 if (!CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)) {
1419 flog_err(EC_BGP_ATTR_FLAG
,
1420 "%s well-known attribute must NOT have the partial flag set (%x)",
1421 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1424 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1425 && !CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
)) {
1426 flog_err(EC_BGP_ATTR_FLAG
,
1427 "%s optional + transitive attribute must NOT have the partial flag set (%x)",
1428 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1433 /* Optional transitive attributes may go through speakers that don't
1434 * reocgnise them and set the Partial bit.
1436 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1437 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
))
1438 SET_FLAG(mask
, BGP_ATTR_FLAG_PARTIAL
);
1440 if ((flags
& ~mask
) == attr_flags_values
[attr_code
])
1443 bgp_attr_flags_diagnose(args
, attr_flags_values
[attr_code
]);
1447 /* Get origin attribute of the update message. */
1448 static bgp_attr_parse_ret_t
bgp_attr_origin(struct bgp_attr_parser_args
*args
)
1450 struct peer
*const peer
= args
->peer
;
1451 struct attr
*const attr
= args
->attr
;
1452 const bgp_size_t length
= args
->length
;
1454 /* If any recognized attribute has Attribute Length that conflicts
1455 with the expected length (based on the attribute type code), then
1456 the Error Subcode is set to Attribute Length Error. The Data
1457 field contains the erroneous attribute (type, length and
1460 flog_err(EC_BGP_ATTR_LEN
,
1461 "Origin attribute length is not one %d", length
);
1462 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1466 /* Fetch origin attribute. */
1467 attr
->origin
= stream_getc(BGP_INPUT(peer
));
1469 /* If the ORIGIN attribute has an undefined value, then the Error
1470 Subcode is set to Invalid Origin Attribute. The Data field
1471 contains the unrecognized attribute (type, length and value). */
1472 if ((attr
->origin
!= BGP_ORIGIN_IGP
) && (attr
->origin
!= BGP_ORIGIN_EGP
)
1473 && (attr
->origin
!= BGP_ORIGIN_INCOMPLETE
)) {
1474 flog_err(EC_BGP_ATTR_ORIGIN
,
1475 "Origin attribute value is invalid %d", attr
->origin
);
1476 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_INVAL_ORIGIN
,
1480 /* Set oring attribute flag. */
1481 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
1486 /* Parse AS path information. This function is wrapper of
1488 static int bgp_attr_aspath(struct bgp_attr_parser_args
*args
)
1490 struct attr
*const attr
= args
->attr
;
1491 struct peer
*const peer
= args
->peer
;
1492 const bgp_size_t length
= args
->length
;
1495 * peer with AS4 => will get 4Byte ASnums
1496 * otherwise, will get 16 Bit
1498 attr
->aspath
= aspath_parse(
1500 CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1501 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
));
1503 /* In case of IBGP, length will be zero. */
1504 if (!attr
->aspath
) {
1505 flog_err(EC_BGP_ATTR_MAL_AS_PATH
,
1506 "Malformed AS path from %s, length is %d", peer
->host
,
1508 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1512 /* Set aspath attribute flag. */
1513 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
1515 return BGP_ATTR_PARSE_PROCEED
;
1518 static bgp_attr_parse_ret_t
bgp_attr_aspath_check(struct peer
*const peer
,
1519 struct attr
*const attr
)
1521 /* These checks were part of bgp_attr_aspath, but with
1522 * as4 we should to check aspath things when
1523 * aspath synthesizing with as4_path has already taken place.
1524 * Otherwise we check ASPATH and use the synthesized thing, and that is
1526 * So do the checks later, i.e. here
1528 struct aspath
*aspath
;
1530 /* Confederation sanity check. */
1531 if ((peer
->sort
== BGP_PEER_CONFED
1532 && !aspath_left_confed_check(attr
->aspath
))
1533 || (peer
->sort
== BGP_PEER_EBGP
1534 && aspath_confed_check(attr
->aspath
))) {
1535 flog_err(EC_BGP_ATTR_MAL_AS_PATH
, "Malformed AS path from %s",
1537 return BGP_ATTR_PARSE_WITHDRAW
;
1540 /* First AS check for EBGP. */
1541 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_ENFORCE_FIRST_AS
)) {
1542 if (peer
->sort
== BGP_PEER_EBGP
1543 && !aspath_firstas_check(attr
->aspath
, peer
->as
)) {
1544 flog_err(EC_BGP_ATTR_FIRST_AS
,
1545 "%s incorrect first AS (must be %u)",
1546 peer
->host
, peer
->as
);
1547 return BGP_ATTR_PARSE_WITHDRAW
;
1551 /* Codification of AS 0 Processing */
1552 if (peer
->sort
== BGP_PEER_EBGP
&& aspath_check_as_zero(attr
->aspath
)) {
1554 EC_BGP_ATTR_MAL_AS_PATH
,
1555 "Malformed AS path, AS number is 0 in the path from %s",
1557 return BGP_ATTR_PARSE_WITHDRAW
;
1560 /* local-as prepend */
1561 if (peer
->change_local_as
1562 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)) {
1563 aspath
= aspath_dup(attr
->aspath
);
1564 aspath
= aspath_add_seq(aspath
, peer
->change_local_as
);
1565 aspath_unintern(&attr
->aspath
);
1566 attr
->aspath
= aspath_intern(aspath
);
1569 return BGP_ATTR_PARSE_PROCEED
;
1572 /* Parse AS4 path information. This function is another wrapper of
1574 static int bgp_attr_as4_path(struct bgp_attr_parser_args
*args
,
1575 struct aspath
**as4_path
)
1577 struct peer
*const peer
= args
->peer
;
1578 struct attr
*const attr
= args
->attr
;
1579 const bgp_size_t length
= args
->length
;
1581 *as4_path
= aspath_parse(peer
->curr
, length
, 1);
1583 /* In case of IBGP, length will be zero. */
1585 flog_err(EC_BGP_ATTR_MAL_AS_PATH
,
1586 "Malformed AS4 path from %s, length is %d", peer
->host
,
1588 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1592 /* Set aspath attribute flag. */
1593 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
);
1595 return BGP_ATTR_PARSE_PROCEED
;
1599 * Check that the nexthop attribute is valid.
1601 bgp_attr_parse_ret_t
1602 bgp_attr_nexthop_valid(struct peer
*peer
, struct attr
*attr
)
1604 in_addr_t nexthop_h
;
1606 nexthop_h
= ntohl(attr
->nexthop
.s_addr
);
1607 if ((IPV4_NET0(nexthop_h
) || IPV4_NET127(nexthop_h
)
1608 || IPV4_CLASS_DE(nexthop_h
))
1609 && !BGP_DEBUG(allow_martians
, ALLOW_MARTIANS
)) {
1610 uint8_t data
[7]; /* type(2) + length(1) + nhop(4) */
1611 char buf
[INET_ADDRSTRLEN
];
1613 inet_ntop(AF_INET
, &attr
->nexthop
.s_addr
, buf
,
1615 flog_err(EC_BGP_ATTR_MARTIAN_NH
, "Martian nexthop %s",
1617 data
[0] = BGP_ATTR_FLAG_TRANS
;
1618 data
[1] = BGP_ATTR_NEXT_HOP
;
1619 data
[2] = BGP_ATTR_NHLEN_IPV4
;
1620 memcpy(&data
[3], &attr
->nexthop
.s_addr
, BGP_ATTR_NHLEN_IPV4
);
1621 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
1622 BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP
,
1624 return BGP_ATTR_PARSE_ERROR
;
1627 return BGP_ATTR_PARSE_PROCEED
;
1630 /* Nexthop attribute. */
1631 static bgp_attr_parse_ret_t
bgp_attr_nexthop(struct bgp_attr_parser_args
*args
)
1633 struct peer
*const peer
= args
->peer
;
1634 struct attr
*const attr
= args
->attr
;
1635 const bgp_size_t length
= args
->length
;
1637 /* Check nexthop attribute length. */
1639 flog_err(EC_BGP_ATTR_LEN
,
1640 "Nexthop attribute length isn't four [%d]", length
);
1642 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1646 attr
->nexthop
.s_addr
= stream_get_ipv4(peer
->curr
);
1647 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
1649 return BGP_ATTR_PARSE_PROCEED
;
1652 /* MED atrribute. */
1653 static bgp_attr_parse_ret_t
bgp_attr_med(struct bgp_attr_parser_args
*args
)
1655 struct peer
*const peer
= args
->peer
;
1656 struct attr
*const attr
= args
->attr
;
1657 const bgp_size_t length
= args
->length
;
1661 flog_err(EC_BGP_ATTR_LEN
,
1662 "MED attribute length isn't four [%d]", length
);
1664 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1668 attr
->med
= stream_getl(peer
->curr
);
1670 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
);
1672 return BGP_ATTR_PARSE_PROCEED
;
1675 /* Local preference attribute. */
1676 static bgp_attr_parse_ret_t
1677 bgp_attr_local_pref(struct bgp_attr_parser_args
*args
)
1679 struct peer
*const peer
= args
->peer
;
1680 struct attr
*const attr
= args
->attr
;
1681 const bgp_size_t length
= args
->length
;
1683 /* if received from an internal neighbor, it SHALL be considered
1684 * malformed if its length is not equal to 4. If malformed, the
1685 * UPDATE message SHALL be handled using the approach of "treat-as-
1688 if (peer
->sort
== BGP_PEER_IBGP
&& length
!= 4) {
1689 flog_err(EC_BGP_ATTR_LEN
,
1690 "LOCAL_PREF attribute length isn't 4 [%u]", length
);
1691 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1695 /* If it is contained in an UPDATE message that is received from an
1696 external peer, then this attribute MUST be ignored by the
1697 receiving speaker. */
1698 if (peer
->sort
== BGP_PEER_EBGP
) {
1699 STREAM_FORWARD_GETP(peer
->curr
, length
);
1700 return BGP_ATTR_PARSE_PROCEED
;
1703 STREAM_GETL(peer
->curr
, attr
->local_pref
);
1705 /* Set the local-pref flag. */
1706 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
);
1708 return BGP_ATTR_PARSE_PROCEED
;
1711 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1715 /* Atomic aggregate. */
1716 static int bgp_attr_atomic(struct bgp_attr_parser_args
*args
)
1718 struct attr
*const attr
= args
->attr
;
1719 const bgp_size_t length
= args
->length
;
1723 flog_err(EC_BGP_ATTR_LEN
,
1724 "ATOMIC_AGGREGATE attribute length isn't 0 [%u]",
1726 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1730 /* Set atomic aggregate flag. */
1731 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
);
1733 return BGP_ATTR_PARSE_PROCEED
;
1736 /* Aggregator attribute */
1737 static int bgp_attr_aggregator(struct bgp_attr_parser_args
*args
)
1739 struct peer
*const peer
= args
->peer
;
1740 struct attr
*const attr
= args
->attr
;
1741 const bgp_size_t length
= args
->length
;
1746 /* peer with AS4 will send 4 Byte AS, peer without will send 2 Byte */
1747 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1748 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
))
1751 if (length
!= wantedlen
) {
1752 flog_err(EC_BGP_ATTR_LEN
,
1753 "AGGREGATOR attribute length isn't %u [%u]", wantedlen
,
1755 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1759 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
))
1760 aggregator_as
= stream_getl(peer
->curr
);
1762 aggregator_as
= stream_getw(peer
->curr
);
1764 attr
->aggregator_as
= aggregator_as
;
1765 attr
->aggregator_addr
.s_addr
= stream_get_ipv4(peer
->curr
);
1767 /* Codification of AS 0 Processing */
1768 if (aggregator_as
== BGP_AS_ZERO
) {
1769 flog_err(EC_BGP_ATTR_LEN
,
1770 "%s: AGGREGATOR AS number is 0 for aspath: %s",
1771 peer
->host
, aspath_print(attr
->aspath
));
1773 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1774 char attr_str
[BUFSIZ
] = {0};
1776 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1778 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1781 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
);
1784 return BGP_ATTR_PARSE_PROCEED
;
1787 /* New Aggregator attribute */
1788 static bgp_attr_parse_ret_t
1789 bgp_attr_as4_aggregator(struct bgp_attr_parser_args
*args
,
1790 as_t
*as4_aggregator_as
,
1791 struct in_addr
*as4_aggregator_addr
)
1793 struct peer
*const peer
= args
->peer
;
1794 struct attr
*const attr
= args
->attr
;
1795 const bgp_size_t length
= args
->length
;
1799 flog_err(EC_BGP_ATTR_LEN
, "New Aggregator length is not 8 [%d]",
1801 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1805 aggregator_as
= stream_getl(peer
->curr
);
1807 *as4_aggregator_as
= aggregator_as
;
1808 as4_aggregator_addr
->s_addr
= stream_get_ipv4(peer
->curr
);
1810 /* Codification of AS 0 Processing */
1811 if (aggregator_as
== BGP_AS_ZERO
) {
1812 flog_err(EC_BGP_ATTR_LEN
,
1813 "%s: AS4_AGGREGATOR AS number is 0 for aspath: %s",
1814 peer
->host
, aspath_print(attr
->aspath
));
1816 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1817 char attr_str
[BUFSIZ
] = {0};
1819 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1821 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1824 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
);
1827 return BGP_ATTR_PARSE_PROCEED
;
1830 /* Munge Aggregator and New-Aggregator, AS_PATH and NEW_AS_PATH.
1832 static bgp_attr_parse_ret_t
1833 bgp_attr_munge_as4_attrs(struct peer
*const peer
, struct attr
*const attr
,
1834 struct aspath
*as4_path
, as_t as4_aggregator
,
1835 struct in_addr
*as4_aggregator_addr
)
1837 int ignore_as4_path
= 0;
1838 struct aspath
*newpath
;
1840 if (!attr
->aspath
) {
1841 /* NULL aspath shouldn't be possible as bgp_attr_parse should
1843 * checked that all well-known, mandatory attributes were
1846 * Can only be a problem with peer itself - hard error
1848 return BGP_ATTR_PARSE_ERROR
;
1851 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)) {
1852 /* peer can do AS4, so we ignore AS4_PATH and AS4_AGGREGATOR
1854 * It is worth a warning though, because the peer really
1855 * should not send them
1857 if (BGP_DEBUG(as4
, AS4
)) {
1858 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
)))
1859 zlog_debug("[AS4] %s %s AS4_PATH", peer
->host
,
1860 "AS4 capable peer, yet it sent");
1863 & (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
)))
1864 zlog_debug("[AS4] %s %s AS4_AGGREGATOR",
1866 "AS4 capable peer, yet it sent");
1869 return BGP_ATTR_PARSE_PROCEED
;
1872 /* We have a asn16 peer. First, look for AS4_AGGREGATOR
1873 * because that may override AS4_PATH
1875 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
))) {
1876 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
))) {
1878 * if the as_number in aggregator is not AS_TRANS,
1879 * then AS4_AGGREGATOR and AS4_PATH shall be ignored
1880 * and the Aggregator shall be taken as
1881 * info on the aggregating node, and the AS_PATH
1882 * shall be taken as the AS_PATH
1884 * the Aggregator shall be ignored and the
1885 * AS4_AGGREGATOR shall be taken as the
1886 * Aggregating node and the AS_PATH is to be
1887 * constructed "as in all other cases"
1889 if (attr
->aggregator_as
!= BGP_AS_TRANS
) {
1891 if (BGP_DEBUG(as4
, AS4
))
1893 "[AS4] %s BGP not AS4 capable peer send AGGREGATOR != AS_TRANS and AS4_AGGREGATOR, so ignore AS4_AGGREGATOR and AS4_PATH",
1895 ignore_as4_path
= 1;
1897 /* "New_aggregator shall be taken as aggregator"
1899 attr
->aggregator_as
= as4_aggregator
;
1900 attr
->aggregator_addr
.s_addr
=
1901 as4_aggregator_addr
->s_addr
;
1904 /* We received a AS4_AGGREGATOR but no AGGREGATOR.
1905 * That is bogus - but reading the conditions
1906 * we have to handle AS4_AGGREGATOR as if it were
1907 * AGGREGATOR in that case
1909 if (BGP_DEBUG(as4
, AS4
))
1911 "[AS4] %s BGP not AS4 capable peer send AS4_AGGREGATOR but no AGGREGATOR, will take it as if AGGREGATOR with AS_TRANS had been there",
1913 attr
->aggregator_as
= as4_aggregator
;
1914 /* sweep it under the carpet and simulate a "good"
1916 attr
->flag
|= (ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
));
1920 /* need to reconcile NEW_AS_PATH and AS_PATH */
1921 if (!ignore_as4_path
1922 && (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
)))) {
1923 newpath
= aspath_reconcile_as4(attr
->aspath
, as4_path
);
1925 return BGP_ATTR_PARSE_ERROR
;
1927 aspath_unintern(&attr
->aspath
);
1928 attr
->aspath
= aspath_intern(newpath
);
1930 return BGP_ATTR_PARSE_PROCEED
;
1933 /* Community attribute. */
1934 static bgp_attr_parse_ret_t
1935 bgp_attr_community(struct bgp_attr_parser_args
*args
)
1937 struct peer
*const peer
= args
->peer
;
1938 struct attr
*const attr
= args
->attr
;
1939 const bgp_size_t length
= args
->length
;
1942 bgp_attr_set_community(attr
, NULL
);
1943 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
1947 bgp_attr_set_community(
1949 community_parse((uint32_t *)stream_pnt(peer
->curr
), length
));
1951 /* XXX: fix community_parse to use stream API and remove this */
1952 stream_forward_getp(peer
->curr
, length
);
1954 /* The Community attribute SHALL be considered malformed if its
1955 * length is not a non-zero multiple of 4.
1957 if (!bgp_attr_get_community(attr
))
1958 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
1961 return BGP_ATTR_PARSE_PROCEED
;
1964 /* Originator ID attribute. */
1965 static bgp_attr_parse_ret_t
1966 bgp_attr_originator_id(struct bgp_attr_parser_args
*args
)
1968 struct peer
*const peer
= args
->peer
;
1969 struct attr
*const attr
= args
->attr
;
1970 const bgp_size_t length
= args
->length
;
1972 /* if received from an internal neighbor, it SHALL be considered
1973 * malformed if its length is not equal to 4. If malformed, the
1974 * UPDATE message SHALL be handled using the approach of "treat-as-
1978 flog_err(EC_BGP_ATTR_LEN
, "Bad originator ID length %d",
1981 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1985 attr
->originator_id
.s_addr
= stream_get_ipv4(peer
->curr
);
1987 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
);
1989 return BGP_ATTR_PARSE_PROCEED
;
1992 /* Cluster list attribute. */
1993 static bgp_attr_parse_ret_t
1994 bgp_attr_cluster_list(struct bgp_attr_parser_args
*args
)
1996 struct peer
*const peer
= args
->peer
;
1997 struct attr
*const attr
= args
->attr
;
1998 const bgp_size_t length
= args
->length
;
2000 /* if received from an internal neighbor, it SHALL be considered
2001 * malformed if its length is not a non-zero multiple of 4. If
2002 * malformed, the UPDATE message SHALL be handled using the approach
2003 * of "treat-as-withdraw".
2005 if (length
== 0 || length
% 4) {
2006 flog_err(EC_BGP_ATTR_LEN
, "Bad cluster list length %d", length
);
2008 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2012 bgp_attr_set_cluster(
2013 attr
, cluster_parse((struct in_addr
*)stream_pnt(peer
->curr
),
2016 /* XXX: Fix cluster_parse to use stream API and then remove this */
2017 stream_forward_getp(peer
->curr
, length
);
2019 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST
);
2021 return BGP_ATTR_PARSE_PROCEED
;
2024 /* Multiprotocol reachability information parse. */
2025 int bgp_mp_reach_parse(struct bgp_attr_parser_args
*args
,
2026 struct bgp_nlri
*mp_update
)
2030 iana_safi_t pkt_safi
;
2032 bgp_size_t nlri_len
;
2035 struct peer
*const peer
= args
->peer
;
2036 struct attr
*const attr
= args
->attr
;
2037 const bgp_size_t length
= args
->length
;
2039 /* Set end of packet. */
2040 s
= BGP_INPUT(peer
);
2041 start
= stream_get_getp(s
);
2043 /* safe to read statically sized header? */
2044 #define BGP_MP_REACH_MIN_SIZE 5
2045 #define LEN_LEFT (length - (stream_get_getp(s) - start))
2046 if ((length
> STREAM_READABLE(s
)) || (length
< BGP_MP_REACH_MIN_SIZE
)) {
2047 zlog_info("%s: %s sent invalid length, %lu, of MP_REACH_NLRI",
2048 __func__
, peer
->host
, (unsigned long)length
);
2049 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2052 /* Load AFI, SAFI. */
2053 pkt_afi
= stream_getw(s
);
2054 pkt_safi
= stream_getc(s
);
2056 /* Convert AFI, SAFI to internal values, check. */
2057 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
2058 /* Log if AFI or SAFI is unrecognized. This is not an error
2060 * the attribute is otherwise malformed.
2062 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
2064 "%s sent unrecognizable AFI, %s or, SAFI, %s, of MP_REACH_NLRI",
2065 peer
->host
, iana_afi2str(pkt_afi
),
2066 iana_safi2str(pkt_safi
));
2067 return BGP_ATTR_PARSE_ERROR
;
2070 /* Get nexthop length. */
2071 attr
->mp_nexthop_len
= stream_getc(s
);
2073 if (LEN_LEFT
< attr
->mp_nexthop_len
) {
2075 "%s: %s sent next-hop length, %u, in MP_REACH_NLRI which goes past the end of attribute",
2076 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2077 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2080 /* Nexthop length check. */
2081 switch (attr
->mp_nexthop_len
) {
2083 if (safi
!= SAFI_FLOWSPEC
) {
2084 zlog_info("%s: %s sent wrong next-hop length, %d, in MP_REACH_NLRI",
2085 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2086 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2089 case BGP_ATTR_NHLEN_VPNV4
:
2090 stream_getl(s
); /* RD high */
2091 stream_getl(s
); /* RD low */
2093 * NOTE: intentional fall through
2094 * - for consistency in rx processing
2096 * The following comment is to signal GCC this intention
2097 * and suppress the warning
2100 case BGP_ATTR_NHLEN_IPV4
:
2101 stream_get(&attr
->mp_nexthop_global_in
, s
, IPV4_MAX_BYTELEN
);
2102 /* Probably needed for RFC 2283 */
2103 if (attr
->nexthop
.s_addr
== INADDR_ANY
)
2104 memcpy(&attr
->nexthop
.s_addr
,
2105 &attr
->mp_nexthop_global_in
, IPV4_MAX_BYTELEN
);
2107 case BGP_ATTR_NHLEN_IPV6_GLOBAL
:
2108 case BGP_ATTR_NHLEN_VPNV6_GLOBAL
:
2109 if (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_VPNV6_GLOBAL
) {
2110 stream_getl(s
); /* RD high */
2111 stream_getl(s
); /* RD low */
2113 stream_get(&attr
->mp_nexthop_global
, s
, IPV6_MAX_BYTELEN
);
2114 if (IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_global
)) {
2115 if (!peer
->nexthop
.ifp
) {
2116 zlog_warn("%s sent a v6 global attribute but address is a V6 LL and there's no peer interface information. Hence, withdrawing",
2118 return BGP_ATTR_PARSE_WITHDRAW
;
2120 attr
->nh_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2123 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
:
2124 case BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
:
2125 if (attr
->mp_nexthop_len
2126 == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
) {
2127 stream_getl(s
); /* RD high */
2128 stream_getl(s
); /* RD low */
2130 stream_get(&attr
->mp_nexthop_global
, s
, IPV6_MAX_BYTELEN
);
2131 if (IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_global
)) {
2132 if (!peer
->nexthop
.ifp
) {
2133 zlog_warn("%s sent a v6 global and LL attribute but global address is a V6 LL and there's no peer interface information. Hence, withdrawing",
2135 return BGP_ATTR_PARSE_WITHDRAW
;
2137 attr
->nh_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2139 if (attr
->mp_nexthop_len
2140 == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
) {
2141 stream_getl(s
); /* RD high */
2142 stream_getl(s
); /* RD low */
2144 stream_get(&attr
->mp_nexthop_local
, s
, IPV6_MAX_BYTELEN
);
2145 if (!IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_local
)) {
2146 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2148 "%s sent next-hops %pI6 and %pI6. Ignoring non-LL value",
2149 peer
->host
, &attr
->mp_nexthop_global
,
2150 &attr
->mp_nexthop_local
);
2152 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
2154 if (!peer
->nexthop
.ifp
) {
2155 zlog_warn("%s sent a v6 LL next-hop and there's no peer interface information. Hence, withdrawing",
2157 return BGP_ATTR_PARSE_WITHDRAW
;
2159 attr
->nh_lla_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2162 zlog_info("%s: %s sent wrong next-hop length, %d, in MP_REACH_NLRI",
2163 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2164 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2168 zlog_info("%s: %s sent SNPA which couldn't be read",
2169 __func__
, peer
->host
);
2170 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2175 if ((val
= stream_getc(s
)))
2177 EC_BGP_DEFUNCT_SNPA_LEN
,
2178 "%s sent non-zero value, %u, for defunct SNPA-length field",
2182 /* must have nrli_len, what is left of the attribute */
2183 nlri_len
= LEN_LEFT
;
2184 if (nlri_len
> STREAM_READABLE(s
)) {
2185 zlog_info("%s: %s sent MP_REACH_NLRI which couldn't be read",
2186 __func__
, peer
->host
);
2187 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2191 zlog_info("%s: %s sent a zero-length NLRI. Hence, treating as a EOR marker",
2192 __func__
, peer
->host
);
2194 mp_update
->afi
= afi
;
2195 mp_update
->safi
= safi
;
2196 return BGP_ATTR_PARSE_EOR
;
2199 mp_update
->afi
= afi
;
2200 mp_update
->safi
= safi
;
2201 mp_update
->nlri
= stream_pnt(s
);
2202 mp_update
->length
= nlri_len
;
2204 stream_forward_getp(s
, nlri_len
);
2206 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
);
2208 return BGP_ATTR_PARSE_PROCEED
;
2212 /* Multiprotocol unreachable parse */
2213 int bgp_mp_unreach_parse(struct bgp_attr_parser_args
*args
,
2214 struct bgp_nlri
*mp_withdraw
)
2219 iana_safi_t pkt_safi
;
2221 uint16_t withdraw_len
;
2222 struct peer
*const peer
= args
->peer
;
2223 struct attr
*const attr
= args
->attr
;
2224 const bgp_size_t length
= args
->length
;
2228 #define BGP_MP_UNREACH_MIN_SIZE 3
2229 if ((length
> STREAM_READABLE(s
)) || (length
< BGP_MP_UNREACH_MIN_SIZE
))
2230 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2232 pkt_afi
= stream_getw(s
);
2233 pkt_safi
= stream_getc(s
);
2235 /* Convert AFI, SAFI to internal values, check. */
2236 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
2237 /* Log if AFI or SAFI is unrecognized. This is not an error
2239 * the attribute is otherwise malformed.
2241 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
2243 "%s: MP_UNREACH received AFI %s or SAFI %s is unrecognized",
2244 peer
->host
, iana_afi2str(pkt_afi
),
2245 iana_safi2str(pkt_safi
));
2246 return BGP_ATTR_PARSE_ERROR
;
2249 withdraw_len
= length
- BGP_MP_UNREACH_MIN_SIZE
;
2251 mp_withdraw
->afi
= afi
;
2252 mp_withdraw
->safi
= safi
;
2253 mp_withdraw
->nlri
= stream_pnt(s
);
2254 mp_withdraw
->length
= withdraw_len
;
2256 stream_forward_getp(s
, withdraw_len
);
2258 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
);
2260 return BGP_ATTR_PARSE_PROCEED
;
2263 /* Large Community attribute. */
2264 static bgp_attr_parse_ret_t
2265 bgp_attr_large_community(struct bgp_attr_parser_args
*args
)
2267 struct peer
*const peer
= args
->peer
;
2268 struct attr
*const attr
= args
->attr
;
2269 const bgp_size_t length
= args
->length
;
2272 * Large community follows new attribute format.
2275 bgp_attr_set_lcommunity(attr
, NULL
);
2276 /* Empty extcomm doesn't seem to be invalid per se */
2277 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2281 bgp_attr_set_lcommunity(
2282 attr
, lcommunity_parse(stream_pnt(peer
->curr
), length
));
2283 /* XXX: fix ecommunity_parse to use stream API */
2284 stream_forward_getp(peer
->curr
, length
);
2286 if (!bgp_attr_get_lcommunity(attr
))
2287 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2290 return BGP_ATTR_PARSE_PROCEED
;
2293 /* Extended Community attribute. */
2294 static bgp_attr_parse_ret_t
2295 bgp_attr_ext_communities(struct bgp_attr_parser_args
*args
)
2297 struct peer
*const peer
= args
->peer
;
2298 struct attr
*const attr
= args
->attr
;
2299 const bgp_size_t length
= args
->length
;
2302 struct ecommunity
*ecomm
;
2305 bgp_attr_set_ecommunity(attr
, NULL
);
2306 /* Empty extcomm doesn't seem to be invalid per se */
2307 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2311 ecomm
= ecommunity_parse(
2312 stream_pnt(peer
->curr
), length
,
2313 CHECK_FLAG(peer
->flags
,
2314 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
));
2315 bgp_attr_set_ecommunity(attr
, ecomm
);
2316 /* XXX: fix ecommunity_parse to use stream API */
2317 stream_forward_getp(peer
->curr
, length
);
2319 /* The Extended Community attribute SHALL be considered malformed if
2320 * its length is not a non-zero multiple of 8.
2322 if (!bgp_attr_get_ecommunity(attr
))
2323 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2326 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
2328 /* Extract DF election preference and mobility sequence number */
2329 attr
->df_pref
= bgp_attr_df_pref_from_ec(attr
, &attr
->df_alg
);
2331 /* Extract MAC mobility sequence number, if any. */
2332 attr
->mm_seqnum
= bgp_attr_mac_mobility_seqnum(attr
, &sticky
);
2333 attr
->sticky
= sticky
;
2335 /* Check if this is a Gateway MAC-IP advertisement */
2336 attr
->default_gw
= bgp_attr_default_gw(attr
);
2338 /* Handle scenario where router flag ecommunity is not
2339 * set but default gw ext community is present.
2340 * Use default gateway, set and propogate R-bit.
2342 if (attr
->default_gw
)
2343 attr
->router_flag
= 1;
2345 /* Check EVPN Neighbor advertisement flags, R-bit */
2346 bgp_attr_evpn_na_flag(attr
, &attr
->router_flag
, &proxy
);
2348 attr
->es_flags
|= ATTR_ES_PROXY_ADVERT
;
2350 /* Extract the Rmac, if any */
2351 if (bgp_attr_rmac(attr
, &attr
->rmac
)) {
2352 if (bgp_debug_update(peer
, NULL
, NULL
, 1)
2353 && bgp_mac_exist(&attr
->rmac
))
2354 zlog_debug("%s: router mac %pEA is self mac", __func__
,
2358 /* Get the tunnel type from encap extended community */
2359 bgp_attr_extcom_tunnel_type(attr
,
2360 (bgp_encap_types
*)&attr
->encap_tunneltype
);
2362 /* Extract link bandwidth, if any. */
2363 (void)ecommunity_linkbw_present(bgp_attr_get_ecommunity(attr
),
2366 return BGP_ATTR_PARSE_PROCEED
;
2369 /* IPv6 Extended Community attribute. */
2370 static bgp_attr_parse_ret_t
2371 bgp_attr_ipv6_ext_communities(struct bgp_attr_parser_args
*args
)
2373 struct peer
*const peer
= args
->peer
;
2374 struct attr
*const attr
= args
->attr
;
2375 const bgp_size_t length
= args
->length
;
2376 struct ecommunity
*ipv6_ecomm
= NULL
;
2379 bgp_attr_set_ipv6_ecommunity(attr
, ipv6_ecomm
);
2380 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2384 ipv6_ecomm
= ecommunity_parse_ipv6(
2385 stream_pnt(peer
->curr
), length
,
2386 CHECK_FLAG(peer
->flags
,
2387 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
));
2388 bgp_attr_set_ipv6_ecommunity(attr
, ipv6_ecomm
);
2390 /* XXX: fix ecommunity_parse to use stream API */
2391 stream_forward_getp(peer
->curr
, length
);
2394 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2397 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_IPV6_EXT_COMMUNITIES
);
2399 return BGP_ATTR_PARSE_PROCEED
;
2402 /* Parse Tunnel Encap attribute in an UPDATE */
2403 static int bgp_attr_encap(uint8_t type
, struct peer
*peer
, /* IN */
2404 bgp_size_t length
, /* IN: attr's length field */
2405 struct attr
*attr
, /* IN: caller already allocated */
2406 uint8_t flag
, /* IN: attr's flags field */
2410 uint16_t tunneltype
= 0;
2412 total
= length
+ (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
) ? 4 : 3);
2414 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_TRANS
)
2415 || !CHECK_FLAG(flag
, BGP_ATTR_FLAG_OPTIONAL
)) {
2417 "Tunnel Encap attribute flag isn't optional and transitive %d",
2419 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
2420 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR
,
2425 if (BGP_ATTR_ENCAP
== type
) {
2426 /* read outer TLV type and length */
2427 uint16_t tlv_length
;
2431 "Tunnel Encap attribute not long enough to contain outer T,L");
2432 bgp_notify_send_with_data(
2433 peer
, BGP_NOTIFY_UPDATE_ERR
,
2434 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
, startp
, total
);
2437 tunneltype
= stream_getw(BGP_INPUT(peer
));
2438 tlv_length
= stream_getw(BGP_INPUT(peer
));
2441 if (tlv_length
!= length
) {
2442 zlog_info("%s: tlv_length(%d) != length(%d)",
2443 __func__
, tlv_length
, length
);
2447 while (length
>= 4) {
2448 uint16_t subtype
= 0;
2449 uint16_t sublength
= 0;
2450 struct bgp_attr_encap_subtlv
*tlv
;
2452 if (BGP_ATTR_ENCAP
== type
) {
2453 subtype
= stream_getc(BGP_INPUT(peer
));
2454 sublength
= stream_getc(BGP_INPUT(peer
));
2456 #ifdef ENABLE_BGP_VNC
2458 subtype
= stream_getw(BGP_INPUT(peer
));
2459 sublength
= stream_getw(BGP_INPUT(peer
));
2464 if (sublength
> length
) {
2466 "Tunnel Encap attribute sub-tlv length %d exceeds remaining length %d",
2468 bgp_notify_send_with_data(
2469 peer
, BGP_NOTIFY_UPDATE_ERR
,
2470 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
, startp
, total
);
2474 /* alloc and copy sub-tlv */
2475 /* TBD make sure these are freed when attributes are released */
2476 tlv
= XCALLOC(MTYPE_ENCAP_TLV
,
2477 sizeof(struct bgp_attr_encap_subtlv
) + sublength
);
2478 tlv
->type
= subtype
;
2479 tlv
->length
= sublength
;
2480 stream_get(tlv
->value
, peer
->curr
, sublength
);
2481 length
-= sublength
;
2483 /* attach tlv to encap chain */
2484 if (BGP_ATTR_ENCAP
== type
) {
2485 struct bgp_attr_encap_subtlv
*stlv_last
;
2486 for (stlv_last
= attr
->encap_subtlvs
;
2487 stlv_last
&& stlv_last
->next
;
2488 stlv_last
= stlv_last
->next
)
2491 stlv_last
->next
= tlv
;
2493 attr
->encap_subtlvs
= tlv
;
2495 #ifdef ENABLE_BGP_VNC
2497 struct bgp_attr_encap_subtlv
*stlv_last
;
2498 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
2499 bgp_attr_get_vnc_subtlvs(attr
);
2501 for (stlv_last
= vnc_subtlvs
;
2502 stlv_last
&& stlv_last
->next
;
2503 stlv_last
= stlv_last
->next
)
2506 stlv_last
->next
= tlv
;
2508 bgp_attr_set_vnc_subtlvs(attr
, tlv
);
2513 if (BGP_ATTR_ENCAP
== type
) {
2514 attr
->encap_tunneltype
= tunneltype
;
2518 /* spurious leftover data */
2520 "Tunnel Encap attribute length is bad: %d leftover octets",
2522 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
2523 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2532 /* SRv6 Service Data Sub-Sub-TLV attribute
2533 * draft-ietf-bess-srv6-services-07
2535 static bgp_attr_parse_ret_t
2536 bgp_attr_srv6_service_data(struct bgp_attr_parser_args
*args
)
2538 struct peer
*const peer
= args
->peer
;
2539 struct attr
*const attr
= args
->attr
;
2540 uint8_t type
, loc_block_len
, loc_node_len
, func_len
, arg_len
,
2541 transposition_len
, transposition_offset
;
2543 size_t headersz
= sizeof(type
) + sizeof(length
);
2545 if (STREAM_READABLE(peer
->curr
) < headersz
) {
2548 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
2549 headersz
, STREAM_READABLE(peer
->curr
));
2550 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2554 type
= stream_getc(peer
->curr
);
2555 length
= stream_getw(peer
->curr
);
2557 if (STREAM_READABLE(peer
->curr
) < length
) {
2560 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficent data (need %hu for attribute data, have %zu remaining in UPDATE)",
2561 length
, STREAM_READABLE(peer
->curr
));
2562 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2566 if (length
< BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
) {
2569 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficient data (need %u, have %hu remaining in UPDATE)",
2570 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
,
2572 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2576 if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE
) {
2577 loc_block_len
= stream_getc(peer
->curr
);
2578 loc_node_len
= stream_getc(peer
->curr
);
2579 func_len
= stream_getc(peer
->curr
);
2580 arg_len
= stream_getc(peer
->curr
);
2581 transposition_len
= stream_getc(peer
->curr
);
2582 transposition_offset
= stream_getc(peer
->curr
);
2584 /* Log SRv6 Service Data Sub-Sub-TLV */
2585 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
)) {
2587 "%s: srv6-l3-srv-data loc-block-len=%u, loc-node-len=%u func-len=%u, arg-len=%u, transposition-len=%u, transposition-offset=%u",
2588 __func__
, loc_block_len
, loc_node_len
, func_len
,
2589 arg_len
, transposition_len
,
2590 transposition_offset
);
2593 attr
->srv6_l3vpn
->loc_block_len
= loc_block_len
;
2594 attr
->srv6_l3vpn
->loc_node_len
= loc_node_len
;
2595 attr
->srv6_l3vpn
->func_len
= func_len
;
2596 attr
->srv6_l3vpn
->arg_len
= arg_len
;
2597 attr
->srv6_l3vpn
->transposition_len
= transposition_len
;
2598 attr
->srv6_l3vpn
->transposition_offset
= transposition_offset
;
2602 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2604 "%s attr SRv6 Service Data Sub-Sub-TLV sub-sub-type=%u is not supported, skipped",
2607 stream_forward_getp(peer
->curr
, length
);
2610 return BGP_ATTR_PARSE_PROCEED
;
2613 /* SRv6 Service Sub-TLV attribute
2614 * draft-ietf-bess-srv6-services-07
2616 static bgp_attr_parse_ret_t
2617 bgp_attr_srv6_service(struct bgp_attr_parser_args
*args
)
2619 struct peer
*const peer
= args
->peer
;
2620 struct attr
*const attr
= args
->attr
;
2621 struct in6_addr ipv6_sid
;
2622 uint8_t type
, sid_flags
;
2623 uint16_t length
, endpoint_behavior
;
2624 size_t headersz
= sizeof(type
) + sizeof(length
);
2625 bgp_attr_parse_ret_t err
;
2628 if (STREAM_READABLE(peer
->curr
) < headersz
) {
2631 "Malformed SRv6 Service Sub-TLV attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
2632 headersz
, STREAM_READABLE(peer
->curr
));
2633 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2637 type
= stream_getc(peer
->curr
);
2638 length
= stream_getw(peer
->curr
);
2640 if (STREAM_READABLE(peer
->curr
) < length
) {
2643 "Malformed SRv6 Service Sub-TLV attribute - insufficent data (need %hu for attribute data, have %zu remaining in UPDATE)",
2644 length
, STREAM_READABLE(peer
->curr
));
2645 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2649 if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO
) {
2650 stream_getc(peer
->curr
);
2651 stream_get(&ipv6_sid
, peer
->curr
, sizeof(ipv6_sid
));
2652 sid_flags
= stream_getc(peer
->curr
);
2653 endpoint_behavior
= stream_getw(peer
->curr
);
2654 stream_getc(peer
->curr
);
2656 /* Log SRv6 Service Sub-TLV */
2657 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
)) {
2658 inet_ntop(AF_INET6
, &ipv6_sid
, buf
, sizeof(buf
));
2660 "%s: srv6-l3-srv sid %s, sid-flags 0x%02x, end-behaviour 0x%04x",
2661 __func__
, buf
, sid_flags
, endpoint_behavior
);
2664 /* Configure from Info */
2665 if (attr
->srv6_l3vpn
) {
2666 flog_err(EC_BGP_ATTRIBUTE_REPEATED
,
2667 "Prefix SID SRv6 L3VPN field repeated");
2668 return bgp_attr_malformed(
2669 args
, BGP_NOTIFY_UPDATE_MAL_ATTR
, args
->total
);
2671 attr
->srv6_l3vpn
= XCALLOC(MTYPE_BGP_SRV6_L3VPN
,
2672 sizeof(struct bgp_attr_srv6_l3vpn
));
2673 sid_copy(&attr
->srv6_l3vpn
->sid
, &ipv6_sid
);
2674 attr
->srv6_l3vpn
->sid_flags
= sid_flags
;
2675 attr
->srv6_l3vpn
->endpoint_behavior
= endpoint_behavior
;
2676 attr
->srv6_l3vpn
->loc_block_len
= 0;
2677 attr
->srv6_l3vpn
->loc_node_len
= 0;
2678 attr
->srv6_l3vpn
->func_len
= 0;
2679 attr
->srv6_l3vpn
->arg_len
= 0;
2680 attr
->srv6_l3vpn
->transposition_len
= 0;
2681 attr
->srv6_l3vpn
->transposition_offset
= 0;
2683 // Sub-Sub-TLV found
2684 if (length
> BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO_LENGTH
) {
2685 err
= bgp_attr_srv6_service_data(args
);
2687 if (err
!= BGP_ATTR_PARSE_PROCEED
)
2691 attr
->srv6_l3vpn
= srv6_l3vpn_intern(attr
->srv6_l3vpn
);
2694 /* Placeholder code for unsupported type */
2696 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2698 "%s attr SRv6 Service Sub-TLV sub-type=%u is not supported, skipped",
2701 stream_forward_getp(peer
->curr
, length
);
2704 return BGP_ATTR_PARSE_PROCEED
;
2708 * Read an individual SID value returning how much data we have read
2709 * Returns 0 if there was an error that needs to be passed up the stack
2711 static bgp_attr_parse_ret_t
bgp_attr_psid_sub(uint8_t type
, uint16_t length
,
2712 struct bgp_attr_parser_args
*args
)
2714 struct peer
*const peer
= args
->peer
;
2715 struct attr
*const attr
= args
->attr
;
2716 uint32_t label_index
;
2717 struct in6_addr ipv6_sid
;
2719 uint32_t srgb_range
;
2721 uint8_t sid_type
, sid_flags
;
2724 if (type
== BGP_PREFIX_SID_LABEL_INDEX
) {
2725 if (STREAM_READABLE(peer
->curr
) < length
2726 || length
!= BGP_PREFIX_SID_LABEL_INDEX_LENGTH
) {
2727 flog_err(EC_BGP_ATTR_LEN
,
2728 "Prefix SID label index length is %hu instead of %u",
2729 length
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
2730 return bgp_attr_malformed(args
,
2731 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2735 /* Ignore flags and reserved */
2736 stream_getc(peer
->curr
);
2737 stream_getw(peer
->curr
);
2739 /* Fetch the label index and see if it is valid. */
2740 label_index
= stream_getl(peer
->curr
);
2741 if (label_index
== BGP_INVALID_LABEL_INDEX
)
2742 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2745 /* Store label index; subsequently, we'll check on
2747 attr
->label_index
= label_index
;
2750 /* Placeholder code for the IPv6 SID type */
2751 else if (type
== BGP_PREFIX_SID_IPV6
) {
2752 if (STREAM_READABLE(peer
->curr
) < length
2753 || length
!= BGP_PREFIX_SID_IPV6_LENGTH
) {
2754 flog_err(EC_BGP_ATTR_LEN
,
2755 "Prefix SID IPv6 length is %hu instead of %u",
2756 length
, BGP_PREFIX_SID_IPV6_LENGTH
);
2757 return bgp_attr_malformed(args
,
2758 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2762 /* Ignore reserved */
2763 stream_getc(peer
->curr
);
2764 stream_getw(peer
->curr
);
2766 stream_get(&ipv6_sid
, peer
->curr
, 16);
2769 /* Placeholder code for the Originator SRGB type */
2770 else if (type
== BGP_PREFIX_SID_ORIGINATOR_SRGB
) {
2772 * ietf-idr-bgp-prefix-sid-05:
2773 * Length is the total length of the value portion of the
2774 * TLV: 2 + multiple of 6.
2776 * peer->curr stream readp should be at the beginning of the 16
2777 * bit flag field at this point in the code.
2781 * Check that the TLV length field is sane: at least 2 bytes of
2782 * flag, and at least 1 SRGB (these are 6 bytes each)
2784 if (length
< (2 + BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
)) {
2787 "Prefix SID Originator SRGB length field claims length of %hu bytes, but the minimum for this TLV type is %u",
2789 2 + BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
);
2790 return bgp_attr_malformed(
2791 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2796 * Check that we actually have at least as much data as
2797 * specified by the length field
2799 if (STREAM_READABLE(peer
->curr
) < length
) {
2800 flog_err(EC_BGP_ATTR_LEN
,
2801 "Prefix SID Originator SRGB specifies length %hu, but only %zu bytes remain",
2802 length
, STREAM_READABLE(peer
->curr
));
2803 return bgp_attr_malformed(
2804 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2809 * Check that the portion of the TLV containing the sequence of
2810 * SRGBs corresponds to a multiple of the SRGB size; to get
2811 * that length, we skip the 16 bit flags field
2813 stream_getw(peer
->curr
);
2815 if (length
% BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
) {
2818 "Prefix SID Originator SRGB length field claims attribute SRGB sequence section is %hubytes, but it must be a multiple of %u",
2819 length
, BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
);
2820 return bgp_attr_malformed(
2821 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2825 srgb_count
= length
/ BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
;
2827 for (int i
= 0; i
< srgb_count
; i
++) {
2828 stream_get(&srgb_base
, peer
->curr
, 3);
2829 stream_get(&srgb_range
, peer
->curr
, 3);
2833 /* Placeholder code for the VPN-SID Service type */
2834 else if (type
== BGP_PREFIX_SID_VPN_SID
) {
2835 if (STREAM_READABLE(peer
->curr
) < length
2836 || length
!= BGP_PREFIX_SID_VPN_SID_LENGTH
) {
2837 flog_err(EC_BGP_ATTR_LEN
,
2838 "Prefix SID VPN SID length is %hu instead of %u",
2839 length
, BGP_PREFIX_SID_VPN_SID_LENGTH
);
2840 return bgp_attr_malformed(args
,
2841 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2845 /* Parse VPN-SID Sub-TLV */
2846 stream_getc(peer
->curr
); /* reserved */
2847 sid_type
= stream_getc(peer
->curr
); /* sid_type */
2848 sid_flags
= stream_getc(peer
->curr
); /* sid_flags */
2849 stream_get(&ipv6_sid
, peer
->curr
,
2850 sizeof(ipv6_sid
)); /* sid_value */
2852 /* Log VPN-SID Sub-TLV */
2853 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
)) {
2854 inet_ntop(AF_INET6
, &ipv6_sid
, buf
, sizeof(buf
));
2856 "%s: vpn-sid: sid %s, sid-type 0x%02x sid-flags 0x%02x",
2857 __func__
, buf
, sid_type
, sid_flags
);
2860 /* Configure from Info */
2861 if (attr
->srv6_vpn
) {
2862 flog_err(EC_BGP_ATTRIBUTE_REPEATED
,
2863 "Prefix SID SRv6 VPN field repeated");
2864 return bgp_attr_malformed(
2865 args
, BGP_NOTIFY_UPDATE_MAL_ATTR
, args
->total
);
2867 attr
->srv6_vpn
= XCALLOC(MTYPE_BGP_SRV6_VPN
,
2868 sizeof(struct bgp_attr_srv6_vpn
));
2869 attr
->srv6_vpn
->sid_flags
= sid_flags
;
2870 sid_copy(&attr
->srv6_vpn
->sid
, &ipv6_sid
);
2871 attr
->srv6_vpn
= srv6_vpn_intern(attr
->srv6_vpn
);
2874 /* Placeholder code for the SRv6 L3 Service type */
2875 else if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE
) {
2876 if (STREAM_READABLE(peer
->curr
) < length
) {
2879 "Prefix SID SRv6 L3-Service length is %hu, but only %zu bytes remain",
2880 length
, STREAM_READABLE(peer
->curr
));
2881 return bgp_attr_malformed(args
,
2882 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2886 /* ignore reserved */
2887 stream_getc(peer
->curr
);
2889 return bgp_attr_srv6_service(args
);
2892 /* Placeholder code for Unsupported TLV */
2895 if (STREAM_READABLE(peer
->curr
) < length
) {
2898 "Prefix SID SRv6 length is %hu - too long, only %zu remaining in this UPDATE",
2899 length
, STREAM_READABLE(peer
->curr
));
2900 return bgp_attr_malformed(
2901 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2905 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2907 "%s attr Prefix-SID sub-type=%u is not supported, skipped",
2910 stream_forward_getp(peer
->curr
, length
);
2913 return BGP_ATTR_PARSE_PROCEED
;
2916 /* Prefix SID attribute
2917 * draft-ietf-idr-bgp-prefix-sid-05
2919 bgp_attr_parse_ret_t
bgp_attr_prefix_sid(struct bgp_attr_parser_args
*args
)
2921 struct peer
*const peer
= args
->peer
;
2922 struct attr
*const attr
= args
->attr
;
2923 bgp_attr_parse_ret_t ret
;
2925 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
);
2929 size_t headersz
= sizeof(type
) + sizeof(length
);
2930 size_t psid_parsed_length
= 0;
2932 while (STREAM_READABLE(peer
->curr
) > 0
2933 && psid_parsed_length
< args
->length
) {
2935 if (STREAM_READABLE(peer
->curr
) < headersz
) {
2938 "Malformed Prefix SID attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
2939 headersz
, STREAM_READABLE(peer
->curr
));
2940 return bgp_attr_malformed(
2941 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2945 type
= stream_getc(peer
->curr
);
2946 length
= stream_getw(peer
->curr
);
2948 if (STREAM_READABLE(peer
->curr
) < length
) {
2951 "Malformed Prefix SID attribute - insufficient data (need %hu for attribute body, have %zu remaining in UPDATE)",
2952 length
, STREAM_READABLE(peer
->curr
));
2953 return bgp_attr_malformed(args
,
2954 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2958 ret
= bgp_attr_psid_sub(type
, length
, args
);
2960 if (ret
!= BGP_ATTR_PARSE_PROCEED
)
2963 psid_parsed_length
+= length
+ headersz
;
2965 if (psid_parsed_length
> args
->length
) {
2968 "Malformed Prefix SID attribute - TLV overflow by attribute (need %zu for TLV length, have %zu overflowed in UPDATE)",
2969 length
+ headersz
, psid_parsed_length
- (length
+ headersz
));
2970 return bgp_attr_malformed(
2971 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2976 return BGP_ATTR_PARSE_PROCEED
;
2979 /* PMSI tunnel attribute (RFC 6514)
2980 * Basic validation checks done here.
2982 static bgp_attr_parse_ret_t
2983 bgp_attr_pmsi_tunnel(struct bgp_attr_parser_args
*args
)
2985 struct peer
*const peer
= args
->peer
;
2986 struct attr
*const attr
= args
->attr
;
2987 const bgp_size_t length
= args
->length
;
2989 int attr_parse_len
= 2 + BGP_LABEL_BYTES
;
2991 /* Verify that the receiver is expecting "ingress replication" as we
2992 * can only support that.
2994 if (length
< attr_parse_len
) {
2995 flog_err(EC_BGP_ATTR_LEN
, "Bad PMSI tunnel attribute length %d",
2997 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3000 stream_getc(peer
->curr
); /* Flags */
3001 tnl_type
= stream_getc(peer
->curr
);
3002 if (tnl_type
> PMSI_TNLTYPE_MAX
) {
3003 flog_err(EC_BGP_ATTR_PMSI_TYPE
,
3004 "Invalid PMSI tunnel attribute type %d", tnl_type
);
3005 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
3008 if (tnl_type
== PMSI_TNLTYPE_INGR_REPL
) {
3010 flog_err(EC_BGP_ATTR_PMSI_LEN
,
3011 "Bad PMSI tunnel attribute length %d for IR",
3013 return bgp_attr_malformed(
3014 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3019 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
);
3020 bgp_attr_set_pmsi_tnl_type(attr
, tnl_type
);
3021 stream_get(&attr
->label
, peer
->curr
, BGP_LABEL_BYTES
);
3023 /* Forward read pointer of input stream. */
3024 stream_forward_getp(peer
->curr
, length
- attr_parse_len
);
3026 return BGP_ATTR_PARSE_PROCEED
;
3029 /* BGP unknown attribute treatment. */
3030 static bgp_attr_parse_ret_t
bgp_attr_unknown(struct bgp_attr_parser_args
*args
)
3032 bgp_size_t total
= args
->total
;
3033 struct transit
*transit
;
3034 struct peer
*const peer
= args
->peer
;
3035 struct attr
*const attr
= args
->attr
;
3036 uint8_t *const startp
= args
->startp
;
3037 const uint8_t type
= args
->type
;
3038 const uint8_t flag
= args
->flags
;
3039 const bgp_size_t length
= args
->length
;
3041 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
3043 "%s Unknown attribute is received (type %d, length %d)",
3044 peer
->host
, type
, length
);
3046 /* Forward read pointer of input stream. */
3047 stream_forward_getp(peer
->curr
, length
);
3049 /* If any of the mandatory well-known attributes are not recognized,
3050 then the Error Subcode is set to Unrecognized Well-known
3051 Attribute. The Data field contains the unrecognized attribute
3052 (type, length and value). */
3053 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_OPTIONAL
)) {
3054 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_UNREC_ATTR
,
3058 /* Unrecognized non-transitive optional attributes must be quietly
3059 ignored and not passed along to other BGP peers. */
3060 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_TRANS
))
3061 return BGP_ATTR_PARSE_PROCEED
;
3063 /* If a path with recognized transitive optional attribute is
3064 accepted and passed along to other BGP peers and the Partial bit
3065 in the Attribute Flags octet is set to 1 by some previous AS, it
3066 is not set back to 0 by the current AS. */
3067 SET_FLAG(*startp
, BGP_ATTR_FLAG_PARTIAL
);
3069 /* Store transitive attribute to the end of attr->transit. */
3070 transit
= bgp_attr_get_transit(attr
);
3072 transit
= XCALLOC(MTYPE_TRANSIT
, sizeof(struct transit
));
3074 transit
->val
= XREALLOC(MTYPE_TRANSIT_VAL
, transit
->val
,
3075 transit
->length
+ total
);
3077 memcpy(transit
->val
+ transit
->length
, startp
, total
);
3078 transit
->length
+= total
;
3079 bgp_attr_set_transit(attr
, transit
);
3081 return BGP_ATTR_PARSE_PROCEED
;
3084 /* Well-known attribute check. */
3085 static int bgp_attr_check(struct peer
*peer
, struct attr
*attr
)
3089 /* BGP Graceful-Restart End-of-RIB for IPv4 unicast is signaled as an
3091 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
) && !attr
->flag
)
3092 return BGP_ATTR_PARSE_PROCEED
;
3094 /* "An UPDATE message that contains the MP_UNREACH_NLRI is not required
3095 to carry any other path attributes.", though if MP_REACH_NLRI or NLRI
3096 are present, it should. Check for any other attribute being present
3099 if ((!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
)) &&
3100 CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
))))
3101 return BGP_ATTR_PARSE_PROCEED
;
3103 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
)))
3104 type
= BGP_ATTR_ORIGIN
;
3106 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
)))
3107 type
= BGP_ATTR_AS_PATH
;
3109 /* RFC 2858 makes Next-Hop optional/ignored, if MP_REACH_NLRI is present
3111 * NLRI is empty. We can't easily check NLRI empty here though.
3113 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
))
3114 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
)))
3115 type
= BGP_ATTR_NEXT_HOP
;
3117 if (peer
->sort
== BGP_PEER_IBGP
3118 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)))
3119 type
= BGP_ATTR_LOCAL_PREF
;
3121 /* If any of the well-known mandatory attributes are not present
3122 * in an UPDATE message, then "treat-as-withdraw" MUST be used.
3125 flog_warn(EC_BGP_MISSING_ATTRIBUTE
,
3126 "%s Missing well-known attribute %s.", peer
->host
,
3127 lookup_msg(attr_str
, type
, NULL
));
3128 return BGP_ATTR_PARSE_WITHDRAW
;
3130 return BGP_ATTR_PARSE_PROCEED
;
3133 /* Read attribute of update packet. This function is called from
3134 bgp_update_receive() in bgp_packet.c. */
3135 bgp_attr_parse_ret_t
bgp_attr_parse(struct peer
*peer
, struct attr
*attr
,
3136 bgp_size_t size
, struct bgp_nlri
*mp_update
,
3137 struct bgp_nlri
*mp_withdraw
)
3139 bgp_attr_parse_ret_t ret
;
3143 uint8_t *startp
, *endp
;
3145 uint8_t seen
[BGP_ATTR_BITMAP_SIZE
];
3146 /* we need the as4_path only until we have synthesized the as_path with
3148 /* same goes for as4_aggregator */
3149 struct aspath
*as4_path
= NULL
;
3150 as_t as4_aggregator
= 0;
3151 struct in_addr as4_aggregator_addr
= {.s_addr
= 0};
3152 struct transit
*transit
;
3154 /* Initialize bitmap. */
3155 memset(seen
, 0, BGP_ATTR_BITMAP_SIZE
);
3157 /* End pointer of BGP attribute. */
3158 endp
= BGP_INPUT_PNT(peer
) + size
;
3160 /* Get attributes to the end of attribute length. */
3161 while (BGP_INPUT_PNT(peer
) < endp
) {
3162 /* Check remaining length check.*/
3163 if (endp
- BGP_INPUT_PNT(peer
) < BGP_ATTR_MIN_LEN
) {
3164 /* XXX warning: long int format, int arg (arg 5) */
3166 EC_BGP_ATTRIBUTE_TOO_SMALL
,
3167 "%s: error BGP attribute length %lu is smaller than min len",
3169 (unsigned long)(endp
3170 - stream_pnt(BGP_INPUT(peer
))));
3172 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3173 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3174 ret
= BGP_ATTR_PARSE_ERROR
;
3178 /* Fetch attribute flag and type. */
3179 startp
= BGP_INPUT_PNT(peer
);
3180 /* "The lower-order four bits of the Attribute Flags octet are
3181 unused. They MUST be zero when sent and MUST be ignored when
3183 flag
= 0xF0 & stream_getc(BGP_INPUT(peer
));
3184 type
= stream_getc(BGP_INPUT(peer
));
3186 /* Check whether Extended-Length applies and is in bounds */
3187 if (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
)
3188 && ((endp
- startp
) < (BGP_ATTR_MIN_LEN
+ 1))) {
3190 EC_BGP_EXT_ATTRIBUTE_TOO_SMALL
,
3191 "%s: Extended length set, but just %lu bytes of attr header",
3193 (unsigned long)(endp
3194 - stream_pnt(BGP_INPUT(peer
))));
3196 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3197 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3198 ret
= BGP_ATTR_PARSE_ERROR
;
3202 /* Check extended attribue length bit. */
3203 if (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
))
3204 length
= stream_getw(BGP_INPUT(peer
));
3206 length
= stream_getc(BGP_INPUT(peer
));
3208 /* If any attribute appears more than once in the UPDATE
3209 message, then the Error Subcode is set to Malformed Attribute
3212 if (CHECK_BITMAP(seen
, type
)) {
3214 EC_BGP_ATTRIBUTE_REPEATED
,
3215 "%s: error BGP attribute type %d appears twice in a message",
3218 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3219 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3220 ret
= BGP_ATTR_PARSE_ERROR
;
3224 /* Set type to bitmap to check duplicate attribute. `type' is
3225 unsigned char so it never overflow bitmap range. */
3227 SET_BITMAP(seen
, type
);
3229 /* Overflow check. */
3230 attr_endp
= BGP_INPUT_PNT(peer
) + length
;
3232 if (attr_endp
> endp
) {
3234 EC_BGP_ATTRIBUTE_TOO_LARGE
,
3235 "%s: BGP type %d length %d is too large, attribute total length is %d. attr_endp is %p. endp is %p",
3236 peer
->host
, type
, length
, size
, attr_endp
,
3240 * If any recognized attribute has an Attribute
3241 * Length that conflicts with the expected length
3242 * (based on the attribute type code), then the
3243 * Error Subcode MUST be set to Attribute Length
3244 * Error. The Data field MUST contain the erroneous
3245 * attribute (type, length, and value).
3247 * We do not currently have a good way to determine the
3248 * length of the attribute independent of the length
3249 * received in the message. Instead we send the
3250 * minimum between the amount of data we have and the
3251 * amount specified by the attribute length field.
3253 * Instead of directly passing in the packet buffer and
3254 * offset we use the stream_get* functions to read into
3255 * a stack buffer, since they perform bounds checking
3256 * and we are working with untrusted data.
3258 unsigned char ndata
[peer
->max_packet_size
];
3259 memset(ndata
, 0x00, sizeof(ndata
));
3261 CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
) ? 2 : 1;
3262 /* Rewind to end of flag field */
3263 stream_rewind_getp(BGP_INPUT(peer
), (1 + lfl
));
3265 stream_get(&ndata
[0], BGP_INPUT(peer
), 1);
3267 stream_get(&ndata
[1], BGP_INPUT(peer
), lfl
);
3269 size_t atl
= attr_endp
- startp
;
3270 size_t ndl
= MIN(atl
, STREAM_READABLE(BGP_INPUT(peer
)));
3271 stream_get(&ndata
[lfl
+ 1], BGP_INPUT(peer
), ndl
);
3273 bgp_notify_send_with_data(
3274 peer
, BGP_NOTIFY_UPDATE_ERR
,
3275 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
, ndata
,
3278 ret
= BGP_ATTR_PARSE_ERROR
;
3282 struct bgp_attr_parser_args attr_args
= {
3289 .total
= attr_endp
- startp
,
3293 /* If any recognized attribute has Attribute Flags that conflict
3294 with the Attribute Type Code, then the Error Subcode is set
3296 Attribute Flags Error. The Data field contains the erroneous
3297 attribute (type, length and value). */
3298 if (bgp_attr_flag_invalid(&attr_args
)) {
3299 ret
= bgp_attr_malformed(
3300 &attr_args
, BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR
,
3302 if (ret
== BGP_ATTR_PARSE_PROCEED
)
3307 /* OK check attribute and store it's value. */
3309 case BGP_ATTR_ORIGIN
:
3310 ret
= bgp_attr_origin(&attr_args
);
3312 case BGP_ATTR_AS_PATH
:
3313 ret
= bgp_attr_aspath(&attr_args
);
3315 case BGP_ATTR_AS4_PATH
:
3316 ret
= bgp_attr_as4_path(&attr_args
, &as4_path
);
3318 case BGP_ATTR_NEXT_HOP
:
3319 ret
= bgp_attr_nexthop(&attr_args
);
3321 case BGP_ATTR_MULTI_EXIT_DISC
:
3322 ret
= bgp_attr_med(&attr_args
);
3324 case BGP_ATTR_LOCAL_PREF
:
3325 ret
= bgp_attr_local_pref(&attr_args
);
3327 case BGP_ATTR_ATOMIC_AGGREGATE
:
3328 ret
= bgp_attr_atomic(&attr_args
);
3330 case BGP_ATTR_AGGREGATOR
:
3331 ret
= bgp_attr_aggregator(&attr_args
);
3333 case BGP_ATTR_AS4_AGGREGATOR
:
3334 ret
= bgp_attr_as4_aggregator(&attr_args
,
3336 &as4_aggregator_addr
);
3338 case BGP_ATTR_COMMUNITIES
:
3339 ret
= bgp_attr_community(&attr_args
);
3341 case BGP_ATTR_LARGE_COMMUNITIES
:
3342 ret
= bgp_attr_large_community(&attr_args
);
3344 case BGP_ATTR_ORIGINATOR_ID
:
3345 ret
= bgp_attr_originator_id(&attr_args
);
3347 case BGP_ATTR_CLUSTER_LIST
:
3348 ret
= bgp_attr_cluster_list(&attr_args
);
3350 case BGP_ATTR_MP_REACH_NLRI
:
3351 ret
= bgp_mp_reach_parse(&attr_args
, mp_update
);
3353 case BGP_ATTR_MP_UNREACH_NLRI
:
3354 ret
= bgp_mp_unreach_parse(&attr_args
, mp_withdraw
);
3356 case BGP_ATTR_EXT_COMMUNITIES
:
3357 ret
= bgp_attr_ext_communities(&attr_args
);
3359 #ifdef ENABLE_BGP_VNC_ATTR
3362 case BGP_ATTR_ENCAP
:
3363 ret
= bgp_attr_encap(type
, peer
, length
, attr
, flag
,
3366 case BGP_ATTR_PREFIX_SID
:
3367 ret
= bgp_attr_prefix_sid(&attr_args
);
3369 case BGP_ATTR_PMSI_TUNNEL
:
3370 ret
= bgp_attr_pmsi_tunnel(&attr_args
);
3372 case BGP_ATTR_IPV6_EXT_COMMUNITIES
:
3373 ret
= bgp_attr_ipv6_ext_communities(&attr_args
);
3376 ret
= bgp_attr_unknown(&attr_args
);
3380 if (ret
== BGP_ATTR_PARSE_ERROR_NOTIFYPLS
) {
3381 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3382 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3383 ret
= BGP_ATTR_PARSE_ERROR
;
3387 if (ret
== BGP_ATTR_PARSE_EOR
) {
3391 if (ret
== BGP_ATTR_PARSE_ERROR
) {
3392 flog_warn(EC_BGP_ATTRIBUTE_PARSE_ERROR
,
3393 "%s: Attribute %s, parse error", peer
->host
,
3394 lookup_msg(attr_str
, type
, NULL
));
3397 if (ret
== BGP_ATTR_PARSE_WITHDRAW
) {
3399 EC_BGP_ATTRIBUTE_PARSE_WITHDRAW
,
3400 "%s: Attribute %s, parse error - treating as withdrawal",
3401 peer
->host
, lookup_msg(attr_str
, type
, NULL
));
3405 /* Check the fetched length. */
3406 if (BGP_INPUT_PNT(peer
) != attr_endp
) {
3407 flog_warn(EC_BGP_ATTRIBUTE_FETCH_ERROR
,
3408 "%s: BGP attribute %s, fetch error",
3409 peer
->host
, lookup_msg(attr_str
, type
, NULL
));
3410 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3411 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3412 ret
= BGP_ATTR_PARSE_ERROR
;
3418 * draft-ietf-idr-bgp-prefix-sid-27#section-3:
3419 * About Prefix-SID path attribute,
3420 * Label-Index TLV(type1) and The Originator SRGB TLV(type-3)
3421 * may only appear in a BGP Prefix-SID attribute attached to
3422 * IPv4/IPv6 Labeled Unicast prefixes ([RFC8277]).
3423 * It MUST be ignored when received for other BGP AFI/SAFI combinations.
3425 if (!attr
->mp_nexthop_len
|| mp_update
->safi
!= SAFI_LABELED_UNICAST
)
3426 attr
->label_index
= BGP_INVALID_LABEL_INDEX
;
3428 /* Check final read pointer is same as end pointer. */
3429 if (BGP_INPUT_PNT(peer
) != endp
) {
3430 flog_warn(EC_BGP_ATTRIBUTES_MISMATCH
,
3431 "%s: BGP attribute %s, length mismatch", peer
->host
,
3432 lookup_msg(attr_str
, type
, NULL
));
3433 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3434 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3436 ret
= BGP_ATTR_PARSE_ERROR
;
3441 * RFC4271: If the NEXT_HOP attribute field is syntactically incorrect,
3442 * then the Error Subcode MUST be set to Invalid NEXT_HOP Attribute.
3443 * This is implemented below and will result in a NOTIFICATION. If the
3444 * NEXT_HOP attribute is semantically incorrect, the error SHOULD be
3445 * logged, and the route SHOULD be ignored. In this case, a NOTIFICATION
3446 * message SHOULD NOT be sent. This is implemented elsewhere.
3448 * RFC4760: An UPDATE message that carries no NLRI, other than the one
3449 * encoded in the MP_REACH_NLRI attribute, SHOULD NOT carry the NEXT_HOP
3450 * attribute. If such a message contains the NEXT_HOP attribute, the BGP
3451 * speaker that receives the message SHOULD ignore this attribute.
3453 if (CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
))
3454 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
))) {
3455 if (bgp_attr_nexthop_valid(peer
, attr
) < 0) {
3456 ret
= BGP_ATTR_PARSE_ERROR
;
3461 /* Check all mandatory well-known attributes are present */
3462 ret
= bgp_attr_check(peer
, attr
);
3467 * At this place we can see whether we got AS4_PATH and/or
3468 * AS4_AGGREGATOR from a 16Bit peer and act accordingly.
3469 * We can not do this before we've read all attributes because
3470 * the as4 handling does not say whether AS4_PATH has to be sent
3471 * after AS_PATH or not - and when AS4_AGGREGATOR will be send
3472 * in relationship to AGGREGATOR.
3473 * So, to be defensive, we are not relying on any order and read
3474 * all attributes first, including these 32bit ones, and now,
3475 * afterwards, we look what and if something is to be done for as4.
3477 * It is possible to not have AS_PATH, e.g. GR EoR and sole
3480 /* actually... this doesn't ever return failure currently, but
3481 * better safe than sorry */
3482 if (CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
))
3483 && bgp_attr_munge_as4_attrs(peer
, attr
, as4_path
, as4_aggregator
,
3484 &as4_aggregator_addr
)) {
3485 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3486 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3487 ret
= BGP_ATTR_PARSE_ERROR
;
3492 * Finally do the checks on the aspath we did not do yet
3493 * because we waited for a potentially synthesized aspath.
3495 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
))) {
3496 ret
= bgp_attr_aspath_check(peer
, attr
);
3497 if (ret
!= BGP_ATTR_PARSE_PROCEED
)
3501 ret
= BGP_ATTR_PARSE_PROCEED
;
3505 * At this stage, we have done all fiddling with as4, and the
3506 * resulting info is in attr->aggregator resp. attr->aspath so
3507 * we can chuck as4_aggregator and as4_path alltogether in order
3511 * unintern - it is in the hash
3512 * The flag that we got this is still there, but that
3513 * does not do any trouble
3515 aspath_unintern(&as4_path
);
3517 transit
= bgp_attr_get_transit(attr
);
3518 if (ret
!= BGP_ATTR_PARSE_ERROR
) {
3519 /* Finally intern unknown attribute. */
3521 bgp_attr_set_transit(attr
, transit_intern(transit
));
3522 if (attr
->encap_subtlvs
)
3523 attr
->encap_subtlvs
= encap_intern(attr
->encap_subtlvs
,
3525 #ifdef ENABLE_BGP_VNC
3526 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
3527 bgp_attr_get_vnc_subtlvs(attr
);
3530 bgp_attr_set_vnc_subtlvs(
3532 encap_intern(vnc_subtlvs
, VNC_SUBTLV_TYPE
));
3536 transit_free(transit
);
3537 bgp_attr_set_transit(attr
, NULL
);
3540 bgp_attr_flush_encap(attr
);
3544 transit
= bgp_attr_get_transit(attr
);
3546 assert(transit
->refcnt
> 0);
3547 if (attr
->encap_subtlvs
)
3548 assert(attr
->encap_subtlvs
->refcnt
> 0);
3549 #ifdef ENABLE_BGP_VNC
3550 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
3551 bgp_attr_get_vnc_subtlvs(attr
);
3554 assert(vnc_subtlvs
->refcnt
> 0);
3561 * Extract the tunnel type from extended community
3563 void bgp_attr_extcom_tunnel_type(struct attr
*attr
,
3564 bgp_encap_types
*tunnel_type
)
3566 struct ecommunity
*ecom
;
3572 ecom
= bgp_attr_get_ecommunity(attr
);
3573 if (!ecom
|| !ecom
->size
)
3576 for (i
= 0; i
< ecom
->size
; i
++) {
3578 uint8_t type
, sub_type
;
3580 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
3583 if (!(type
== ECOMMUNITY_ENCODE_OPAQUE
&&
3584 sub_type
== ECOMMUNITY_OPAQUE_SUBTYPE_ENCAP
))
3586 *tunnel_type
= ((pnt
[6] << 8) | pnt
[7]);
3593 size_t bgp_packet_mpattr_start(struct stream
*s
, struct peer
*peer
, afi_t afi
,
3594 safi_t safi
, struct bpacket_attr_vec_arr
*vecarr
,
3599 iana_safi_t pkt_safi
;
3602 /* Set extended bit always to encode the attribute length as 2 bytes */
3603 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_EXTLEN
);
3604 stream_putc(s
, BGP_ATTR_MP_REACH_NLRI
);
3605 sizep
= stream_get_endp(s
);
3606 stream_putw(s
, 0); /* Marker: Attribute length. */
3609 /* Convert AFI, SAFI to values for packet. */
3610 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
3612 stream_putw(s
, pkt_afi
); /* AFI */
3613 stream_putc(s
, pkt_safi
); /* SAFI */
3617 && (safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
3618 || safi
== SAFI_MPLS_VPN
|| safi
== SAFI_MULTICAST
))
3619 nh_afi
= peer_cap_enhe(peer
, afi
, safi
) ? AFI_IP6
: AFI_IP
;
3620 else if (safi
== SAFI_FLOWSPEC
)
3623 nh_afi
= BGP_NEXTHOP_AFI_FROM_NHLEN(attr
->mp_nexthop_len
);
3626 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
, attr
);
3631 case SAFI_MULTICAST
:
3632 case SAFI_LABELED_UNICAST
:
3634 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
3638 stream_putl(s
, 0); /* RD = 0, per RFC */
3640 stream_put(s
, &attr
->mp_nexthop_global_in
, 4);
3645 stream_put(s
, &attr
->mp_nexthop_global_in
, 4);
3648 if (attr
->mp_nexthop_len
== 0)
3649 stream_putc(s
, 0); /* no nexthop for flowspec */
3651 stream_putc(s
, attr
->mp_nexthop_len
);
3652 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
3661 case SAFI_MULTICAST
:
3662 case SAFI_LABELED_UNICAST
:
3664 if (attr
->mp_nexthop_len
3665 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
3667 BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
);
3668 stream_put(s
, &attr
->mp_nexthop_global
,
3670 stream_put(s
, &attr
->mp_nexthop_local
,
3673 stream_putc(s
, IPV6_MAX_BYTELEN
);
3674 stream_put(s
, &attr
->mp_nexthop_global
,
3678 case SAFI_MPLS_VPN
: {
3679 if (attr
->mp_nexthop_len
3680 == BGP_ATTR_NHLEN_IPV6_GLOBAL
) {
3682 stream_putl(s
, 0); /* RD = 0, per RFC */
3684 stream_put(s
, &attr
->mp_nexthop_global
,
3686 } else if (attr
->mp_nexthop_len
3687 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
3689 stream_putl(s
, 0); /* RD = 0, per RFC */
3691 stream_put(s
, &attr
->mp_nexthop_global
,
3693 stream_putl(s
, 0); /* RD = 0, per RFC */
3695 stream_put(s
, &attr
->mp_nexthop_local
,
3700 stream_putc(s
, IPV6_MAX_BYTELEN
);
3701 stream_put(s
, &attr
->mp_nexthop_global
,
3705 stream_putc(s
, 0); /* no nexthop for flowspec */
3711 if (safi
!= SAFI_FLOWSPEC
)
3713 EC_BGP_ATTR_NH_SEND_LEN
,
3714 "Bad nexthop when sending to %s, AFI %u SAFI %u nhlen %d",
3715 peer
->host
, afi
, safi
, attr
->mp_nexthop_len
);
3724 void bgp_packet_mpattr_prefix(struct stream
*s
, afi_t afi
, safi_t safi
,
3725 const struct prefix
*p
,
3726 const struct prefix_rd
*prd
, mpls_label_t
*label
,
3727 uint32_t num_labels
, bool addpath_capable
,
3728 uint32_t addpath_tx_id
, struct attr
*attr
)
3730 if (safi
== SAFI_MPLS_VPN
) {
3731 if (addpath_capable
)
3732 stream_putl(s
, addpath_tx_id
);
3733 /* Label, RD, Prefix write. */
3734 stream_putc(s
, p
->prefixlen
+ 88);
3735 stream_put(s
, label
, BGP_LABEL_BYTES
);
3736 stream_put(s
, prd
->val
, 8);
3737 stream_put(s
, &p
->u
.prefix
, PSIZE(p
->prefixlen
));
3738 } else if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
3739 /* EVPN prefix - contents depend on type */
3740 bgp_evpn_encode_prefix(s
, p
, prd
, label
, num_labels
, attr
,
3741 addpath_capable
, addpath_tx_id
);
3742 } else if (safi
== SAFI_LABELED_UNICAST
) {
3743 /* Prefix write with label. */
3744 stream_put_labeled_prefix(s
, p
, label
, addpath_capable
,
3746 } else if (safi
== SAFI_FLOWSPEC
) {
3747 stream_putc(s
, p
->u
.prefix_flowspec
.prefixlen
);
3748 stream_put(s
, (const void *)p
->u
.prefix_flowspec
.ptr
,
3749 p
->u
.prefix_flowspec
.prefixlen
);
3751 stream_put_prefix_addpath(s
, p
, addpath_capable
, addpath_tx_id
);
3754 size_t bgp_packet_mpattr_prefix_size(afi_t afi
, safi_t safi
,
3755 const struct prefix
*p
)
3757 int size
= PSIZE(p
->prefixlen
);
3758 if (safi
== SAFI_MPLS_VPN
)
3760 else if (safi
== SAFI_LABELED_UNICAST
)
3761 size
+= BGP_LABEL_BYTES
;
3762 else if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
)
3763 size
+= 232; // TODO: Maximum possible for type-2, type-3 and
3769 * Encodes the tunnel encapsulation attribute,
3770 * and with ENABLE_BGP_VNC the VNC attribute which uses
3771 * almost the same TLV format
3773 static void bgp_packet_mpattr_tea(struct bgp
*bgp
, struct peer
*peer
,
3774 struct stream
*s
, struct attr
*attr
,
3777 unsigned int attrlenfield
= 0;
3778 unsigned int attrhdrlen
= 0;
3779 struct bgp_attr_encap_subtlv
*subtlvs
;
3780 struct bgp_attr_encap_subtlv
*st
;
3781 const char *attrname
;
3783 if (!attr
|| (attrtype
== BGP_ATTR_ENCAP
3784 && (!attr
->encap_tunneltype
3785 || attr
->encap_tunneltype
== BGP_ENCAP_TYPE_MPLS
)))
3789 case BGP_ATTR_ENCAP
:
3790 attrname
= "Tunnel Encap";
3791 subtlvs
= attr
->encap_subtlvs
;
3792 if (subtlvs
== NULL
) /* nothing to do */
3795 * The tunnel encap attr has an "outer" tlv.
3797 * L = total length of subtlvs,
3798 * V = concatenated subtlvs.
3800 attrlenfield
= 2 + 2; /* T + L */
3801 attrhdrlen
= 1 + 1; /* subTLV T + L */
3804 #ifdef ENABLE_BGP_VNC_ATTR
3807 subtlvs
= bgp_attr_get_vnc_subtlvs(attr
);
3808 if (subtlvs
== NULL
) /* nothing to do */
3810 attrlenfield
= 0; /* no outer T + L */
3811 attrhdrlen
= 2 + 2; /* subTLV T + L */
3819 /* compute attr length */
3820 for (st
= subtlvs
; st
; st
= st
->next
) {
3821 attrlenfield
+= (attrhdrlen
+ st
->length
);
3824 if (attrlenfield
> 0xffff) {
3825 zlog_info("%s attribute is too long (length=%d), can't send it",
3826 attrname
, attrlenfield
);
3830 if (attrlenfield
> 0xff) {
3831 /* 2-octet length field */
3833 BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
3834 | BGP_ATTR_FLAG_EXTLEN
);
3835 stream_putc(s
, attrtype
);
3836 stream_putw(s
, attrlenfield
& 0xffff);
3838 /* 1-octet length field */
3839 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
);
3840 stream_putc(s
, attrtype
);
3841 stream_putc(s
, attrlenfield
& 0xff);
3844 if (attrtype
== BGP_ATTR_ENCAP
) {
3845 /* write outer T+L */
3846 stream_putw(s
, attr
->encap_tunneltype
);
3847 stream_putw(s
, attrlenfield
- 4);
3850 /* write each sub-tlv */
3851 for (st
= subtlvs
; st
; st
= st
->next
) {
3852 if (attrtype
== BGP_ATTR_ENCAP
) {
3853 stream_putc(s
, st
->type
);
3854 stream_putc(s
, st
->length
);
3855 #ifdef ENABLE_BGP_VNC
3857 stream_putw(s
, st
->type
);
3858 stream_putw(s
, st
->length
);
3861 stream_put(s
, st
->value
, st
->length
);
3865 void bgp_packet_mpattr_end(struct stream
*s
, size_t sizep
)
3867 /* Set MP attribute length. Don't count the (2) bytes used to encode
3869 stream_putw_at(s
, sizep
, (stream_get_endp(s
) - sizep
) - 2);
3872 static bool bgp_append_local_as(struct peer
*peer
, afi_t afi
, safi_t safi
)
3874 if (!BGP_AS_IS_PRIVATE(peer
->local_as
)
3875 || (BGP_AS_IS_PRIVATE(peer
->local_as
)
3876 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3877 PEER_FLAG_REMOVE_PRIVATE_AS
)
3878 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3879 PEER_FLAG_REMOVE_PRIVATE_AS_ALL
)
3880 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3881 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
)
3882 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3883 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
)))
3888 /* Make attribute packet. */
3889 bgp_size_t
bgp_packet_attribute(struct bgp
*bgp
, struct peer
*peer
,
3890 struct stream
*s
, struct attr
*attr
,
3891 struct bpacket_attr_vec_arr
*vecarr
,
3892 struct prefix
*p
, afi_t afi
, safi_t safi
,
3893 struct peer
*from
, struct prefix_rd
*prd
,
3894 mpls_label_t
*label
, uint32_t num_labels
,
3895 bool addpath_capable
, uint32_t addpath_tx_id
)
3898 size_t aspath_sizep
;
3899 struct aspath
*aspath
;
3900 int send_as4_path
= 0;
3901 int send_as4_aggregator
= 0;
3902 bool use32bit
= CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
3903 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
3908 /* Remember current pointer. */
3909 cp
= stream_get_endp(s
);
3912 && !((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
3913 && !peer_cap_enhe(peer
, afi
, safi
))) {
3914 size_t mpattrlen_pos
= 0;
3916 mpattrlen_pos
= bgp_packet_mpattr_start(s
, peer
, afi
, safi
,
3918 bgp_packet_mpattr_prefix(s
, afi
, safi
, p
, prd
, label
,
3919 num_labels
, addpath_capable
,
3920 addpath_tx_id
, attr
);
3921 bgp_packet_mpattr_end(s
, mpattrlen_pos
);
3924 /* Origin attribute. */
3925 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
3926 stream_putc(s
, BGP_ATTR_ORIGIN
);
3928 stream_putc(s
, attr
->origin
);
3930 /* AS path attribute. */
3932 /* If remote-peer is EBGP */
3933 if (peer
->sort
== BGP_PEER_EBGP
3934 && (!CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3935 PEER_FLAG_AS_PATH_UNCHANGED
)
3936 || attr
->aspath
->segments
== NULL
)
3937 && (!CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3938 PEER_FLAG_RSERVER_CLIENT
))) {
3939 aspath
= aspath_dup(attr
->aspath
);
3941 /* Even though we may not be configured for confederations we
3943 * RXed an AS_PATH with AS_CONFED_SEQUENCE or AS_CONFED_SET */
3944 aspath
= aspath_delete_confed_seq(aspath
);
3946 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
3947 /* Stuff our path CONFED_ID on the front */
3948 aspath
= aspath_add_seq(aspath
, bgp
->confed_id
);
3950 if (peer
->change_local_as
) {
3951 /* If replace-as is specified, we only use the
3952 change_local_as when
3953 advertising routes. */
3954 if (!CHECK_FLAG(peer
->flags
,
3955 PEER_FLAG_LOCAL_AS_REPLACE_AS
))
3956 if (bgp_append_local_as(peer
, afi
,
3958 aspath
= aspath_add_seq(
3959 aspath
, peer
->local_as
);
3960 aspath
= aspath_add_seq(aspath
,
3961 peer
->change_local_as
);
3963 aspath
= aspath_add_seq(aspath
, peer
->local_as
);
3966 } else if (peer
->sort
== BGP_PEER_CONFED
) {
3967 /* A confed member, so we need to do the AS_CONFED_SEQUENCE
3969 aspath
= aspath_dup(attr
->aspath
);
3970 aspath
= aspath_add_confed_seq(aspath
, peer
->local_as
);
3972 aspath
= attr
->aspath
;
3974 /* If peer is not AS4 capable, then:
3975 * - send the created AS_PATH out as AS4_PATH (optional, transitive),
3976 * but ensure that no AS_CONFED_SEQUENCE and AS_CONFED_SET path
3978 * types are in it (i.e. exclude them if they are there)
3979 * AND do this only if there is at least one asnum > 65535 in the
3981 * - send an AS_PATH out, but put 16Bit ASnums in it, not 32bit, and
3983 * all ASnums > 65535 to BGP_AS_TRANS
3986 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_EXTLEN
);
3987 stream_putc(s
, BGP_ATTR_AS_PATH
);
3988 aspath_sizep
= stream_get_endp(s
);
3990 stream_putw_at(s
, aspath_sizep
, aspath_put(s
, aspath
, use32bit
));
3992 /* OLD session may need NEW_AS_PATH sent, if there are 4-byte ASNs
3995 if (!use32bit
&& aspath_has_as4(aspath
))
3997 1; /* we'll do this later, at the correct place */
3999 /* Nexthop attribute. */
4000 if (afi
== AFI_IP
&& safi
== SAFI_UNICAST
4001 && !peer_cap_enhe(peer
, afi
, safi
)) {
4002 afi_t nh_afi
= BGP_NEXTHOP_AFI_FROM_NHLEN(attr
->mp_nexthop_len
);
4004 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
)) {
4005 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4006 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4007 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
,
4010 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4011 } else if (peer_cap_enhe(from
, afi
, safi
)
4012 || (nh_afi
== AFI_IP6
)) {
4014 * Likely this is the case when an IPv4 prefix was
4015 * received with Extended Next-hop capability in this
4016 * or another vrf and is now being advertised to
4017 * non-ENHE peers. Since peer_cap_enhe only checks
4018 * peers in this vrf, also check the nh_afi to catch
4019 * the case where the originator was in another vrf.
4020 * Setting the mandatory (ipv4) next-hop attribute here
4021 * to enable implicit next-hop self with correct A-F
4022 * (ipv4 address family).
4024 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4025 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4026 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
,
4029 stream_put_ipv4(s
, 0);
4033 /* MED attribute. */
4034 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
)
4035 || bgp
->maxmed_active
) {
4036 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4037 stream_putc(s
, BGP_ATTR_MULTI_EXIT_DISC
);
4039 stream_putl(s
, (bgp
->maxmed_active
? bgp
->maxmed_value
4043 /* Local preference. */
4044 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->sort
== BGP_PEER_CONFED
) {
4045 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4046 stream_putc(s
, BGP_ATTR_LOCAL_PREF
);
4048 stream_putl(s
, attr
->local_pref
);
4051 /* Atomic aggregate. */
4052 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
)) {
4053 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4054 stream_putc(s
, BGP_ATTR_ATOMIC_AGGREGATE
);
4059 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
)) {
4060 /* Common to BGP_ATTR_AGGREGATOR, regardless of ASN size */
4061 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4062 stream_putc(s
, BGP_ATTR_AGGREGATOR
);
4065 /* AS4 capable peer */
4067 stream_putl(s
, attr
->aggregator_as
);
4069 /* 2-byte AS peer */
4072 /* Is ASN representable in 2-bytes? Or must AS_TRANS be
4074 if (attr
->aggregator_as
> UINT16_MAX
) {
4075 stream_putw(s
, BGP_AS_TRANS
);
4077 /* we have to send AS4_AGGREGATOR, too.
4078 * we'll do that later in order to send
4079 * attributes in ascending
4082 send_as4_aggregator
= 1;
4084 stream_putw(s
, (uint16_t)attr
->aggregator_as
);
4086 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4089 /* Community attribute. */
4090 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
)
4091 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
))) {
4092 struct community
*comm
= NULL
;
4094 comm
= bgp_attr_get_community(attr
);
4095 if (comm
->size
* 4 > 255) {
4097 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4098 | BGP_ATTR_FLAG_EXTLEN
);
4099 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4100 stream_putw(s
, comm
->size
* 4);
4103 BGP_ATTR_FLAG_OPTIONAL
4104 | BGP_ATTR_FLAG_TRANS
);
4105 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4106 stream_putc(s
, comm
->size
* 4);
4108 stream_put(s
, comm
->val
, comm
->size
* 4);
4112 * Large Community attribute.
4114 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4115 PEER_FLAG_SEND_LARGE_COMMUNITY
)
4116 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
))) {
4117 if (lcom_length(bgp_attr_get_lcommunity(attr
)) > 255) {
4119 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4120 | BGP_ATTR_FLAG_EXTLEN
);
4121 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4123 lcom_length(bgp_attr_get_lcommunity(attr
)));
4126 BGP_ATTR_FLAG_OPTIONAL
4127 | BGP_ATTR_FLAG_TRANS
);
4128 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4130 lcom_length(bgp_attr_get_lcommunity(attr
)));
4132 stream_put(s
, bgp_attr_get_lcommunity(attr
)->val
,
4133 lcom_length(bgp_attr_get_lcommunity(attr
)));
4136 /* Route Reflector. */
4137 if (peer
->sort
== BGP_PEER_IBGP
&& from
4138 && from
->sort
== BGP_PEER_IBGP
) {
4139 struct cluster_list
*cluster
= bgp_attr_get_cluster(attr
);
4141 /* Originator ID. */
4142 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4143 stream_putc(s
, BGP_ATTR_ORIGINATOR_ID
);
4146 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
))
4147 stream_put_in_addr(s
, &attr
->originator_id
);
4149 stream_put_in_addr(s
, &from
->remote_id
);
4152 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4153 stream_putc(s
, BGP_ATTR_CLUSTER_LIST
);
4156 stream_putc(s
, cluster
->length
+ 4);
4157 /* If this peer configuration's parent BGP has
4159 if (bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
4160 stream_put_in_addr(s
, &bgp
->cluster_id
);
4162 stream_put_in_addr(s
, &bgp
->router_id
);
4163 stream_put(s
, cluster
->list
, cluster
->length
);
4166 /* If this peer configuration's parent BGP has
4168 if (bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
4169 stream_put_in_addr(s
, &bgp
->cluster_id
);
4171 stream_put_in_addr(s
, &bgp
->router_id
);
4175 /* Extended Communities attribute. */
4176 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
)
4177 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
))) {
4178 struct ecommunity
*ecomm
= bgp_attr_get_ecommunity(attr
);
4180 if (peer
->sort
== BGP_PEER_IBGP
4181 || peer
->sort
== BGP_PEER_CONFED
) {
4182 if (ecomm
->size
* 8 > 255) {
4184 BGP_ATTR_FLAG_OPTIONAL
4185 | BGP_ATTR_FLAG_TRANS
4186 | BGP_ATTR_FLAG_EXTLEN
);
4187 stream_putc(s
, BGP_ATTR_EXT_COMMUNITIES
);
4188 stream_putw(s
, ecomm
->size
* 8);
4191 BGP_ATTR_FLAG_OPTIONAL
4192 | BGP_ATTR_FLAG_TRANS
);
4193 stream_putc(s
, BGP_ATTR_EXT_COMMUNITIES
);
4194 stream_putc(s
, ecomm
->size
* 8);
4196 stream_put(s
, ecomm
->val
, ecomm
->size
* 8);
4200 int ecom_tr_size
= 0;
4203 for (i
= 0; i
< ecomm
->size
; i
++) {
4204 pnt
= ecomm
->val
+ (i
* 8);
4207 if (CHECK_FLAG(tbit
,
4208 ECOMMUNITY_FLAG_NON_TRANSITIVE
))
4215 if (ecom_tr_size
* 8 > 255) {
4218 BGP_ATTR_FLAG_OPTIONAL
4219 | BGP_ATTR_FLAG_TRANS
4220 | BGP_ATTR_FLAG_EXTLEN
);
4222 BGP_ATTR_EXT_COMMUNITIES
);
4223 stream_putw(s
, ecom_tr_size
* 8);
4227 BGP_ATTR_FLAG_OPTIONAL
4228 | BGP_ATTR_FLAG_TRANS
);
4230 BGP_ATTR_EXT_COMMUNITIES
);
4231 stream_putc(s
, ecom_tr_size
* 8);
4234 for (i
= 0; i
< ecomm
->size
; i
++) {
4235 pnt
= ecomm
->val
+ (i
* 8);
4240 ECOMMUNITY_FLAG_NON_TRANSITIVE
))
4243 stream_put(s
, pnt
, 8);
4249 /* Label index attribute. */
4250 if (safi
== SAFI_LABELED_UNICAST
) {
4251 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
)) {
4252 uint32_t label_index
;
4254 label_index
= attr
->label_index
;
4256 if (label_index
!= BGP_INVALID_LABEL_INDEX
) {
4258 BGP_ATTR_FLAG_OPTIONAL
4259 | BGP_ATTR_FLAG_TRANS
);
4260 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4262 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX
);
4264 BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
4265 stream_putc(s
, 0); // reserved
4266 stream_putw(s
, 0); // flags
4267 stream_putl(s
, label_index
);
4272 /* SRv6 Service Information Attribute. */
4273 if ((afi
== AFI_IP
|| afi
== AFI_IP6
) && safi
== SAFI_MPLS_VPN
) {
4274 if (attr
->srv6_l3vpn
) {
4275 uint8_t subtlv_len
=
4276 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
4278 + BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO_LENGTH
;
4279 uint8_t tlv_len
= subtlv_len
+ BGP_ATTR_MIN_LEN
+ 1;
4280 uint8_t attr_len
= tlv_len
+ BGP_ATTR_MIN_LEN
;
4281 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
4282 | BGP_ATTR_FLAG_TRANS
);
4283 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4284 stream_putc(s
, attr_len
);
4285 stream_putc(s
, BGP_PREFIX_SID_SRV6_L3_SERVICE
);
4286 stream_putw(s
, tlv_len
);
4287 stream_putc(s
, 0); /* reserved */
4288 stream_putc(s
, BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO
);
4289 stream_putw(s
, subtlv_len
);
4290 stream_putc(s
, 0); /* reserved */
4291 stream_put(s
, &attr
->srv6_l3vpn
->sid
,
4292 sizeof(attr
->srv6_l3vpn
->sid
)); /* sid */
4293 stream_putc(s
, 0); /* sid_flags */
4294 stream_putw(s
, 0xffff); /* endpoint */
4295 stream_putc(s
, 0); /* reserved */
4298 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE
);
4301 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
);
4302 stream_putc(s
, attr
->srv6_l3vpn
->loc_block_len
);
4303 stream_putc(s
, attr
->srv6_l3vpn
->loc_node_len
);
4304 stream_putc(s
, attr
->srv6_l3vpn
->func_len
);
4305 stream_putc(s
, attr
->srv6_l3vpn
->arg_len
);
4306 stream_putc(s
, attr
->srv6_l3vpn
->transposition_len
);
4307 stream_putc(s
, attr
->srv6_l3vpn
->transposition_offset
);
4308 } else if (attr
->srv6_vpn
) {
4309 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
4310 | BGP_ATTR_FLAG_TRANS
);
4311 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4312 stream_putc(s
, 22); /* tlv len */
4313 stream_putc(s
, BGP_PREFIX_SID_VPN_SID
);
4314 stream_putw(s
, 0x13); /* tlv len */
4315 stream_putc(s
, 0x00); /* reserved */
4316 stream_putc(s
, 0x01); /* sid_type */
4317 stream_putc(s
, 0x00); /* sif_flags */
4318 stream_put(s
, &attr
->srv6_vpn
->sid
,
4319 sizeof(attr
->srv6_vpn
->sid
)); /* sid */
4323 if (send_as4_path
) {
4324 /* If the peer is NOT As4 capable, AND */
4325 /* there are ASnums > 65535 in path THEN
4326 * give out AS4_PATH */
4328 /* Get rid of all AS_CONFED_SEQUENCE and AS_CONFED_SET
4330 * Hm, I wonder... confederation things *should* only be at
4331 * the beginning of an aspath, right? Then we should use
4332 * aspath_delete_confed_seq for this, because it is already
4334 * Folks, talk to me: what is reasonable here!?
4336 aspath
= aspath_delete_confed_seq(aspath
);
4339 BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
4340 | BGP_ATTR_FLAG_EXTLEN
);
4341 stream_putc(s
, BGP_ATTR_AS4_PATH
);
4342 aspath_sizep
= stream_get_endp(s
);
4344 stream_putw_at(s
, aspath_sizep
, aspath_put(s
, aspath
, 1));
4347 if (aspath
!= attr
->aspath
)
4348 aspath_free(aspath
);
4350 if (send_as4_aggregator
) {
4351 /* send AS4_AGGREGATOR, at this place */
4352 /* this section of code moved here in order to ensure the
4354 * *ascending* order of attributes
4356 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4357 stream_putc(s
, BGP_ATTR_AS4_AGGREGATOR
);
4359 stream_putl(s
, attr
->aggregator_as
);
4360 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4363 if (((afi
== AFI_IP
|| afi
== AFI_IP6
)
4364 && (safi
== SAFI_ENCAP
|| safi
== SAFI_MPLS_VPN
))
4365 || (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
)) {
4366 /* Tunnel Encap attribute */
4367 bgp_packet_mpattr_tea(bgp
, peer
, s
, attr
, BGP_ATTR_ENCAP
);
4369 #ifdef ENABLE_BGP_VNC_ATTR
4371 bgp_packet_mpattr_tea(bgp
, peer
, s
, attr
, BGP_ATTR_VNC
);
4376 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
)) {
4377 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4378 stream_putc(s
, BGP_ATTR_PMSI_TUNNEL
);
4379 stream_putc(s
, 9); // Length
4380 stream_putc(s
, 0); // Flags
4381 stream_putc(s
, bgp_attr_get_pmsi_tnl_type(attr
));
4382 stream_put(s
, &(attr
->label
),
4383 BGP_LABEL_BYTES
); // MPLS Label / VXLAN VNI
4384 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4385 // Unicast tunnel endpoint IP address
4388 /* Unknown transit attribute. */
4389 struct transit
*transit
= bgp_attr_get_transit(attr
);
4392 stream_put(s
, transit
->val
, transit
->length
);
4394 /* Return total size of attribute. */
4395 return stream_get_endp(s
) - cp
;
4398 size_t bgp_packet_mpunreach_start(struct stream
*s
, afi_t afi
, safi_t safi
)
4400 unsigned long attrlen_pnt
;
4402 iana_safi_t pkt_safi
;
4404 /* Set extended bit always to encode the attribute length as 2 bytes */
4405 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_EXTLEN
);
4406 stream_putc(s
, BGP_ATTR_MP_UNREACH_NLRI
);
4408 attrlen_pnt
= stream_get_endp(s
);
4409 stream_putw(s
, 0); /* Length of this attribute. */
4411 /* Convert AFI, SAFI to values for packet. */
4412 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
4414 stream_putw(s
, pkt_afi
);
4415 stream_putc(s
, pkt_safi
);
4420 void bgp_packet_mpunreach_prefix(struct stream
*s
, const struct prefix
*p
,
4421 afi_t afi
, safi_t safi
,
4422 const struct prefix_rd
*prd
,
4423 mpls_label_t
*label
, uint32_t num_labels
,
4424 bool addpath_capable
, uint32_t addpath_tx_id
,
4427 uint8_t wlabel
[3] = {0x80, 0x00, 0x00};
4429 if (safi
== SAFI_LABELED_UNICAST
) {
4430 label
= (mpls_label_t
*)wlabel
;
4434 bgp_packet_mpattr_prefix(s
, afi
, safi
, p
, prd
, label
, num_labels
,
4435 addpath_capable
, addpath_tx_id
, attr
);
4438 void bgp_packet_mpunreach_end(struct stream
*s
, size_t attrlen_pnt
)
4440 bgp_packet_mpattr_end(s
, attrlen_pnt
);
4443 /* Initialization of attribute. */
4444 void bgp_attr_init(void)
4457 void bgp_attr_finish(void)
4462 ecommunity_finish();
4463 lcommunity_finish();
4470 /* Make attribute packet. */
4471 void bgp_dump_routes_attr(struct stream
*s
, struct attr
*attr
,
4472 const struct prefix
*prefix
)
4477 struct aspath
*aspath
;
4478 bool addpath_capable
= false;
4479 uint32_t addpath_tx_id
= 0;
4481 /* Remember current pointer. */
4482 cp
= stream_get_endp(s
);
4484 /* Place holder of length. */
4487 /* Origin attribute. */
4488 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4489 stream_putc(s
, BGP_ATTR_ORIGIN
);
4491 stream_putc(s
, attr
->origin
);
4493 aspath
= attr
->aspath
;
4495 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_EXTLEN
);
4496 stream_putc(s
, BGP_ATTR_AS_PATH
);
4497 aspath_lenp
= stream_get_endp(s
);
4500 stream_putw_at(s
, aspath_lenp
, aspath_put(s
, aspath
, 1));
4502 /* Nexthop attribute. */
4503 /* If it's an IPv6 prefix, don't dump the IPv4 nexthop to save space */
4504 if (prefix
!= NULL
&& prefix
->family
!= AF_INET6
) {
4505 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4506 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4508 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4511 /* MED attribute. */
4512 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
)) {
4513 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4514 stream_putc(s
, BGP_ATTR_MULTI_EXIT_DISC
);
4516 stream_putl(s
, attr
->med
);
4519 /* Local preference. */
4520 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)) {
4521 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4522 stream_putc(s
, BGP_ATTR_LOCAL_PREF
);
4524 stream_putl(s
, attr
->local_pref
);
4527 /* Atomic aggregate. */
4528 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
)) {
4529 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4530 stream_putc(s
, BGP_ATTR_ATOMIC_AGGREGATE
);
4535 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
)) {
4536 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4537 stream_putc(s
, BGP_ATTR_AGGREGATOR
);
4539 stream_putl(s
, attr
->aggregator_as
);
4540 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4543 /* Community attribute. */
4544 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
)) {
4545 struct community
*comm
= NULL
;
4547 comm
= bgp_attr_get_community(attr
);
4548 if (comm
->size
* 4 > 255) {
4550 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4551 | BGP_ATTR_FLAG_EXTLEN
);
4552 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4553 stream_putw(s
, comm
->size
* 4);
4556 BGP_ATTR_FLAG_OPTIONAL
4557 | BGP_ATTR_FLAG_TRANS
);
4558 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4559 stream_putc(s
, comm
->size
* 4);
4561 stream_put(s
, comm
->val
, comm
->size
* 4);
4564 /* Large Community attribute. */
4565 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
)) {
4566 if (lcom_length(bgp_attr_get_lcommunity(attr
)) > 255) {
4568 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4569 | BGP_ATTR_FLAG_EXTLEN
);
4570 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4572 lcom_length(bgp_attr_get_lcommunity(attr
)));
4575 BGP_ATTR_FLAG_OPTIONAL
4576 | BGP_ATTR_FLAG_TRANS
);
4577 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4579 lcom_length(bgp_attr_get_lcommunity(attr
)));
4582 stream_put(s
, bgp_attr_get_lcommunity(attr
)->val
,
4583 lcom_length(bgp_attr_get_lcommunity(attr
)));
4586 /* Add a MP_NLRI attribute to dump the IPv6 next hop */
4587 if (prefix
!= NULL
&& prefix
->family
== AF_INET6
4588 && (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL
4589 || attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)) {
4592 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4593 stream_putc(s
, BGP_ATTR_MP_REACH_NLRI
);
4594 sizep
= stream_get_endp(s
);
4597 stream_putc(s
, 0); /* Marker: Attribute length. */
4598 stream_putw(s
, AFI_IP6
); /* AFI */
4599 stream_putc(s
, SAFI_UNICAST
); /* SAFI */
4602 stream_putc(s
, attr
->mp_nexthop_len
);
4603 stream_put(s
, &attr
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
4604 if (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
4605 stream_put(s
, &attr
->mp_nexthop_local
,
4612 stream_put_prefix_addpath(s
, prefix
, addpath_capable
,
4615 /* Set MP attribute length. */
4616 stream_putc_at(s
, sizep
, (stream_get_endp(s
) - sizep
) - 1);
4620 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
)) {
4621 if (attr
->label_index
!= BGP_INVALID_LABEL_INDEX
) {
4623 BGP_ATTR_FLAG_OPTIONAL
4624 | BGP_ATTR_FLAG_TRANS
);
4625 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4627 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX
);
4628 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
4629 stream_putc(s
, 0); // reserved
4630 stream_putw(s
, 0); // flags
4631 stream_putl(s
, attr
->label_index
);
4635 /* Return total size of attribute. */
4636 len
= stream_get_endp(s
) - cp
- 2;
4637 stream_putw_at(s
, cp
, len
);