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 {BGP_ATTR_OTC
, "OTC"},
80 #ifdef ENABLE_BGP_VNC_ATTR
81 {BGP_ATTR_VNC
, "VNC"},
83 {BGP_ATTR_LARGE_COMMUNITIES
, "LARGE_COMMUNITY"},
84 {BGP_ATTR_PREFIX_SID
, "PREFIX_SID"},
85 {BGP_ATTR_IPV6_EXT_COMMUNITIES
, "IPV6_EXT_COMMUNITIES"},
86 {BGP_ATTR_AIGP
, "AIGP"},
89 static const struct message attr_flag_str
[] = {
90 {BGP_ATTR_FLAG_OPTIONAL
, "Optional"},
91 {BGP_ATTR_FLAG_TRANS
, "Transitive"},
92 {BGP_ATTR_FLAG_PARTIAL
, "Partial"},
93 /* bgp_attr_flags_diagnose() relies on this bit being last in
95 {BGP_ATTR_FLAG_EXTLEN
, "Extended Length"},
98 static struct hash
*cluster_hash
;
100 static void *cluster_hash_alloc(void *p
)
102 const struct cluster_list
*val
= (const struct cluster_list
*)p
;
103 struct cluster_list
*cluster
;
105 cluster
= XMALLOC(MTYPE_CLUSTER
, sizeof(struct cluster_list
));
106 cluster
->length
= val
->length
;
108 if (cluster
->length
) {
109 cluster
->list
= XMALLOC(MTYPE_CLUSTER_VAL
, val
->length
);
110 memcpy(cluster
->list
, val
->list
, val
->length
);
112 cluster
->list
= NULL
;
119 /* Cluster list related functions. */
120 static struct cluster_list
*cluster_parse(struct in_addr
*pnt
, int length
)
122 struct cluster_list tmp
= {};
123 struct cluster_list
*cluster
;
126 tmp
.list
= length
== 0 ? NULL
: pnt
;
128 cluster
= hash_get(cluster_hash
, &tmp
, cluster_hash_alloc
);
133 bool cluster_loop_check(struct cluster_list
*cluster
, struct in_addr originator
)
137 for (i
= 0; i
< cluster
->length
/ 4; i
++)
138 if (cluster
->list
[i
].s_addr
== originator
.s_addr
)
143 static unsigned int cluster_hash_key_make(const void *p
)
145 const struct cluster_list
*cluster
= p
;
147 return jhash(cluster
->list
, cluster
->length
, 0);
150 static bool cluster_hash_cmp(const void *p1
, const void *p2
)
152 const struct cluster_list
*cluster1
= p1
;
153 const struct cluster_list
*cluster2
= p2
;
155 if (cluster1
->list
== cluster2
->list
)
158 if (!cluster1
->list
|| !cluster2
->list
)
161 if (cluster1
->length
!= cluster2
->length
)
164 return (memcmp(cluster1
->list
, cluster2
->list
, cluster1
->length
) == 0);
167 static void cluster_free(struct cluster_list
*cluster
)
169 XFREE(MTYPE_CLUSTER_VAL
, cluster
->list
);
170 XFREE(MTYPE_CLUSTER
, cluster
);
173 static struct cluster_list
*cluster_intern(struct cluster_list
*cluster
)
175 struct cluster_list
*find
;
177 find
= hash_get(cluster_hash
, cluster
, cluster_hash_alloc
);
183 static void cluster_unintern(struct cluster_list
**cluster
)
185 if ((*cluster
)->refcnt
)
186 (*cluster
)->refcnt
--;
188 if ((*cluster
)->refcnt
== 0) {
189 void *p
= hash_release(cluster_hash
, *cluster
);
190 assert(p
== *cluster
);
191 cluster_free(*cluster
);
196 static void cluster_init(void)
198 cluster_hash
= hash_create(cluster_hash_key_make
, cluster_hash_cmp
,
202 static void cluster_finish(void)
204 hash_clean(cluster_hash
, (void (*)(void *))cluster_free
);
205 hash_free(cluster_hash
);
209 static struct hash
*encap_hash
= NULL
;
210 #ifdef ENABLE_BGP_VNC
211 static struct hash
*vnc_hash
= NULL
;
213 static struct hash
*srv6_l3vpn_hash
;
214 static struct hash
*srv6_vpn_hash
;
216 struct bgp_attr_encap_subtlv
*encap_tlv_dup(struct bgp_attr_encap_subtlv
*orig
)
218 struct bgp_attr_encap_subtlv
*new;
219 struct bgp_attr_encap_subtlv
*tail
;
220 struct bgp_attr_encap_subtlv
*p
;
222 for (p
= orig
, tail
= new = NULL
; p
; p
= p
->next
) {
223 int size
= sizeof(struct bgp_attr_encap_subtlv
) + p
->length
;
225 tail
->next
= XCALLOC(MTYPE_ENCAP_TLV
, size
);
228 tail
= new = XCALLOC(MTYPE_ENCAP_TLV
, size
);
231 memcpy(tail
, p
, size
);
238 static void encap_free(struct bgp_attr_encap_subtlv
*p
)
240 struct bgp_attr_encap_subtlv
*next
;
244 XFREE(MTYPE_ENCAP_TLV
, p
);
249 void bgp_attr_flush_encap(struct attr
*attr
)
254 if (attr
->encap_subtlvs
) {
255 encap_free(attr
->encap_subtlvs
);
256 attr
->encap_subtlvs
= NULL
;
258 #ifdef ENABLE_BGP_VNC
259 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
260 bgp_attr_get_vnc_subtlvs(attr
);
263 encap_free(vnc_subtlvs
);
264 bgp_attr_set_vnc_subtlvs(attr
, NULL
);
270 * Compare encap sub-tlv chains
275 * This algorithm could be made faster if needed
277 static bool encap_same(const struct bgp_attr_encap_subtlv
*h1
,
278 const struct bgp_attr_encap_subtlv
*h2
)
280 const struct bgp_attr_encap_subtlv
*p
;
281 const struct bgp_attr_encap_subtlv
*q
;
285 if (h1
== NULL
|| h2
== NULL
)
288 for (p
= h1
; p
; p
= p
->next
) {
289 for (q
= h2
; q
; q
= q
->next
) {
290 if ((p
->type
== q
->type
) && (p
->length
== q
->length
)
291 && !memcmp(p
->value
, q
->value
, p
->length
)) {
300 for (p
= h2
; p
; p
= p
->next
) {
301 for (q
= h1
; q
; q
= q
->next
) {
302 if ((p
->type
== q
->type
) && (p
->length
== q
->length
)
303 && !memcmp(p
->value
, q
->value
, p
->length
)) {
315 static void *encap_hash_alloc(void *p
)
317 /* Encap structure is already allocated. */
323 #ifdef ENABLE_BGP_VNC
328 static struct bgp_attr_encap_subtlv
*
329 encap_intern(struct bgp_attr_encap_subtlv
*encap
, encap_subtlv_type type
)
331 struct bgp_attr_encap_subtlv
*find
;
332 struct hash
*hash
= encap_hash
;
333 #ifdef ENABLE_BGP_VNC
334 if (type
== VNC_SUBTLV_TYPE
)
338 find
= hash_get(hash
, encap
, encap_hash_alloc
);
346 static void encap_unintern(struct bgp_attr_encap_subtlv
**encapp
,
347 encap_subtlv_type type
)
349 struct bgp_attr_encap_subtlv
*encap
= *encapp
;
353 if (encap
->refcnt
== 0) {
354 struct hash
*hash
= encap_hash
;
355 #ifdef ENABLE_BGP_VNC
356 if (type
== VNC_SUBTLV_TYPE
)
359 hash_release(hash
, encap
);
365 static unsigned int encap_hash_key_make(const void *p
)
367 const struct bgp_attr_encap_subtlv
*encap
= p
;
369 return jhash(encap
->value
, encap
->length
, 0);
372 static bool encap_hash_cmp(const void *p1
, const void *p2
)
374 return encap_same((const struct bgp_attr_encap_subtlv
*)p1
,
375 (const struct bgp_attr_encap_subtlv
*)p2
);
378 static void encap_init(void)
380 encap_hash
= hash_create(encap_hash_key_make
, encap_hash_cmp
,
382 #ifdef ENABLE_BGP_VNC
383 vnc_hash
= hash_create(encap_hash_key_make
, encap_hash_cmp
,
388 static void encap_finish(void)
390 hash_clean(encap_hash
, (void (*)(void *))encap_free
);
391 hash_free(encap_hash
);
393 #ifdef ENABLE_BGP_VNC
394 hash_clean(vnc_hash
, (void (*)(void *))encap_free
);
400 static bool overlay_index_same(const struct attr
*a1
, const struct attr
*a2
)
409 return bgp_route_evpn_same(bgp_attr_get_evpn_overlay(a1
),
410 bgp_attr_get_evpn_overlay(a2
));
413 /* Unknown transit attribute. */
414 static struct hash
*transit_hash
;
416 static void transit_free(struct transit
*transit
)
418 XFREE(MTYPE_TRANSIT_VAL
, transit
->val
);
419 XFREE(MTYPE_TRANSIT
, transit
);
422 static void *transit_hash_alloc(void *p
)
424 /* Transit structure is already allocated. */
428 static struct transit
*transit_intern(struct transit
*transit
)
430 struct transit
*find
;
432 find
= hash_get(transit_hash
, transit
, transit_hash_alloc
);
434 transit_free(transit
);
440 static void transit_unintern(struct transit
**transit
)
442 if ((*transit
)->refcnt
)
443 (*transit
)->refcnt
--;
445 if ((*transit
)->refcnt
== 0) {
446 hash_release(transit_hash
, *transit
);
447 transit_free(*transit
);
452 static bool bgp_attr_aigp_get_tlv_metric(uint8_t *pnt
, int length
,
461 ptr_get_be16(data
+ 1, &tlv_length
);
464 /* The value field of the AIGP TLV is always 8 octets
465 * long and its value is interpreted as an unsigned 64-bit
468 if (tlv_type
== BGP_AIGP_TLV_METRIC
) {
469 (void)ptr_get_be64(data
+ 3, aigp
);
471 /* If an AIGP attribute is received and its first AIGP
472 * TLV contains the maximum value 0xffffffffffffffff,
473 * the attribute SHOULD be considered to be malformed
474 * and SHOULD be discarded as specified in this section.
476 if (*aigp
== BGP_AIGP_TLV_METRIC_MAX
) {
477 zlog_err("Bad AIGP TLV (%s) length: %llu",
478 BGP_AIGP_TLV_METRIC_DESC
,
479 BGP_AIGP_TLV_METRIC_MAX
);
487 length
-= tlv_length
;
493 static uint64_t bgp_aigp_metric_total(struct bgp_path_info
*bpi
)
495 uint64_t aigp
= bgp_attr_get_aigp_metric(bpi
->attr
);
498 return aigp
+ bpi
->nexthop
->metric
;
503 static void stream_put_bgp_aigp_tlv_metric(struct stream
*s
,
504 struct bgp_path_info
*bpi
)
506 stream_putc(s
, BGP_AIGP_TLV_METRIC
);
507 stream_putw(s
, BGP_AIGP_TLV_METRIC_LEN
);
508 stream_putq(s
, bgp_aigp_metric_total(bpi
));
511 static bool bgp_attr_aigp_valid(uint8_t *pnt
, int length
)
518 zlog_err("Bad AIGP attribute length (MUST be minimum 3): %u",
525 ptr_get_be16(data
+ 1, &tlv_length
);
528 if (length
< tlv_length
) {
530 "Bad AIGP attribute length: %u, but TLV length: %u",
535 if (tlv_length
< 3) {
536 zlog_err("Bad AIGP TLV length (MUST be minimum 3): %u",
541 /* AIGP TLV, Length: 11 */
542 if (tlv_type
== BGP_AIGP_TLV_METRIC
&&
543 tlv_length
!= BGP_AIGP_TLV_METRIC_LEN
) {
544 zlog_err("Bad AIGP TLV (%s) length: %u",
545 BGP_AIGP_TLV_METRIC_DESC
, tlv_length
);
550 length
-= tlv_length
;
556 static void *srv6_l3vpn_hash_alloc(void *p
)
561 static void srv6_l3vpn_free(struct bgp_attr_srv6_l3vpn
*l3vpn
)
563 XFREE(MTYPE_BGP_SRV6_L3VPN
, l3vpn
);
566 static struct bgp_attr_srv6_l3vpn
*
567 srv6_l3vpn_intern(struct bgp_attr_srv6_l3vpn
*l3vpn
)
569 struct bgp_attr_srv6_l3vpn
*find
;
571 find
= hash_get(srv6_l3vpn_hash
, l3vpn
, srv6_l3vpn_hash_alloc
);
573 srv6_l3vpn_free(l3vpn
);
578 static void srv6_l3vpn_unintern(struct bgp_attr_srv6_l3vpn
**l3vpnp
)
580 struct bgp_attr_srv6_l3vpn
*l3vpn
= *l3vpnp
;
585 if (l3vpn
->refcnt
== 0) {
586 hash_release(srv6_l3vpn_hash
, l3vpn
);
587 srv6_l3vpn_free(l3vpn
);
592 static void *srv6_vpn_hash_alloc(void *p
)
597 static void srv6_vpn_free(struct bgp_attr_srv6_vpn
*vpn
)
599 XFREE(MTYPE_BGP_SRV6_VPN
, vpn
);
602 static struct bgp_attr_srv6_vpn
*srv6_vpn_intern(struct bgp_attr_srv6_vpn
*vpn
)
604 struct bgp_attr_srv6_vpn
*find
;
606 find
= hash_get(srv6_vpn_hash
, vpn
, srv6_vpn_hash_alloc
);
613 static void srv6_vpn_unintern(struct bgp_attr_srv6_vpn
**vpnp
)
615 struct bgp_attr_srv6_vpn
*vpn
= *vpnp
;
620 if (vpn
->refcnt
== 0) {
621 hash_release(srv6_vpn_hash
, vpn
);
627 static uint32_t srv6_l3vpn_hash_key_make(const void *p
)
629 const struct bgp_attr_srv6_l3vpn
*l3vpn
= p
;
632 key
= jhash(&l3vpn
->sid
, 16, key
);
633 key
= jhash_1word(l3vpn
->sid_flags
, key
);
634 key
= jhash_1word(l3vpn
->endpoint_behavior
, key
);
635 key
= jhash_1word(l3vpn
->loc_block_len
, key
);
636 key
= jhash_1word(l3vpn
->loc_node_len
, key
);
637 key
= jhash_1word(l3vpn
->func_len
, key
);
638 key
= jhash_1word(l3vpn
->arg_len
, key
);
639 key
= jhash_1word(l3vpn
->transposition_len
, key
);
640 key
= jhash_1word(l3vpn
->transposition_offset
, key
);
644 static bool srv6_l3vpn_hash_cmp(const void *p1
, const void *p2
)
646 const struct bgp_attr_srv6_l3vpn
*l3vpn1
= p1
;
647 const struct bgp_attr_srv6_l3vpn
*l3vpn2
= p2
;
649 return sid_same(&l3vpn1
->sid
, &l3vpn2
->sid
)
650 && l3vpn1
->sid_flags
== l3vpn2
->sid_flags
651 && l3vpn1
->endpoint_behavior
== l3vpn2
->endpoint_behavior
652 && l3vpn1
->loc_block_len
== l3vpn2
->loc_block_len
653 && l3vpn1
->loc_node_len
== l3vpn2
->loc_node_len
654 && l3vpn1
->func_len
== l3vpn2
->func_len
655 && l3vpn1
->arg_len
== l3vpn2
->arg_len
656 && l3vpn1
->transposition_len
== l3vpn2
->transposition_len
657 && l3vpn1
->transposition_offset
== l3vpn2
->transposition_offset
;
660 static bool srv6_l3vpn_same(const struct bgp_attr_srv6_l3vpn
*h1
,
661 const struct bgp_attr_srv6_l3vpn
*h2
)
665 else if (h1
== NULL
|| h2
== NULL
)
668 return srv6_l3vpn_hash_cmp((const void *)h1
, (const void *)h2
);
671 static unsigned int srv6_vpn_hash_key_make(const void *p
)
673 const struct bgp_attr_srv6_vpn
*vpn
= p
;
676 key
= jhash(&vpn
->sid
, 16, key
);
677 key
= jhash_1word(vpn
->sid_flags
, key
);
681 static bool srv6_vpn_hash_cmp(const void *p1
, const void *p2
)
683 const struct bgp_attr_srv6_vpn
*vpn1
= p1
;
684 const struct bgp_attr_srv6_vpn
*vpn2
= p2
;
686 return sid_same(&vpn1
->sid
, &vpn2
->sid
)
687 && vpn1
->sid_flags
== vpn2
->sid_flags
;
690 static bool srv6_vpn_same(const struct bgp_attr_srv6_vpn
*h1
,
691 const struct bgp_attr_srv6_vpn
*h2
)
695 else if (h1
== NULL
|| h2
== NULL
)
698 return srv6_vpn_hash_cmp((const void *)h1
, (const void *)h2
);
701 static void srv6_init(void)
704 hash_create(srv6_l3vpn_hash_key_make
, srv6_l3vpn_hash_cmp
,
705 "BGP Prefix-SID SRv6-L3VPN-Service-TLV");
706 srv6_vpn_hash
= hash_create(srv6_vpn_hash_key_make
, srv6_vpn_hash_cmp
,
707 "BGP Prefix-SID SRv6-VPN-Service-TLV");
710 static void srv6_finish(void)
712 hash_clean(srv6_l3vpn_hash
, (void (*)(void *))srv6_l3vpn_free
);
713 hash_free(srv6_l3vpn_hash
);
714 srv6_l3vpn_hash
= NULL
;
715 hash_clean(srv6_vpn_hash
, (void (*)(void *))srv6_vpn_free
);
716 hash_free(srv6_vpn_hash
);
717 srv6_vpn_hash
= NULL
;
720 static unsigned int transit_hash_key_make(const void *p
)
722 const struct transit
*transit
= p
;
724 return jhash(transit
->val
, transit
->length
, 0);
727 static bool transit_hash_cmp(const void *p1
, const void *p2
)
729 const struct transit
*transit1
= p1
;
730 const struct transit
*transit2
= p2
;
732 return (transit1
->length
== transit2
->length
733 && memcmp(transit1
->val
, transit2
->val
, transit1
->length
) == 0);
736 static void transit_init(void)
738 transit_hash
= hash_create(transit_hash_key_make
, transit_hash_cmp
,
742 static void transit_finish(void)
744 hash_clean(transit_hash
, (void (*)(void *))transit_free
);
745 hash_free(transit_hash
);
749 /* Attribute hash routines. */
750 static struct hash
*attrhash
;
752 unsigned long int attr_count(void)
754 return attrhash
->count
;
757 unsigned long int attr_unknown_count(void)
759 return transit_hash
->count
;
762 unsigned int attrhash_key_make(const void *p
)
764 const struct attr
*attr
= (struct attr
*)p
;
766 #define MIX(val) key = jhash_1word(val, key)
767 #define MIX3(a, b, c) key = jhash_3words((a), (b), (c), key)
769 MIX3(attr
->origin
, attr
->nexthop
.s_addr
, attr
->med
);
770 MIX3(attr
->local_pref
, attr
->aggregator_as
,
771 attr
->aggregator_addr
.s_addr
);
772 MIX3(attr
->weight
, attr
->mp_nexthop_global_in
.s_addr
,
773 attr
->originator_id
.s_addr
);
774 MIX3(attr
->tag
, attr
->label
, attr
->label_index
);
777 MIX(aspath_key_make(attr
->aspath
));
778 if (bgp_attr_get_community(attr
))
779 MIX(community_hash_make(bgp_attr_get_community(attr
)));
780 if (bgp_attr_get_lcommunity(attr
))
781 MIX(lcommunity_hash_make(bgp_attr_get_lcommunity(attr
)));
782 if (bgp_attr_get_ecommunity(attr
))
783 MIX(ecommunity_hash_make(bgp_attr_get_ecommunity(attr
)));
784 if (bgp_attr_get_ipv6_ecommunity(attr
))
785 MIX(ecommunity_hash_make(bgp_attr_get_ipv6_ecommunity(attr
)));
786 if (bgp_attr_get_cluster(attr
))
787 MIX(cluster_hash_key_make(bgp_attr_get_cluster(attr
)));
788 if (bgp_attr_get_transit(attr
))
789 MIX(transit_hash_key_make(bgp_attr_get_transit(attr
)));
790 if (attr
->encap_subtlvs
)
791 MIX(encap_hash_key_make(attr
->encap_subtlvs
));
792 if (attr
->srv6_l3vpn
)
793 MIX(srv6_l3vpn_hash_key_make(attr
->srv6_l3vpn
));
795 MIX(srv6_vpn_hash_key_make(attr
->srv6_vpn
));
796 #ifdef ENABLE_BGP_VNC
797 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
798 bgp_attr_get_vnc_subtlvs(attr
);
800 MIX(encap_hash_key_make(vnc_subtlvs
));
802 MIX(attr
->mp_nexthop_len
);
803 key
= jhash(attr
->mp_nexthop_global
.s6_addr
, IPV6_MAX_BYTELEN
, key
);
804 key
= jhash(attr
->mp_nexthop_local
.s6_addr
, IPV6_MAX_BYTELEN
, key
);
805 MIX3(attr
->nh_ifindex
, attr
->nh_lla_ifindex
, attr
->distance
);
806 MIX(attr
->rmap_table_id
);
810 MIX(bgp_attr_get_aigp_metric(attr
));
815 bool attrhash_cmp(const void *p1
, const void *p2
)
817 const struct attr
*attr1
= p1
;
818 const struct attr
*attr2
= p2
;
820 if (attr1
->flag
== attr2
->flag
&& attr1
->origin
== attr2
->origin
821 && attr1
->nexthop
.s_addr
== attr2
->nexthop
.s_addr
822 && attr1
->aspath
== attr2
->aspath
823 && bgp_attr_get_community(attr1
)
824 == bgp_attr_get_community(attr2
)
825 && attr1
->med
== attr2
->med
826 && attr1
->local_pref
== attr2
->local_pref
827 && attr1
->rmap_change_flags
== attr2
->rmap_change_flags
) {
828 if (attr1
->aggregator_as
== attr2
->aggregator_as
&&
829 attr1
->aggregator_addr
.s_addr
==
830 attr2
->aggregator_addr
.s_addr
&&
831 attr1
->weight
== attr2
->weight
&&
832 attr1
->tag
== attr2
->tag
&&
833 attr1
->label_index
== attr2
->label_index
&&
834 attr1
->mp_nexthop_len
== attr2
->mp_nexthop_len
&&
835 bgp_attr_get_ecommunity(attr1
) ==
836 bgp_attr_get_ecommunity(attr2
) &&
837 bgp_attr_get_ipv6_ecommunity(attr1
) ==
838 bgp_attr_get_ipv6_ecommunity(attr2
) &&
839 bgp_attr_get_lcommunity(attr1
) ==
840 bgp_attr_get_lcommunity(attr2
) &&
841 bgp_attr_get_cluster(attr1
) ==
842 bgp_attr_get_cluster(attr2
) &&
843 bgp_attr_get_transit(attr1
) ==
844 bgp_attr_get_transit(attr2
) &&
845 bgp_attr_get_aigp_metric(attr1
) ==
846 bgp_attr_get_aigp_metric(attr2
) &&
847 attr1
->rmap_table_id
== attr2
->rmap_table_id
&&
848 (attr1
->encap_tunneltype
== attr2
->encap_tunneltype
) &&
849 encap_same(attr1
->encap_subtlvs
, attr2
->encap_subtlvs
)
850 #ifdef ENABLE_BGP_VNC
851 && encap_same(bgp_attr_get_vnc_subtlvs(attr1
),
852 bgp_attr_get_vnc_subtlvs(attr2
))
854 && IPV6_ADDR_SAME(&attr1
->mp_nexthop_global
,
855 &attr2
->mp_nexthop_global
) &&
856 IPV6_ADDR_SAME(&attr1
->mp_nexthop_local
,
857 &attr2
->mp_nexthop_local
) &&
858 IPV4_ADDR_SAME(&attr1
->mp_nexthop_global_in
,
859 &attr2
->mp_nexthop_global_in
) &&
860 IPV4_ADDR_SAME(&attr1
->originator_id
,
861 &attr2
->originator_id
) &&
862 overlay_index_same(attr1
, attr2
) &&
863 !memcmp(&attr1
->esi
, &attr2
->esi
, sizeof(esi_t
)) &&
864 attr1
->es_flags
== attr2
->es_flags
&&
865 attr1
->mm_sync_seqnum
== attr2
->mm_sync_seqnum
&&
866 attr1
->df_pref
== attr2
->df_pref
&&
867 attr1
->df_alg
== attr2
->df_alg
&&
868 attr1
->nh_ifindex
== attr2
->nh_ifindex
&&
869 attr1
->nh_flag
== attr2
->nh_flag
&&
870 attr1
->nh_lla_ifindex
== attr2
->nh_lla_ifindex
&&
871 attr1
->distance
== attr2
->distance
&&
872 srv6_l3vpn_same(attr1
->srv6_l3vpn
, attr2
->srv6_l3vpn
) &&
873 srv6_vpn_same(attr1
->srv6_vpn
, attr2
->srv6_vpn
) &&
874 attr1
->srte_color
== attr2
->srte_color
&&
875 attr1
->nh_type
== attr2
->nh_type
&&
876 attr1
->bh_type
== attr2
->bh_type
&&
877 attr1
->otc
== attr2
->otc
)
884 static void attrhash_init(void)
887 hash_create(attrhash_key_make
, attrhash_cmp
, "BGP Attributes");
891 * special for hash_clean below
893 static void attr_vfree(void *attr
)
895 XFREE(MTYPE_ATTR
, attr
);
898 static void attrhash_finish(void)
900 hash_clean(attrhash
, attr_vfree
);
905 static void attr_show_all_iterator(struct hash_bucket
*bucket
, struct vty
*vty
)
907 struct attr
*attr
= bucket
->data
;
908 struct in6_addr
*sid
= NULL
;
910 if (attr
->srv6_l3vpn
)
911 sid
= &attr
->srv6_l3vpn
->sid
;
912 else if (attr
->srv6_vpn
)
913 sid
= &attr
->srv6_vpn
->sid
;
915 vty_out(vty
, "attr[%ld] nexthop %pI4\n", attr
->refcnt
, &attr
->nexthop
);
919 " distance: %u med: %u local_pref: %u origin: %u weight: %u label: %u sid: %pI6\n",
920 attr
->flag
, attr
->distance
, attr
->med
, attr
->local_pref
,
921 attr
->origin
, attr
->weight
, attr
->label
, sid
);
924 void attr_show_all(struct vty
*vty
)
926 hash_iterate(attrhash
, (void (*)(struct hash_bucket
*,
927 void *))attr_show_all_iterator
,
931 static void *bgp_attr_hash_alloc(void *p
)
933 struct attr
*val
= (struct attr
*)p
;
936 attr
= XMALLOC(MTYPE_ATTR
, sizeof(struct attr
));
938 if (val
->encap_subtlvs
) {
939 val
->encap_subtlvs
= NULL
;
941 #ifdef ENABLE_BGP_VNC
942 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
943 bgp_attr_get_vnc_subtlvs(val
);
946 bgp_attr_set_vnc_subtlvs(val
, NULL
);
953 /* Internet argument attribute. */
954 struct attr
*bgp_attr_intern(struct attr
*attr
)
957 struct ecommunity
*ecomm
= NULL
;
958 struct ecommunity
*ipv6_ecomm
= NULL
;
959 struct lcommunity
*lcomm
= NULL
;
960 struct community
*comm
= NULL
;
962 /* Intern referenced structure. */
964 if (!attr
->aspath
->refcnt
)
965 attr
->aspath
= aspath_intern(attr
->aspath
);
967 attr
->aspath
->refcnt
++;
970 comm
= bgp_attr_get_community(attr
);
973 bgp_attr_set_community(attr
, community_intern(comm
));
978 ecomm
= bgp_attr_get_ecommunity(attr
);
981 bgp_attr_set_ecommunity(attr
, ecommunity_intern(ecomm
));
986 ipv6_ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
988 if (!ipv6_ecomm
->refcnt
)
989 bgp_attr_set_ipv6_ecommunity(
990 attr
, ecommunity_intern(ipv6_ecomm
));
992 ipv6_ecomm
->refcnt
++;
995 lcomm
= bgp_attr_get_lcommunity(attr
);
998 bgp_attr_set_lcommunity(attr
, lcommunity_intern(lcomm
));
1003 struct cluster_list
*cluster
= bgp_attr_get_cluster(attr
);
1006 if (!cluster
->refcnt
)
1007 bgp_attr_set_cluster(attr
, cluster_intern(cluster
));
1012 struct transit
*transit
= bgp_attr_get_transit(attr
);
1015 if (!transit
->refcnt
)
1016 bgp_attr_set_transit(attr
, transit_intern(transit
));
1020 if (attr
->encap_subtlvs
) {
1021 if (!attr
->encap_subtlvs
->refcnt
)
1022 attr
->encap_subtlvs
= encap_intern(attr
->encap_subtlvs
,
1025 attr
->encap_subtlvs
->refcnt
++;
1027 if (attr
->srv6_l3vpn
) {
1028 if (!attr
->srv6_l3vpn
->refcnt
)
1029 attr
->srv6_l3vpn
= srv6_l3vpn_intern(attr
->srv6_l3vpn
);
1031 attr
->srv6_l3vpn
->refcnt
++;
1033 if (attr
->srv6_vpn
) {
1034 if (!attr
->srv6_vpn
->refcnt
)
1035 attr
->srv6_vpn
= srv6_vpn_intern(attr
->srv6_vpn
);
1037 attr
->srv6_vpn
->refcnt
++;
1039 #ifdef ENABLE_BGP_VNC
1040 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
1041 bgp_attr_get_vnc_subtlvs(attr
);
1044 if (!vnc_subtlvs
->refcnt
)
1045 bgp_attr_set_vnc_subtlvs(
1047 encap_intern(vnc_subtlvs
, VNC_SUBTLV_TYPE
));
1049 vnc_subtlvs
->refcnt
++;
1053 /* At this point, attr only contains intern'd pointers. that means
1054 * if we find it in attrhash, it has all the same pointers and we
1055 * correctly updated the refcounts on these.
1056 * If we don't find it, we need to allocate a one because in all
1057 * cases this returns a new reference to a hashed attr, but the input
1058 * wasn't on hash. */
1059 find
= (struct attr
*)hash_get(attrhash
, attr
, bgp_attr_hash_alloc
);
1065 /* Make network statement's attribute. */
1066 struct attr
*bgp_attr_default_set(struct attr
*attr
, struct bgp
*bgp
,
1069 memset(attr
, 0, sizeof(struct attr
));
1071 attr
->origin
= origin
;
1072 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
1073 attr
->aspath
= aspath_empty();
1074 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
1075 attr
->weight
= BGP_ATTR_DEFAULT_WEIGHT
;
1077 attr
->label_index
= BGP_INVALID_LABEL_INDEX
;
1078 attr
->label
= MPLS_INVALID_LABEL
;
1079 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
1080 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
1081 attr
->local_pref
= bgp
->default_local_pref
;
1086 /* Create the attributes for an aggregate */
1087 struct attr
*bgp_attr_aggregate_intern(
1088 struct bgp
*bgp
, uint8_t origin
, struct aspath
*aspath
,
1089 struct community
*community
, struct ecommunity
*ecommunity
,
1090 struct lcommunity
*lcommunity
, struct bgp_aggregate
*aggregate
,
1091 uint8_t atomic_aggregate
, const struct prefix
*p
)
1095 route_map_result_t ret
;
1097 memset(&attr
, 0, sizeof(attr
));
1099 /* Origin attribute. */
1100 attr
.origin
= origin
;
1101 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
1105 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
);
1107 /* AS path attribute. */
1109 attr
.aspath
= aspath_intern(aspath
);
1111 attr
.aspath
= aspath_empty();
1112 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
1114 /* Next hop attribute. */
1115 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
1118 uint32_t gshut
= COMMUNITY_GSHUT
;
1120 /* If we are not shutting down ourselves and we are
1121 * aggregating a route that contains the GSHUT community we
1122 * need to remove that community when creating the aggregate */
1123 if (!bgp_in_graceful_shutdown(bgp
)
1124 && community_include(community
, gshut
)) {
1125 community_del_val(community
, &gshut
);
1128 bgp_attr_set_community(&attr
, community
);
1132 bgp_attr_set_ecommunity(&attr
, ecommunity
);
1135 bgp_attr_set_lcommunity(&attr
, lcommunity
);
1137 if (bgp_in_graceful_shutdown(bgp
))
1138 bgp_attr_add_gshut_community(&attr
);
1140 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1141 attr
.label
= MPLS_INVALID_LABEL
;
1142 attr
.weight
= BGP_ATTR_DEFAULT_WEIGHT
;
1143 attr
.mp_nexthop_len
= IPV6_MAX_BYTELEN
;
1144 if (!aggregate
->as_set
|| atomic_aggregate
)
1145 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
);
1146 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
);
1147 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
))
1148 attr
.aggregator_as
= bgp
->confed_id
;
1150 attr
.aggregator_as
= bgp
->as
;
1151 attr
.aggregator_addr
= bgp
->router_id
;
1153 /* Apply route-map */
1154 if (aggregate
->rmap
.name
) {
1155 struct attr attr_tmp
= attr
;
1156 struct bgp_path_info rmap_path
;
1158 memset(&rmap_path
, 0, sizeof(rmap_path
));
1159 rmap_path
.peer
= bgp
->peer_self
;
1160 rmap_path
.attr
= &attr_tmp
;
1162 SET_FLAG(bgp
->peer_self
->rmap_type
, PEER_RMAP_TYPE_AGGREGATE
);
1164 ret
= route_map_apply(aggregate
->rmap
.map
, p
, &rmap_path
);
1166 bgp
->peer_self
->rmap_type
= 0;
1168 if (ret
== RMAP_DENYMATCH
) {
1169 /* Free uninterned attribute. */
1170 bgp_attr_flush(&attr_tmp
);
1172 /* Unintern original. */
1173 aspath_unintern(&attr
.aspath
);
1177 if (bgp_in_graceful_shutdown(bgp
))
1178 bgp_attr_add_gshut_community(&attr_tmp
);
1180 new = bgp_attr_intern(&attr_tmp
);
1183 if (bgp_in_graceful_shutdown(bgp
))
1184 bgp_attr_add_gshut_community(&attr
);
1186 new = bgp_attr_intern(&attr
);
1189 /* Always release the 'intern()'ed AS Path. */
1190 aspath_unintern(&attr
.aspath
);
1195 /* Unintern just the sub-components of the attr, but not the attr */
1196 void bgp_attr_unintern_sub(struct attr
*attr
)
1198 struct ecommunity
*ecomm
= NULL
;
1199 struct ecommunity
*ipv6_ecomm
= NULL
;
1200 struct cluster_list
*cluster
;
1201 struct lcommunity
*lcomm
= NULL
;
1202 struct community
*comm
= NULL
;
1204 /* aspath refcount shoud be decrement. */
1205 aspath_unintern(&attr
->aspath
);
1206 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
));
1208 comm
= bgp_attr_get_community(attr
);
1209 community_unintern(&comm
);
1210 bgp_attr_set_community(attr
, NULL
);
1212 ecomm
= bgp_attr_get_ecommunity(attr
);
1213 ecommunity_unintern(&ecomm
);
1214 bgp_attr_set_ecommunity(attr
, NULL
);
1216 ipv6_ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
1217 ecommunity_unintern(&ipv6_ecomm
);
1218 bgp_attr_set_ipv6_ecommunity(attr
, NULL
);
1220 lcomm
= bgp_attr_get_lcommunity(attr
);
1221 lcommunity_unintern(&lcomm
);
1222 bgp_attr_set_lcommunity(attr
, NULL
);
1224 cluster
= bgp_attr_get_cluster(attr
);
1226 cluster_unintern(&cluster
);
1227 bgp_attr_set_cluster(attr
, cluster
);
1229 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST
));
1231 struct transit
*transit
= bgp_attr_get_transit(attr
);
1234 transit_unintern(&transit
);
1235 bgp_attr_set_transit(attr
, transit
);
1238 if (attr
->encap_subtlvs
)
1239 encap_unintern(&attr
->encap_subtlvs
, ENCAP_SUBTLV_TYPE
);
1241 #ifdef ENABLE_BGP_VNC
1242 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
1243 bgp_attr_get_vnc_subtlvs(attr
);
1246 encap_unintern(&vnc_subtlvs
, VNC_SUBTLV_TYPE
);
1247 bgp_attr_set_vnc_subtlvs(attr
, vnc_subtlvs
);
1251 if (attr
->srv6_l3vpn
)
1252 srv6_l3vpn_unintern(&attr
->srv6_l3vpn
);
1255 srv6_vpn_unintern(&attr
->srv6_vpn
);
1258 /* Free bgp attribute and aspath. */
1259 void bgp_attr_unintern(struct attr
**pattr
)
1261 struct attr
*attr
= *pattr
;
1265 /* Decrement attribute reference. */
1270 /* If reference becomes zero then free attribute object. */
1271 if (attr
->refcnt
== 0) {
1272 ret
= hash_release(attrhash
, attr
);
1273 assert(ret
!= NULL
);
1274 XFREE(MTYPE_ATTR
, attr
);
1278 bgp_attr_unintern_sub(&tmp
);
1281 void bgp_attr_flush(struct attr
*attr
)
1283 struct ecommunity
*ecomm
;
1284 struct ecommunity
*ipv6_ecomm
;
1285 struct cluster_list
*cluster
;
1286 struct lcommunity
*lcomm
;
1287 struct community
*comm
;
1289 if (attr
->aspath
&& !attr
->aspath
->refcnt
) {
1290 aspath_free(attr
->aspath
);
1291 attr
->aspath
= NULL
;
1293 comm
= bgp_attr_get_community(attr
);
1294 if (comm
&& !comm
->refcnt
)
1295 community_free(&comm
);
1296 bgp_attr_set_community(attr
, NULL
);
1298 ecomm
= bgp_attr_get_ecommunity(attr
);
1299 if (ecomm
&& !ecomm
->refcnt
)
1300 ecommunity_free(&ecomm
);
1301 bgp_attr_set_ecommunity(attr
, NULL
);
1303 ipv6_ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
1304 if (ipv6_ecomm
&& !ipv6_ecomm
->refcnt
)
1305 ecommunity_free(&ipv6_ecomm
);
1306 bgp_attr_set_ipv6_ecommunity(attr
, NULL
);
1308 lcomm
= bgp_attr_get_lcommunity(attr
);
1309 if (lcomm
&& !lcomm
->refcnt
)
1310 lcommunity_free(&lcomm
);
1311 bgp_attr_set_lcommunity(attr
, NULL
);
1313 cluster
= bgp_attr_get_cluster(attr
);
1314 if (cluster
&& !cluster
->refcnt
) {
1315 cluster_free(cluster
);
1316 bgp_attr_set_cluster(attr
, NULL
);
1319 struct transit
*transit
= bgp_attr_get_transit(attr
);
1321 if (transit
&& !transit
->refcnt
) {
1322 transit_free(transit
);
1323 bgp_attr_set_transit(attr
, NULL
);
1325 if (attr
->encap_subtlvs
&& !attr
->encap_subtlvs
->refcnt
) {
1326 encap_free(attr
->encap_subtlvs
);
1327 attr
->encap_subtlvs
= NULL
;
1329 if (attr
->srv6_l3vpn
&& !attr
->srv6_l3vpn
->refcnt
) {
1330 srv6_l3vpn_free(attr
->srv6_l3vpn
);
1331 attr
->srv6_l3vpn
= NULL
;
1333 if (attr
->srv6_vpn
&& !attr
->srv6_vpn
->refcnt
) {
1334 srv6_vpn_free(attr
->srv6_vpn
);
1335 attr
->srv6_vpn
= NULL
;
1337 #ifdef ENABLE_BGP_VNC
1338 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
1339 bgp_attr_get_vnc_subtlvs(attr
);
1341 if (vnc_subtlvs
&& !vnc_subtlvs
->refcnt
) {
1342 encap_free(vnc_subtlvs
);
1343 bgp_attr_set_vnc_subtlvs(attr
, NULL
);
1348 /* Implement draft-scudder-idr-optional-transitive behaviour and
1349 * avoid resetting sessions for malformed attributes which are
1350 * are partial/optional and hence where the error likely was not
1351 * introduced by the sending neighbour.
1353 static enum bgp_attr_parse_ret
1354 bgp_attr_malformed(struct bgp_attr_parser_args
*args
, uint8_t subcode
,
1357 struct peer
*const peer
= args
->peer
;
1358 struct attr
*const attr
= args
->attr
;
1359 const uint8_t flags
= args
->flags
;
1360 /* startp and length must be special-cased, as whether or not to
1361 * send the attribute data with the NOTIFY depends on the error,
1362 * the caller therefore signals this with the seperate length argument
1364 uint8_t *notify_datap
= (length
> 0 ? args
->startp
: NULL
);
1366 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1367 char attr_str
[BUFSIZ
] = {0};
1369 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1371 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1374 /* Only relax error handling for eBGP peers */
1375 if (peer
->sort
!= BGP_PEER_EBGP
) {
1376 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
, subcode
,
1377 notify_datap
, length
);
1378 return BGP_ATTR_PARSE_ERROR
;
1381 /* Adjust the stream getp to the end of the attribute, in case we can
1382 * still proceed but the caller hasn't read all the attribute.
1384 stream_set_getp(BGP_INPUT(peer
),
1385 (args
->startp
- STREAM_DATA(BGP_INPUT(peer
)))
1388 switch (args
->type
) {
1389 /* where an attribute is relatively inconsequential, e.g. it does not
1390 * affect route selection, and can be safely ignored, then any such
1391 * attributes which are malformed should just be ignored and the route
1392 * processed as normal.
1394 case BGP_ATTR_AS4_AGGREGATOR
:
1395 case BGP_ATTR_AGGREGATOR
:
1396 case BGP_ATTR_ATOMIC_AGGREGATE
:
1397 return BGP_ATTR_PARSE_PROCEED
;
1399 /* Core attributes, particularly ones which may influence route
1400 * selection, should be treat-as-withdraw.
1402 case BGP_ATTR_ORIGIN
:
1403 case BGP_ATTR_AS_PATH
:
1404 case BGP_ATTR_NEXT_HOP
:
1405 case BGP_ATTR_MULTI_EXIT_DISC
:
1406 case BGP_ATTR_LOCAL_PREF
:
1407 case BGP_ATTR_COMMUNITIES
:
1408 case BGP_ATTR_EXT_COMMUNITIES
:
1409 case BGP_ATTR_IPV6_EXT_COMMUNITIES
:
1410 case BGP_ATTR_LARGE_COMMUNITIES
:
1411 case BGP_ATTR_ORIGINATOR_ID
:
1412 case BGP_ATTR_CLUSTER_LIST
:
1414 return BGP_ATTR_PARSE_WITHDRAW
;
1415 case BGP_ATTR_MP_REACH_NLRI
:
1416 case BGP_ATTR_MP_UNREACH_NLRI
:
1417 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
, subcode
,
1418 notify_datap
, length
);
1419 return BGP_ATTR_PARSE_ERROR
;
1422 /* Partial optional attributes that are malformed should not cause
1423 * the whole session to be reset. Instead treat it as a withdrawal
1424 * of the routes, if possible.
1426 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
)
1427 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1428 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_PARTIAL
))
1429 return BGP_ATTR_PARSE_WITHDRAW
;
1431 /* default to reset */
1432 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
1435 /* Find out what is wrong with the path attribute flag bits and log the error.
1436 "Flag bits" here stand for Optional, Transitive and Partial, but not for
1437 Extended Length. Checking O/T/P bits at once implies, that the attribute
1438 being diagnosed is defined by RFC as either a "well-known" or an "optional,
1439 non-transitive" attribute. */
1441 bgp_attr_flags_diagnose(struct bgp_attr_parser_args
*args
,
1442 uint8_t desired_flags
/* how RFC says it must be */
1445 uint8_t seen
= 0, i
;
1446 uint8_t real_flags
= args
->flags
;
1447 const uint8_t attr_code
= args
->type
;
1449 desired_flags
&= ~BGP_ATTR_FLAG_EXTLEN
;
1450 real_flags
&= ~BGP_ATTR_FLAG_EXTLEN
;
1451 for (i
= 0; i
<= 2; i
++) /* O,T,P, but not E */
1452 if (CHECK_FLAG(desired_flags
, attr_flag_str
[i
].key
)
1453 != CHECK_FLAG(real_flags
, attr_flag_str
[i
].key
)) {
1454 flog_err(EC_BGP_ATTR_FLAG
,
1455 "%s attribute must%s be flagged as \"%s\"",
1456 lookup_msg(attr_str
, attr_code
, NULL
),
1457 CHECK_FLAG(desired_flags
, attr_flag_str
[i
].key
)
1460 attr_flag_str
[i
].str
);
1465 "Strange, %s called for attr %s, but no problem found with flags (real flags 0x%x, desired 0x%x)",
1466 __func__
, lookup_msg(attr_str
, attr_code
, NULL
),
1467 real_flags
, desired_flags
);
1471 /* Required flags for attributes. EXTLEN will be masked off when testing,
1472 * as will PARTIAL for optional+transitive attributes.
1474 const uint8_t attr_flags_values
[] = {
1475 [BGP_ATTR_ORIGIN
] = BGP_ATTR_FLAG_TRANS
,
1476 [BGP_ATTR_AS_PATH
] = BGP_ATTR_FLAG_TRANS
,
1477 [BGP_ATTR_NEXT_HOP
] = BGP_ATTR_FLAG_TRANS
,
1478 [BGP_ATTR_MULTI_EXIT_DISC
] = BGP_ATTR_FLAG_OPTIONAL
,
1479 [BGP_ATTR_LOCAL_PREF
] = BGP_ATTR_FLAG_TRANS
,
1480 [BGP_ATTR_ATOMIC_AGGREGATE
] = BGP_ATTR_FLAG_TRANS
,
1481 [BGP_ATTR_AGGREGATOR
] = BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
,
1482 [BGP_ATTR_COMMUNITIES
] = BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
,
1483 [BGP_ATTR_ORIGINATOR_ID
] = BGP_ATTR_FLAG_OPTIONAL
,
1484 [BGP_ATTR_CLUSTER_LIST
] = BGP_ATTR_FLAG_OPTIONAL
,
1485 [BGP_ATTR_MP_REACH_NLRI
] = BGP_ATTR_FLAG_OPTIONAL
,
1486 [BGP_ATTR_MP_UNREACH_NLRI
] = BGP_ATTR_FLAG_OPTIONAL
,
1487 [BGP_ATTR_EXT_COMMUNITIES
] =
1488 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1489 [BGP_ATTR_AS4_PATH
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1490 [BGP_ATTR_AS4_AGGREGATOR
] =
1491 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1492 [BGP_ATTR_PMSI_TUNNEL
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1493 [BGP_ATTR_LARGE_COMMUNITIES
] =
1494 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1495 [BGP_ATTR_OTC
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1496 [BGP_ATTR_PREFIX_SID
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1497 [BGP_ATTR_IPV6_EXT_COMMUNITIES
] =
1498 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1499 [BGP_ATTR_AIGP
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1501 static const size_t attr_flags_values_max
= array_size(attr_flags_values
) - 1;
1503 static bool bgp_attr_flag_invalid(struct bgp_attr_parser_args
*args
)
1505 uint8_t mask
= BGP_ATTR_FLAG_EXTLEN
;
1506 const uint8_t flags
= args
->flags
;
1507 const uint8_t attr_code
= args
->type
;
1509 /* there may be attributes we don't know about */
1510 if (attr_code
> attr_flags_values_max
)
1512 if (attr_flags_values
[attr_code
] == 0)
1515 /* RFC4271, "For well-known attributes, the Transitive bit MUST be set
1519 if (!CHECK_FLAG(BGP_ATTR_FLAG_OPTIONAL
, flags
)
1520 && !CHECK_FLAG(BGP_ATTR_FLAG_TRANS
, flags
)) {
1523 "%s well-known attributes must have transitive flag set (%x)",
1524 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1528 /* "For well-known attributes and for optional non-transitive
1530 * the Partial bit MUST be set to 0."
1532 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_PARTIAL
)) {
1533 if (!CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)) {
1534 flog_err(EC_BGP_ATTR_FLAG
,
1535 "%s well-known attribute must NOT have the partial flag set (%x)",
1536 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1539 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1540 && !CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
)) {
1541 flog_err(EC_BGP_ATTR_FLAG
,
1542 "%s optional + transitive attribute must NOT have the partial flag set (%x)",
1543 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1548 /* Optional transitive attributes may go through speakers that don't
1549 * reocgnise them and set the Partial bit.
1551 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1552 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
))
1553 SET_FLAG(mask
, BGP_ATTR_FLAG_PARTIAL
);
1555 if ((flags
& ~mask
) == attr_flags_values
[attr_code
])
1558 bgp_attr_flags_diagnose(args
, attr_flags_values
[attr_code
]);
1562 /* Get origin attribute of the update message. */
1563 static enum bgp_attr_parse_ret
1564 bgp_attr_origin(struct bgp_attr_parser_args
*args
)
1566 struct peer
*const peer
= args
->peer
;
1567 struct attr
*const attr
= args
->attr
;
1568 const bgp_size_t length
= args
->length
;
1570 /* If any recognized attribute has Attribute Length that conflicts
1571 with the expected length (based on the attribute type code), then
1572 the Error Subcode is set to Attribute Length Error. The Data
1573 field contains the erroneous attribute (type, length and
1576 flog_err(EC_BGP_ATTR_LEN
,
1577 "Origin attribute length is not one %d", length
);
1578 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1582 /* Fetch origin attribute. */
1583 attr
->origin
= stream_getc(BGP_INPUT(peer
));
1585 /* If the ORIGIN attribute has an undefined value, then the Error
1586 Subcode is set to Invalid Origin Attribute. The Data field
1587 contains the unrecognized attribute (type, length and value). */
1588 if ((attr
->origin
!= BGP_ORIGIN_IGP
) && (attr
->origin
!= BGP_ORIGIN_EGP
)
1589 && (attr
->origin
!= BGP_ORIGIN_INCOMPLETE
)) {
1590 flog_err(EC_BGP_ATTR_ORIGIN
,
1591 "Origin attribute value is invalid %d", attr
->origin
);
1592 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_INVAL_ORIGIN
,
1596 /* Set oring attribute flag. */
1597 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
1602 /* Parse AS path information. This function is wrapper of
1604 static int bgp_attr_aspath(struct bgp_attr_parser_args
*args
)
1606 struct attr
*const attr
= args
->attr
;
1607 struct peer
*const peer
= args
->peer
;
1608 const bgp_size_t length
= args
->length
;
1611 * peer with AS4 => will get 4Byte ASnums
1612 * otherwise, will get 16 Bit
1614 attr
->aspath
= aspath_parse(
1616 CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1617 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
));
1619 /* In case of IBGP, length will be zero. */
1620 if (!attr
->aspath
) {
1621 flog_err(EC_BGP_ATTR_MAL_AS_PATH
,
1622 "Malformed AS path from %s, length is %d", peer
->host
,
1624 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1628 /* Conformant BGP speakers SHOULD NOT send BGP
1629 * UPDATE messages containing AS_SET or AS_CONFED_SET. Upon receipt of
1630 * such messages, conformant BGP speakers SHOULD use the "Treat-as-
1631 * withdraw" error handling behavior as per [RFC7606].
1633 if (peer
->bgp
->reject_as_sets
&& aspath_check_as_sets(attr
->aspath
)) {
1634 flog_err(EC_BGP_ATTR_MAL_AS_PATH
,
1635 "AS_SET and AS_CONFED_SET are deprecated from %pBP",
1637 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1641 /* Set aspath attribute flag. */
1642 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
1644 return BGP_ATTR_PARSE_PROCEED
;
1647 static enum bgp_attr_parse_ret
bgp_attr_aspath_check(struct peer
*const peer
,
1648 struct attr
*const attr
)
1650 /* These checks were part of bgp_attr_aspath, but with
1651 * as4 we should to check aspath things when
1652 * aspath synthesizing with as4_path has already taken place.
1653 * Otherwise we check ASPATH and use the synthesized thing, and that is
1655 * So do the checks later, i.e. here
1657 struct aspath
*aspath
;
1659 /* Confederation sanity check. */
1660 if ((peer
->sort
== BGP_PEER_CONFED
1661 && !aspath_left_confed_check(attr
->aspath
))
1662 || (peer
->sort
== BGP_PEER_EBGP
1663 && aspath_confed_check(attr
->aspath
))) {
1664 flog_err(EC_BGP_ATTR_MAL_AS_PATH
, "Malformed AS path from %s",
1666 return BGP_ATTR_PARSE_WITHDRAW
;
1669 /* First AS check for EBGP. */
1670 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_ENFORCE_FIRST_AS
)) {
1671 if (peer
->sort
== BGP_PEER_EBGP
1672 && !aspath_firstas_check(attr
->aspath
, peer
->as
)) {
1673 flog_err(EC_BGP_ATTR_FIRST_AS
,
1674 "%s incorrect first AS (must be %u)",
1675 peer
->host
, peer
->as
);
1676 return BGP_ATTR_PARSE_WITHDRAW
;
1680 /* Codification of AS 0 Processing */
1681 if (peer
->sort
== BGP_PEER_EBGP
&& aspath_check_as_zero(attr
->aspath
)) {
1683 EC_BGP_ATTR_MAL_AS_PATH
,
1684 "Malformed AS path, AS number is 0 in the path from %s",
1686 return BGP_ATTR_PARSE_WITHDRAW
;
1689 /* local-as prepend */
1690 if (peer
->change_local_as
1691 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)) {
1692 aspath
= aspath_dup(attr
->aspath
);
1693 aspath
= aspath_add_seq(aspath
, peer
->change_local_as
);
1694 aspath_unintern(&attr
->aspath
);
1695 attr
->aspath
= aspath_intern(aspath
);
1698 return BGP_ATTR_PARSE_PROCEED
;
1701 /* Parse AS4 path information. This function is another wrapper of
1703 static int bgp_attr_as4_path(struct bgp_attr_parser_args
*args
,
1704 struct aspath
**as4_path
)
1706 struct peer
*const peer
= args
->peer
;
1707 struct attr
*const attr
= args
->attr
;
1708 const bgp_size_t length
= args
->length
;
1710 *as4_path
= aspath_parse(peer
->curr
, length
, 1);
1712 /* In case of IBGP, length will be zero. */
1714 flog_err(EC_BGP_ATTR_MAL_AS_PATH
,
1715 "Malformed AS4 path from %s, length is %d", peer
->host
,
1717 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1721 /* Conformant BGP speakers SHOULD NOT send BGP
1722 * UPDATE messages containing AS_SET or AS_CONFED_SET. Upon receipt of
1723 * such messages, conformant BGP speakers SHOULD use the "Treat-as-
1724 * withdraw" error handling behavior as per [RFC7606].
1726 if (peer
->bgp
->reject_as_sets
&& aspath_check_as_sets(attr
->aspath
)) {
1727 flog_err(EC_BGP_ATTR_MAL_AS_PATH
,
1728 "AS_SET and AS_CONFED_SET are deprecated from %pBP",
1730 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1734 /* Set aspath attribute flag. */
1735 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
);
1737 return BGP_ATTR_PARSE_PROCEED
;
1741 * Check that the nexthop attribute is valid.
1743 enum bgp_attr_parse_ret
bgp_attr_nexthop_valid(struct peer
*peer
,
1746 struct bgp
*bgp
= peer
->bgp
;
1748 if (ipv4_martian(&attr
->nexthop
) && !bgp
->allow_martian
) {
1749 uint8_t data
[7]; /* type(2) + length(1) + nhop(4) */
1751 flog_err(EC_BGP_ATTR_MARTIAN_NH
, "Martian nexthop %pI4",
1753 data
[0] = BGP_ATTR_FLAG_TRANS
;
1754 data
[1] = BGP_ATTR_NEXT_HOP
;
1755 data
[2] = BGP_ATTR_NHLEN_IPV4
;
1756 memcpy(&data
[3], &attr
->nexthop
.s_addr
, BGP_ATTR_NHLEN_IPV4
);
1757 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
1758 BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP
,
1760 return BGP_ATTR_PARSE_ERROR
;
1763 return BGP_ATTR_PARSE_PROCEED
;
1766 /* Nexthop attribute. */
1767 static enum bgp_attr_parse_ret
1768 bgp_attr_nexthop(struct bgp_attr_parser_args
*args
)
1770 struct peer
*const peer
= args
->peer
;
1771 struct attr
*const attr
= args
->attr
;
1772 const bgp_size_t length
= args
->length
;
1774 /* Check nexthop attribute length. */
1776 flog_err(EC_BGP_ATTR_LEN
,
1777 "Nexthop attribute length isn't four [%d]", length
);
1779 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1783 attr
->nexthop
.s_addr
= stream_get_ipv4(peer
->curr
);
1784 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
1786 return BGP_ATTR_PARSE_PROCEED
;
1789 /* MED atrribute. */
1790 static enum bgp_attr_parse_ret
bgp_attr_med(struct bgp_attr_parser_args
*args
)
1792 struct peer
*const peer
= args
->peer
;
1793 struct attr
*const attr
= args
->attr
;
1794 const bgp_size_t length
= args
->length
;
1798 flog_err(EC_BGP_ATTR_LEN
,
1799 "MED attribute length isn't four [%d]", length
);
1801 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1805 attr
->med
= stream_getl(peer
->curr
);
1807 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
);
1809 return BGP_ATTR_PARSE_PROCEED
;
1812 /* Local preference attribute. */
1813 static enum bgp_attr_parse_ret
1814 bgp_attr_local_pref(struct bgp_attr_parser_args
*args
)
1816 struct peer
*const peer
= args
->peer
;
1817 struct attr
*const attr
= args
->attr
;
1818 const bgp_size_t length
= args
->length
;
1820 /* if received from an internal neighbor, it SHALL be considered
1821 * malformed if its length is not equal to 4. If malformed, the
1822 * UPDATE message SHALL be handled using the approach of "treat-as-
1825 if (peer
->sort
== BGP_PEER_IBGP
&& length
!= 4) {
1826 flog_err(EC_BGP_ATTR_LEN
,
1827 "LOCAL_PREF attribute length isn't 4 [%u]", length
);
1828 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1832 /* If it is contained in an UPDATE message that is received from an
1833 external peer, then this attribute MUST be ignored by the
1834 receiving speaker. */
1835 if (peer
->sort
== BGP_PEER_EBGP
) {
1836 STREAM_FORWARD_GETP(peer
->curr
, length
);
1837 return BGP_ATTR_PARSE_PROCEED
;
1840 STREAM_GETL(peer
->curr
, attr
->local_pref
);
1842 /* Set the local-pref flag. */
1843 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
);
1845 return BGP_ATTR_PARSE_PROCEED
;
1848 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1852 /* Atomic aggregate. */
1853 static int bgp_attr_atomic(struct bgp_attr_parser_args
*args
)
1855 struct attr
*const attr
= args
->attr
;
1856 const bgp_size_t length
= args
->length
;
1860 flog_err(EC_BGP_ATTR_LEN
,
1861 "ATOMIC_AGGREGATE attribute length isn't 0 [%u]",
1863 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1867 /* Set atomic aggregate flag. */
1868 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
);
1870 return BGP_ATTR_PARSE_PROCEED
;
1873 /* Aggregator attribute */
1874 static int bgp_attr_aggregator(struct bgp_attr_parser_args
*args
)
1876 struct peer
*const peer
= args
->peer
;
1877 struct attr
*const attr
= args
->attr
;
1878 const bgp_size_t length
= args
->length
;
1883 /* peer with AS4 will send 4 Byte AS, peer without will send 2 Byte */
1884 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1885 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
))
1888 if (length
!= wantedlen
) {
1889 flog_err(EC_BGP_ATTR_LEN
,
1890 "AGGREGATOR attribute length isn't %u [%u]", wantedlen
,
1892 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1896 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
))
1897 aggregator_as
= stream_getl(peer
->curr
);
1899 aggregator_as
= stream_getw(peer
->curr
);
1901 attr
->aggregator_as
= aggregator_as
;
1902 attr
->aggregator_addr
.s_addr
= stream_get_ipv4(peer
->curr
);
1904 /* Codification of AS 0 Processing */
1905 if (aggregator_as
== BGP_AS_ZERO
) {
1906 flog_err(EC_BGP_ATTR_LEN
,
1907 "%s: AGGREGATOR AS number is 0 for aspath: %s",
1908 peer
->host
, aspath_print(attr
->aspath
));
1910 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1911 char attr_str
[BUFSIZ
] = {0};
1913 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1915 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1918 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
);
1921 return BGP_ATTR_PARSE_PROCEED
;
1924 /* New Aggregator attribute */
1925 static enum bgp_attr_parse_ret
1926 bgp_attr_as4_aggregator(struct bgp_attr_parser_args
*args
,
1927 as_t
*as4_aggregator_as
,
1928 struct in_addr
*as4_aggregator_addr
)
1930 struct peer
*const peer
= args
->peer
;
1931 struct attr
*const attr
= args
->attr
;
1932 const bgp_size_t length
= args
->length
;
1936 flog_err(EC_BGP_ATTR_LEN
, "New Aggregator length is not 8 [%d]",
1938 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1942 aggregator_as
= stream_getl(peer
->curr
);
1944 *as4_aggregator_as
= aggregator_as
;
1945 as4_aggregator_addr
->s_addr
= stream_get_ipv4(peer
->curr
);
1947 /* Codification of AS 0 Processing */
1948 if (aggregator_as
== BGP_AS_ZERO
) {
1949 flog_err(EC_BGP_ATTR_LEN
,
1950 "%s: AS4_AGGREGATOR AS number is 0 for aspath: %s",
1951 peer
->host
, aspath_print(attr
->aspath
));
1953 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1954 char attr_str
[BUFSIZ
] = {0};
1956 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1958 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1961 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
);
1964 return BGP_ATTR_PARSE_PROCEED
;
1967 /* Munge Aggregator and New-Aggregator, AS_PATH and NEW_AS_PATH.
1969 static enum bgp_attr_parse_ret
1970 bgp_attr_munge_as4_attrs(struct peer
*const peer
, struct attr
*const attr
,
1971 struct aspath
*as4_path
, as_t as4_aggregator
,
1972 struct in_addr
*as4_aggregator_addr
)
1974 int ignore_as4_path
= 0;
1975 struct aspath
*newpath
;
1977 if (!attr
->aspath
) {
1978 /* NULL aspath shouldn't be possible as bgp_attr_parse should
1980 * checked that all well-known, mandatory attributes were
1983 * Can only be a problem with peer itself - hard error
1985 return BGP_ATTR_PARSE_ERROR
;
1988 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)) {
1989 /* peer can do AS4, so we ignore AS4_PATH and AS4_AGGREGATOR
1991 * It is worth a warning though, because the peer really
1992 * should not send them
1994 if (BGP_DEBUG(as4
, AS4
)) {
1995 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
)))
1996 zlog_debug("[AS4] %s %s AS4_PATH", peer
->host
,
1997 "AS4 capable peer, yet it sent");
2000 & (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
)))
2001 zlog_debug("[AS4] %s %s AS4_AGGREGATOR",
2003 "AS4 capable peer, yet it sent");
2006 return BGP_ATTR_PARSE_PROCEED
;
2009 /* We have a asn16 peer. First, look for AS4_AGGREGATOR
2010 * because that may override AS4_PATH
2012 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
))) {
2013 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
))) {
2015 * if the as_number in aggregator is not AS_TRANS,
2016 * then AS4_AGGREGATOR and AS4_PATH shall be ignored
2017 * and the Aggregator shall be taken as
2018 * info on the aggregating node, and the AS_PATH
2019 * shall be taken as the AS_PATH
2021 * the Aggregator shall be ignored and the
2022 * AS4_AGGREGATOR shall be taken as the
2023 * Aggregating node and the AS_PATH is to be
2024 * constructed "as in all other cases"
2026 if (attr
->aggregator_as
!= BGP_AS_TRANS
) {
2028 if (BGP_DEBUG(as4
, AS4
))
2030 "[AS4] %s BGP not AS4 capable peer send AGGREGATOR != AS_TRANS and AS4_AGGREGATOR, so ignore AS4_AGGREGATOR and AS4_PATH",
2032 ignore_as4_path
= 1;
2034 /* "New_aggregator shall be taken as aggregator"
2036 attr
->aggregator_as
= as4_aggregator
;
2037 attr
->aggregator_addr
.s_addr
=
2038 as4_aggregator_addr
->s_addr
;
2041 /* We received a AS4_AGGREGATOR but no AGGREGATOR.
2042 * That is bogus - but reading the conditions
2043 * we have to handle AS4_AGGREGATOR as if it were
2044 * AGGREGATOR in that case
2046 if (BGP_DEBUG(as4
, AS4
))
2048 "[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",
2050 attr
->aggregator_as
= as4_aggregator
;
2051 /* sweep it under the carpet and simulate a "good"
2053 attr
->flag
|= (ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
));
2057 /* need to reconcile NEW_AS_PATH and AS_PATH */
2058 if (!ignore_as4_path
2059 && (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
)))) {
2060 newpath
= aspath_reconcile_as4(attr
->aspath
, as4_path
);
2062 return BGP_ATTR_PARSE_ERROR
;
2064 aspath_unintern(&attr
->aspath
);
2065 attr
->aspath
= aspath_intern(newpath
);
2067 return BGP_ATTR_PARSE_PROCEED
;
2070 /* Community attribute. */
2071 static enum bgp_attr_parse_ret
2072 bgp_attr_community(struct bgp_attr_parser_args
*args
)
2074 struct peer
*const peer
= args
->peer
;
2075 struct attr
*const attr
= args
->attr
;
2076 const bgp_size_t length
= args
->length
;
2079 bgp_attr_set_community(attr
, NULL
);
2080 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2084 bgp_attr_set_community(
2086 community_parse((uint32_t *)stream_pnt(peer
->curr
), length
));
2088 /* XXX: fix community_parse to use stream API and remove this */
2089 stream_forward_getp(peer
->curr
, length
);
2091 /* The Community attribute SHALL be considered malformed if its
2092 * length is not a non-zero multiple of 4.
2094 if (!bgp_attr_get_community(attr
))
2095 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2098 return BGP_ATTR_PARSE_PROCEED
;
2101 /* Originator ID attribute. */
2102 static enum bgp_attr_parse_ret
2103 bgp_attr_originator_id(struct bgp_attr_parser_args
*args
)
2105 struct peer
*const peer
= args
->peer
;
2106 struct attr
*const attr
= args
->attr
;
2107 const bgp_size_t length
= args
->length
;
2109 /* if received from an internal neighbor, it SHALL be considered
2110 * malformed if its length is not equal to 4. If malformed, the
2111 * UPDATE message SHALL be handled using the approach of "treat-as-
2115 flog_err(EC_BGP_ATTR_LEN
, "Bad originator ID length %d",
2118 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2122 attr
->originator_id
.s_addr
= stream_get_ipv4(peer
->curr
);
2124 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
);
2126 return BGP_ATTR_PARSE_PROCEED
;
2129 /* Cluster list attribute. */
2130 static enum bgp_attr_parse_ret
2131 bgp_attr_cluster_list(struct bgp_attr_parser_args
*args
)
2133 struct peer
*const peer
= args
->peer
;
2134 struct attr
*const attr
= args
->attr
;
2135 const bgp_size_t length
= args
->length
;
2137 /* if received from an internal neighbor, it SHALL be considered
2138 * malformed if its length is not a non-zero multiple of 4. If
2139 * malformed, the UPDATE message SHALL be handled using the approach
2140 * of "treat-as-withdraw".
2142 if (length
== 0 || length
% 4) {
2143 flog_err(EC_BGP_ATTR_LEN
, "Bad cluster list length %d", length
);
2145 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2149 bgp_attr_set_cluster(
2150 attr
, cluster_parse((struct in_addr
*)stream_pnt(peer
->curr
),
2153 /* XXX: Fix cluster_parse to use stream API and then remove this */
2154 stream_forward_getp(peer
->curr
, length
);
2156 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST
);
2158 return BGP_ATTR_PARSE_PROCEED
;
2161 /* Multiprotocol reachability information parse. */
2162 int bgp_mp_reach_parse(struct bgp_attr_parser_args
*args
,
2163 struct bgp_nlri
*mp_update
)
2167 iana_safi_t pkt_safi
;
2169 bgp_size_t nlri_len
;
2172 struct peer
*const peer
= args
->peer
;
2173 struct attr
*const attr
= args
->attr
;
2174 const bgp_size_t length
= args
->length
;
2176 /* Set end of packet. */
2177 s
= BGP_INPUT(peer
);
2178 start
= stream_get_getp(s
);
2180 /* safe to read statically sized header? */
2181 #define BGP_MP_REACH_MIN_SIZE 5
2182 #define LEN_LEFT (length - (stream_get_getp(s) - start))
2183 if ((length
> STREAM_READABLE(s
)) || (length
< BGP_MP_REACH_MIN_SIZE
)) {
2184 zlog_info("%s: %s sent invalid length, %lu, of MP_REACH_NLRI",
2185 __func__
, peer
->host
, (unsigned long)length
);
2186 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2189 /* Load AFI, SAFI. */
2190 pkt_afi
= stream_getw(s
);
2191 pkt_safi
= stream_getc(s
);
2193 /* Convert AFI, SAFI to internal values, check. */
2194 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
2195 /* Log if AFI or SAFI is unrecognized. This is not an error
2197 * the attribute is otherwise malformed.
2199 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
2201 "%s sent unrecognizable AFI, %s or, SAFI, %s, of MP_REACH_NLRI",
2202 peer
->host
, iana_afi2str(pkt_afi
),
2203 iana_safi2str(pkt_safi
));
2204 return BGP_ATTR_PARSE_ERROR
;
2207 /* Get nexthop length. */
2208 attr
->mp_nexthop_len
= stream_getc(s
);
2210 if (LEN_LEFT
< attr
->mp_nexthop_len
) {
2212 "%s: %s sent next-hop length, %u, in MP_REACH_NLRI which goes past the end of attribute",
2213 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2214 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2217 /* Nexthop length check. */
2218 switch (attr
->mp_nexthop_len
) {
2220 if (safi
!= SAFI_FLOWSPEC
) {
2221 zlog_info("%s: %s sent wrong next-hop length, %d, in MP_REACH_NLRI",
2222 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2223 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2226 case BGP_ATTR_NHLEN_VPNV4
:
2227 stream_getl(s
); /* RD high */
2228 stream_getl(s
); /* RD low */
2230 * NOTE: intentional fall through
2231 * - for consistency in rx processing
2233 * The following comment is to signal GCC this intention
2234 * and suppress the warning
2237 case BGP_ATTR_NHLEN_IPV4
:
2238 stream_get(&attr
->mp_nexthop_global_in
, s
, IPV4_MAX_BYTELEN
);
2239 /* Probably needed for RFC 2283 */
2240 if (attr
->nexthop
.s_addr
== INADDR_ANY
)
2241 memcpy(&attr
->nexthop
.s_addr
,
2242 &attr
->mp_nexthop_global_in
, IPV4_MAX_BYTELEN
);
2244 case BGP_ATTR_NHLEN_IPV6_GLOBAL
:
2245 case BGP_ATTR_NHLEN_VPNV6_GLOBAL
:
2246 if (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_VPNV6_GLOBAL
) {
2247 stream_getl(s
); /* RD high */
2248 stream_getl(s
); /* RD low */
2250 stream_get(&attr
->mp_nexthop_global
, s
, IPV6_MAX_BYTELEN
);
2251 if (IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_global
)) {
2252 if (!peer
->nexthop
.ifp
) {
2253 zlog_warn("%s sent a v6 global attribute but address is a V6 LL and there's no peer interface information. Hence, withdrawing",
2255 return BGP_ATTR_PARSE_WITHDRAW
;
2257 attr
->nh_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2258 if (if_is_operative(peer
->nexthop
.ifp
))
2259 SET_FLAG(attr
->nh_flag
,
2260 BGP_ATTR_NH_IF_OPERSTATE
);
2262 UNSET_FLAG(attr
->nh_flag
,
2263 BGP_ATTR_NH_IF_OPERSTATE
);
2266 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
:
2267 case BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
:
2268 if (attr
->mp_nexthop_len
2269 == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
) {
2270 stream_getl(s
); /* RD high */
2271 stream_getl(s
); /* RD low */
2273 stream_get(&attr
->mp_nexthop_global
, s
, IPV6_MAX_BYTELEN
);
2274 if (IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_global
)) {
2275 if (!peer
->nexthop
.ifp
) {
2276 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",
2278 return BGP_ATTR_PARSE_WITHDRAW
;
2280 attr
->nh_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2281 if (if_is_operative(peer
->nexthop
.ifp
))
2282 SET_FLAG(attr
->nh_flag
,
2283 BGP_ATTR_NH_IF_OPERSTATE
);
2285 UNSET_FLAG(attr
->nh_flag
,
2286 BGP_ATTR_NH_IF_OPERSTATE
);
2288 if (attr
->mp_nexthop_len
2289 == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
) {
2290 stream_getl(s
); /* RD high */
2291 stream_getl(s
); /* RD low */
2293 stream_get(&attr
->mp_nexthop_local
, s
, IPV6_MAX_BYTELEN
);
2294 if (!IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_local
)) {
2295 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2297 "%s sent next-hops %pI6 and %pI6. Ignoring non-LL value",
2298 peer
->host
, &attr
->mp_nexthop_global
,
2299 &attr
->mp_nexthop_local
);
2301 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
2303 if (!peer
->nexthop
.ifp
) {
2304 zlog_warn("%s sent a v6 LL next-hop and there's no peer interface information. Hence, withdrawing",
2306 return BGP_ATTR_PARSE_WITHDRAW
;
2308 attr
->nh_lla_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2311 zlog_info("%s: %s sent wrong next-hop length, %d, in MP_REACH_NLRI",
2312 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2313 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2317 zlog_info("%s: %s sent SNPA which couldn't be read",
2318 __func__
, peer
->host
);
2319 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2324 if ((val
= stream_getc(s
)))
2326 EC_BGP_DEFUNCT_SNPA_LEN
,
2327 "%s sent non-zero value, %u, for defunct SNPA-length field",
2331 /* must have nrli_len, what is left of the attribute */
2332 nlri_len
= LEN_LEFT
;
2333 if (nlri_len
> STREAM_READABLE(s
)) {
2334 zlog_info("%s: %s sent MP_REACH_NLRI which couldn't be read",
2335 __func__
, peer
->host
);
2336 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2340 zlog_info("%s: %s sent a zero-length NLRI. Hence, treating as a EOR marker",
2341 __func__
, peer
->host
);
2343 mp_update
->afi
= afi
;
2344 mp_update
->safi
= safi
;
2345 return BGP_ATTR_PARSE_EOR
;
2348 mp_update
->afi
= afi
;
2349 mp_update
->safi
= safi
;
2350 mp_update
->nlri
= stream_pnt(s
);
2351 mp_update
->length
= nlri_len
;
2353 stream_forward_getp(s
, nlri_len
);
2355 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
);
2357 return BGP_ATTR_PARSE_PROCEED
;
2361 /* Multiprotocol unreachable parse */
2362 int bgp_mp_unreach_parse(struct bgp_attr_parser_args
*args
,
2363 struct bgp_nlri
*mp_withdraw
)
2368 iana_safi_t pkt_safi
;
2370 uint16_t withdraw_len
;
2371 struct peer
*const peer
= args
->peer
;
2372 struct attr
*const attr
= args
->attr
;
2373 const bgp_size_t length
= args
->length
;
2377 #define BGP_MP_UNREACH_MIN_SIZE 3
2378 if ((length
> STREAM_READABLE(s
)) || (length
< BGP_MP_UNREACH_MIN_SIZE
))
2379 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2381 pkt_afi
= stream_getw(s
);
2382 pkt_safi
= stream_getc(s
);
2384 /* Convert AFI, SAFI to internal values, check. */
2385 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
2386 /* Log if AFI or SAFI is unrecognized. This is not an error
2388 * the attribute is otherwise malformed.
2390 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
2392 "%s: MP_UNREACH received AFI %s or SAFI %s is unrecognized",
2393 peer
->host
, iana_afi2str(pkt_afi
),
2394 iana_safi2str(pkt_safi
));
2395 return BGP_ATTR_PARSE_ERROR
;
2398 withdraw_len
= length
- BGP_MP_UNREACH_MIN_SIZE
;
2400 mp_withdraw
->afi
= afi
;
2401 mp_withdraw
->safi
= safi
;
2402 mp_withdraw
->nlri
= stream_pnt(s
);
2403 mp_withdraw
->length
= withdraw_len
;
2405 stream_forward_getp(s
, withdraw_len
);
2407 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
);
2409 return BGP_ATTR_PARSE_PROCEED
;
2412 /* Large Community attribute. */
2413 static enum bgp_attr_parse_ret
2414 bgp_attr_large_community(struct bgp_attr_parser_args
*args
)
2416 struct peer
*const peer
= args
->peer
;
2417 struct attr
*const attr
= args
->attr
;
2418 const bgp_size_t length
= args
->length
;
2421 * Large community follows new attribute format.
2424 bgp_attr_set_lcommunity(attr
, NULL
);
2425 /* Empty extcomm doesn't seem to be invalid per se */
2426 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2430 bgp_attr_set_lcommunity(
2431 attr
, lcommunity_parse(stream_pnt(peer
->curr
), length
));
2432 /* XXX: fix ecommunity_parse to use stream API */
2433 stream_forward_getp(peer
->curr
, length
);
2435 if (!bgp_attr_get_lcommunity(attr
))
2436 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2439 return BGP_ATTR_PARSE_PROCEED
;
2442 /* Extended Community attribute. */
2443 static enum bgp_attr_parse_ret
2444 bgp_attr_ext_communities(struct bgp_attr_parser_args
*args
)
2446 struct peer
*const peer
= args
->peer
;
2447 struct attr
*const attr
= args
->attr
;
2448 const bgp_size_t length
= args
->length
;
2451 struct ecommunity
*ecomm
;
2454 bgp_attr_set_ecommunity(attr
, NULL
);
2455 /* Empty extcomm doesn't seem to be invalid per se */
2456 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2460 ecomm
= ecommunity_parse(
2461 stream_pnt(peer
->curr
), length
,
2462 CHECK_FLAG(peer
->flags
,
2463 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
));
2464 bgp_attr_set_ecommunity(attr
, ecomm
);
2465 /* XXX: fix ecommunity_parse to use stream API */
2466 stream_forward_getp(peer
->curr
, length
);
2468 /* The Extended Community attribute SHALL be considered malformed if
2469 * its length is not a non-zero multiple of 8.
2471 if (!bgp_attr_get_ecommunity(attr
))
2472 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2475 /* Extract DF election preference and mobility sequence number */
2476 attr
->df_pref
= bgp_attr_df_pref_from_ec(attr
, &attr
->df_alg
);
2478 /* Extract MAC mobility sequence number, if any. */
2479 attr
->mm_seqnum
= bgp_attr_mac_mobility_seqnum(attr
, &sticky
);
2480 attr
->sticky
= sticky
;
2482 /* Check if this is a Gateway MAC-IP advertisement */
2483 attr
->default_gw
= bgp_attr_default_gw(attr
);
2485 /* Handle scenario where router flag ecommunity is not
2486 * set but default gw ext community is present.
2487 * Use default gateway, set and propogate R-bit.
2489 if (attr
->default_gw
)
2490 attr
->router_flag
= 1;
2492 /* Check EVPN Neighbor advertisement flags, R-bit */
2493 bgp_attr_evpn_na_flag(attr
, &attr
->router_flag
, &proxy
);
2495 attr
->es_flags
|= ATTR_ES_PROXY_ADVERT
;
2497 /* Extract the Rmac, if any */
2498 if (bgp_attr_rmac(attr
, &attr
->rmac
)) {
2499 if (bgp_debug_update(peer
, NULL
, NULL
, 1)
2500 && bgp_mac_exist(&attr
->rmac
))
2501 zlog_debug("%s: router mac %pEA is self mac", __func__
,
2505 /* Get the tunnel type from encap extended community */
2506 bgp_attr_extcom_tunnel_type(attr
,
2507 (bgp_encap_types
*)&attr
->encap_tunneltype
);
2509 /* Extract link bandwidth, if any. */
2510 (void)ecommunity_linkbw_present(bgp_attr_get_ecommunity(attr
),
2513 return BGP_ATTR_PARSE_PROCEED
;
2516 /* IPv6 Extended Community attribute. */
2517 static enum bgp_attr_parse_ret
2518 bgp_attr_ipv6_ext_communities(struct bgp_attr_parser_args
*args
)
2520 struct peer
*const peer
= args
->peer
;
2521 struct attr
*const attr
= args
->attr
;
2522 const bgp_size_t length
= args
->length
;
2523 struct ecommunity
*ipv6_ecomm
= NULL
;
2526 bgp_attr_set_ipv6_ecommunity(attr
, ipv6_ecomm
);
2527 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2531 ipv6_ecomm
= ecommunity_parse_ipv6(
2532 stream_pnt(peer
->curr
), length
,
2533 CHECK_FLAG(peer
->flags
,
2534 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
));
2535 bgp_attr_set_ipv6_ecommunity(attr
, ipv6_ecomm
);
2537 /* XXX: fix ecommunity_parse to use stream API */
2538 stream_forward_getp(peer
->curr
, length
);
2541 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2544 return BGP_ATTR_PARSE_PROCEED
;
2547 /* Parse Tunnel Encap attribute in an UPDATE */
2548 static int bgp_attr_encap(uint8_t type
, struct peer
*peer
, /* IN */
2549 bgp_size_t length
, /* IN: attr's length field */
2550 struct attr
*attr
, /* IN: caller already allocated */
2551 uint8_t flag
, /* IN: attr's flags field */
2555 uint16_t tunneltype
= 0;
2557 total
= length
+ (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
) ? 4 : 3);
2559 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_TRANS
)
2560 || !CHECK_FLAG(flag
, BGP_ATTR_FLAG_OPTIONAL
)) {
2562 "Tunnel Encap attribute flag isn't optional and transitive %d",
2564 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
2565 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR
,
2570 if (BGP_ATTR_ENCAP
== type
) {
2571 /* read outer TLV type and length */
2572 uint16_t tlv_length
;
2576 "Tunnel Encap attribute not long enough to contain outer T,L");
2577 bgp_notify_send_with_data(
2578 peer
, BGP_NOTIFY_UPDATE_ERR
,
2579 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
, startp
, total
);
2582 tunneltype
= stream_getw(BGP_INPUT(peer
));
2583 tlv_length
= stream_getw(BGP_INPUT(peer
));
2586 if (tlv_length
!= length
) {
2587 zlog_info("%s: tlv_length(%d) != length(%d)",
2588 __func__
, tlv_length
, length
);
2592 while (length
>= 4) {
2593 uint16_t subtype
= 0;
2594 uint16_t sublength
= 0;
2595 struct bgp_attr_encap_subtlv
*tlv
;
2597 if (BGP_ATTR_ENCAP
== type
) {
2598 subtype
= stream_getc(BGP_INPUT(peer
));
2599 sublength
= stream_getc(BGP_INPUT(peer
));
2601 #ifdef ENABLE_BGP_VNC
2603 subtype
= stream_getw(BGP_INPUT(peer
));
2604 sublength
= stream_getw(BGP_INPUT(peer
));
2609 if (sublength
> length
) {
2611 "Tunnel Encap attribute sub-tlv length %d exceeds remaining length %d",
2613 bgp_notify_send_with_data(
2614 peer
, BGP_NOTIFY_UPDATE_ERR
,
2615 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
, startp
, total
);
2619 /* alloc and copy sub-tlv */
2620 /* TBD make sure these are freed when attributes are released */
2621 tlv
= XCALLOC(MTYPE_ENCAP_TLV
,
2622 sizeof(struct bgp_attr_encap_subtlv
) + sublength
);
2623 tlv
->type
= subtype
;
2624 tlv
->length
= sublength
;
2625 stream_get(tlv
->value
, peer
->curr
, sublength
);
2626 length
-= sublength
;
2628 /* attach tlv to encap chain */
2629 if (BGP_ATTR_ENCAP
== type
) {
2630 struct bgp_attr_encap_subtlv
*stlv_last
;
2631 for (stlv_last
= attr
->encap_subtlvs
;
2632 stlv_last
&& stlv_last
->next
;
2633 stlv_last
= stlv_last
->next
)
2636 stlv_last
->next
= tlv
;
2638 attr
->encap_subtlvs
= tlv
;
2640 #ifdef ENABLE_BGP_VNC
2642 struct bgp_attr_encap_subtlv
*stlv_last
;
2643 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
2644 bgp_attr_get_vnc_subtlvs(attr
);
2646 for (stlv_last
= vnc_subtlvs
;
2647 stlv_last
&& stlv_last
->next
;
2648 stlv_last
= stlv_last
->next
)
2651 stlv_last
->next
= tlv
;
2653 bgp_attr_set_vnc_subtlvs(attr
, tlv
);
2658 if (BGP_ATTR_ENCAP
== type
) {
2659 attr
->encap_tunneltype
= tunneltype
;
2663 /* spurious leftover data */
2665 "Tunnel Encap attribute length is bad: %d leftover octets",
2667 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
2668 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2677 /* SRv6 Service Data Sub-Sub-TLV attribute
2678 * draft-ietf-bess-srv6-services-07
2680 static enum bgp_attr_parse_ret
2681 bgp_attr_srv6_service_data(struct bgp_attr_parser_args
*args
)
2683 struct peer
*const peer
= args
->peer
;
2684 struct attr
*const attr
= args
->attr
;
2685 uint8_t type
, loc_block_len
, loc_node_len
, func_len
, arg_len
,
2686 transposition_len
, transposition_offset
;
2688 size_t headersz
= sizeof(type
) + sizeof(length
);
2690 if (STREAM_READABLE(peer
->curr
) < headersz
) {
2693 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
2694 headersz
, STREAM_READABLE(peer
->curr
));
2695 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2699 type
= stream_getc(peer
->curr
);
2700 length
= stream_getw(peer
->curr
);
2702 if (STREAM_READABLE(peer
->curr
) < length
) {
2705 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficent data (need %hu for attribute data, have %zu remaining in UPDATE)",
2706 length
, STREAM_READABLE(peer
->curr
));
2707 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2711 if (length
< BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
) {
2714 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficient data (need %u, have %hu remaining in UPDATE)",
2715 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
,
2717 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2721 if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE
) {
2722 if (STREAM_READABLE(peer
->curr
) <
2723 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
) {
2726 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficient data (need %u, have %zu remaining in UPDATE)",
2727 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
,
2728 STREAM_READABLE(peer
->curr
));
2729 return bgp_attr_malformed(
2730 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2734 loc_block_len
= stream_getc(peer
->curr
);
2735 loc_node_len
= stream_getc(peer
->curr
);
2736 func_len
= stream_getc(peer
->curr
);
2737 arg_len
= stream_getc(peer
->curr
);
2738 transposition_len
= stream_getc(peer
->curr
);
2739 transposition_offset
= stream_getc(peer
->curr
);
2741 /* Log SRv6 Service Data Sub-Sub-TLV */
2742 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
)) {
2744 "%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",
2745 __func__
, loc_block_len
, loc_node_len
, func_len
,
2746 arg_len
, transposition_len
,
2747 transposition_offset
);
2750 attr
->srv6_l3vpn
->loc_block_len
= loc_block_len
;
2751 attr
->srv6_l3vpn
->loc_node_len
= loc_node_len
;
2752 attr
->srv6_l3vpn
->func_len
= func_len
;
2753 attr
->srv6_l3vpn
->arg_len
= arg_len
;
2754 attr
->srv6_l3vpn
->transposition_len
= transposition_len
;
2755 attr
->srv6_l3vpn
->transposition_offset
= transposition_offset
;
2759 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2761 "%s attr SRv6 Service Data Sub-Sub-TLV sub-sub-type=%u is not supported, skipped",
2764 stream_forward_getp(peer
->curr
, length
);
2767 return BGP_ATTR_PARSE_PROCEED
;
2770 /* SRv6 Service Sub-TLV attribute
2771 * draft-ietf-bess-srv6-services-07
2773 static enum bgp_attr_parse_ret
2774 bgp_attr_srv6_service(struct bgp_attr_parser_args
*args
)
2776 struct peer
*const peer
= args
->peer
;
2777 struct attr
*const attr
= args
->attr
;
2778 struct in6_addr ipv6_sid
;
2779 uint8_t type
, sid_flags
;
2780 uint16_t length
, endpoint_behavior
;
2781 size_t headersz
= sizeof(type
) + sizeof(length
);
2782 enum bgp_attr_parse_ret err
;
2784 if (STREAM_READABLE(peer
->curr
) < headersz
) {
2787 "Malformed SRv6 Service Sub-TLV attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
2788 headersz
, STREAM_READABLE(peer
->curr
));
2789 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2793 type
= stream_getc(peer
->curr
);
2794 length
= stream_getw(peer
->curr
);
2796 if (STREAM_READABLE(peer
->curr
) < length
) {
2799 "Malformed SRv6 Service Sub-TLV attribute - insufficent data (need %hu for attribute data, have %zu remaining in UPDATE)",
2800 length
, STREAM_READABLE(peer
->curr
));
2801 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2805 if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO
) {
2806 if (STREAM_READABLE(peer
->curr
) <
2807 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO_LENGTH
) {
2810 "Malformed SRv6 Service Sub-TLV attribute - insufficent data (need %d for attribute data, have %zu remaining in UPDATE)",
2811 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO_LENGTH
,
2812 STREAM_READABLE(peer
->curr
));
2813 return bgp_attr_malformed(
2814 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2817 stream_getc(peer
->curr
);
2818 stream_get(&ipv6_sid
, peer
->curr
, sizeof(ipv6_sid
));
2819 sid_flags
= stream_getc(peer
->curr
);
2820 endpoint_behavior
= stream_getw(peer
->curr
);
2821 stream_getc(peer
->curr
);
2823 /* Log SRv6 Service Sub-TLV */
2824 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
))
2826 "%s: srv6-l3-srv sid %pI6, sid-flags 0x%02x, end-behaviour 0x%04x",
2827 __func__
, &ipv6_sid
, sid_flags
,
2830 /* Configure from Info */
2831 if (attr
->srv6_l3vpn
) {
2832 flog_err(EC_BGP_ATTRIBUTE_REPEATED
,
2833 "Prefix SID SRv6 L3VPN field repeated");
2834 return bgp_attr_malformed(
2835 args
, BGP_NOTIFY_UPDATE_MAL_ATTR
, args
->total
);
2837 attr
->srv6_l3vpn
= XCALLOC(MTYPE_BGP_SRV6_L3VPN
,
2838 sizeof(struct bgp_attr_srv6_l3vpn
));
2839 sid_copy(&attr
->srv6_l3vpn
->sid
, &ipv6_sid
);
2840 attr
->srv6_l3vpn
->sid_flags
= sid_flags
;
2841 attr
->srv6_l3vpn
->endpoint_behavior
= endpoint_behavior
;
2842 attr
->srv6_l3vpn
->loc_block_len
= 0;
2843 attr
->srv6_l3vpn
->loc_node_len
= 0;
2844 attr
->srv6_l3vpn
->func_len
= 0;
2845 attr
->srv6_l3vpn
->arg_len
= 0;
2846 attr
->srv6_l3vpn
->transposition_len
= 0;
2847 attr
->srv6_l3vpn
->transposition_offset
= 0;
2849 // Sub-Sub-TLV found
2850 if (length
> BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO_LENGTH
) {
2851 err
= bgp_attr_srv6_service_data(args
);
2853 if (err
!= BGP_ATTR_PARSE_PROCEED
)
2857 attr
->srv6_l3vpn
= srv6_l3vpn_intern(attr
->srv6_l3vpn
);
2860 /* Placeholder code for unsupported type */
2862 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2864 "%s attr SRv6 Service Sub-TLV sub-type=%u is not supported, skipped",
2867 stream_forward_getp(peer
->curr
, length
);
2870 return BGP_ATTR_PARSE_PROCEED
;
2874 * Read an individual SID value returning how much data we have read
2875 * Returns 0 if there was an error that needs to be passed up the stack
2877 static enum bgp_attr_parse_ret
2878 bgp_attr_psid_sub(uint8_t type
, uint16_t length
,
2879 struct bgp_attr_parser_args
*args
)
2881 struct peer
*const peer
= args
->peer
;
2882 struct attr
*const attr
= args
->attr
;
2883 uint32_t label_index
;
2884 struct in6_addr ipv6_sid
;
2886 uint32_t srgb_range
;
2888 uint8_t sid_type
, sid_flags
;
2890 if (type
== BGP_PREFIX_SID_LABEL_INDEX
) {
2891 if (STREAM_READABLE(peer
->curr
) < length
2892 || length
!= BGP_PREFIX_SID_LABEL_INDEX_LENGTH
) {
2893 flog_err(EC_BGP_ATTR_LEN
,
2894 "Prefix SID label index length is %hu instead of %u",
2895 length
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
2896 return bgp_attr_malformed(args
,
2897 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2901 /* Ignore flags and reserved */
2902 stream_getc(peer
->curr
);
2903 stream_getw(peer
->curr
);
2905 /* Fetch the label index and see if it is valid. */
2906 label_index
= stream_getl(peer
->curr
);
2907 if (label_index
== BGP_INVALID_LABEL_INDEX
)
2908 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2911 /* Store label index; subsequently, we'll check on
2913 attr
->label_index
= label_index
;
2916 /* Placeholder code for the IPv6 SID type */
2917 else if (type
== BGP_PREFIX_SID_IPV6
) {
2918 if (STREAM_READABLE(peer
->curr
) < length
2919 || length
!= BGP_PREFIX_SID_IPV6_LENGTH
) {
2920 flog_err(EC_BGP_ATTR_LEN
,
2921 "Prefix SID IPv6 length is %hu instead of %u",
2922 length
, BGP_PREFIX_SID_IPV6_LENGTH
);
2923 return bgp_attr_malformed(args
,
2924 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2928 /* Ignore reserved */
2929 stream_getc(peer
->curr
);
2930 stream_getw(peer
->curr
);
2932 stream_get(&ipv6_sid
, peer
->curr
, 16);
2935 /* Placeholder code for the Originator SRGB type */
2936 else if (type
== BGP_PREFIX_SID_ORIGINATOR_SRGB
) {
2938 * ietf-idr-bgp-prefix-sid-05:
2939 * Length is the total length of the value portion of the
2940 * TLV: 2 + multiple of 6.
2942 * peer->curr stream readp should be at the beginning of the 16
2943 * bit flag field at this point in the code.
2947 * Check that the TLV length field is sane: at least 2 bytes of
2948 * flag, and at least 1 SRGB (these are 6 bytes each)
2950 if (length
< (2 + BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
)) {
2953 "Prefix SID Originator SRGB length field claims length of %hu bytes, but the minimum for this TLV type is %u",
2955 2 + BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
);
2956 return bgp_attr_malformed(
2957 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2962 * Check that we actually have at least as much data as
2963 * specified by the length field
2965 if (STREAM_READABLE(peer
->curr
) < length
) {
2966 flog_err(EC_BGP_ATTR_LEN
,
2967 "Prefix SID Originator SRGB specifies length %hu, but only %zu bytes remain",
2968 length
, STREAM_READABLE(peer
->curr
));
2969 return bgp_attr_malformed(
2970 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2975 * Check that the portion of the TLV containing the sequence of
2976 * SRGBs corresponds to a multiple of the SRGB size; to get
2977 * that length, we skip the 16 bit flags field
2979 stream_getw(peer
->curr
);
2981 if (length
% BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
) {
2984 "Prefix SID Originator SRGB length field claims attribute SRGB sequence section is %hubytes, but it must be a multiple of %u",
2985 length
, BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
);
2986 return bgp_attr_malformed(
2987 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2991 srgb_count
= length
/ BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
;
2993 for (int i
= 0; i
< srgb_count
; i
++) {
2994 stream_get(&srgb_base
, peer
->curr
, 3);
2995 stream_get(&srgb_range
, peer
->curr
, 3);
2999 /* Placeholder code for the VPN-SID Service type */
3000 else if (type
== BGP_PREFIX_SID_VPN_SID
) {
3001 if (STREAM_READABLE(peer
->curr
) < length
3002 || length
!= BGP_PREFIX_SID_VPN_SID_LENGTH
) {
3003 flog_err(EC_BGP_ATTR_LEN
,
3004 "Prefix SID VPN SID length is %hu instead of %u",
3005 length
, BGP_PREFIX_SID_VPN_SID_LENGTH
);
3006 return bgp_attr_malformed(args
,
3007 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3011 /* Parse VPN-SID Sub-TLV */
3012 stream_getc(peer
->curr
); /* reserved */
3013 sid_type
= stream_getc(peer
->curr
); /* sid_type */
3014 sid_flags
= stream_getc(peer
->curr
); /* sid_flags */
3015 stream_get(&ipv6_sid
, peer
->curr
,
3016 sizeof(ipv6_sid
)); /* sid_value */
3018 /* Log VPN-SID Sub-TLV */
3019 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
))
3021 "%s: vpn-sid: sid %pI6, sid-type 0x%02x sid-flags 0x%02x",
3022 __func__
, &ipv6_sid
, sid_type
, sid_flags
);
3024 /* Configure from Info */
3025 if (attr
->srv6_vpn
) {
3026 flog_err(EC_BGP_ATTRIBUTE_REPEATED
,
3027 "Prefix SID SRv6 VPN field repeated");
3028 return bgp_attr_malformed(
3029 args
, BGP_NOTIFY_UPDATE_MAL_ATTR
, args
->total
);
3031 attr
->srv6_vpn
= XCALLOC(MTYPE_BGP_SRV6_VPN
,
3032 sizeof(struct bgp_attr_srv6_vpn
));
3033 attr
->srv6_vpn
->sid_flags
= sid_flags
;
3034 sid_copy(&attr
->srv6_vpn
->sid
, &ipv6_sid
);
3035 attr
->srv6_vpn
= srv6_vpn_intern(attr
->srv6_vpn
);
3038 /* Placeholder code for the SRv6 L3 Service type */
3039 else if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE
) {
3040 if (STREAM_READABLE(peer
->curr
) < length
) {
3043 "Prefix SID SRv6 L3-Service length is %hu, but only %zu bytes remain",
3044 length
, STREAM_READABLE(peer
->curr
));
3045 return bgp_attr_malformed(args
,
3046 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3050 /* ignore reserved */
3051 stream_getc(peer
->curr
);
3053 return bgp_attr_srv6_service(args
);
3056 /* Placeholder code for Unsupported TLV */
3059 if (STREAM_READABLE(peer
->curr
) < length
) {
3062 "Prefix SID SRv6 length is %hu - too long, only %zu remaining in this UPDATE",
3063 length
, STREAM_READABLE(peer
->curr
));
3064 return bgp_attr_malformed(
3065 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3069 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
3071 "%s attr Prefix-SID sub-type=%u is not supported, skipped",
3074 stream_forward_getp(peer
->curr
, length
);
3077 return BGP_ATTR_PARSE_PROCEED
;
3080 /* Prefix SID attribute
3081 * draft-ietf-idr-bgp-prefix-sid-05
3083 enum bgp_attr_parse_ret
bgp_attr_prefix_sid(struct bgp_attr_parser_args
*args
)
3085 struct peer
*const peer
= args
->peer
;
3086 struct attr
*const attr
= args
->attr
;
3087 enum bgp_attr_parse_ret ret
;
3089 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
);
3093 size_t headersz
= sizeof(type
) + sizeof(length
);
3094 size_t psid_parsed_length
= 0;
3096 while (STREAM_READABLE(peer
->curr
) > 0
3097 && psid_parsed_length
< args
->length
) {
3099 if (STREAM_READABLE(peer
->curr
) < headersz
) {
3102 "Malformed Prefix SID attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
3103 headersz
, STREAM_READABLE(peer
->curr
));
3104 return bgp_attr_malformed(
3105 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3109 type
= stream_getc(peer
->curr
);
3110 length
= stream_getw(peer
->curr
);
3112 if (STREAM_READABLE(peer
->curr
) < length
) {
3115 "Malformed Prefix SID attribute - insufficient data (need %hu for attribute body, have %zu remaining in UPDATE)",
3116 length
, STREAM_READABLE(peer
->curr
));
3117 return bgp_attr_malformed(args
,
3118 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3122 ret
= bgp_attr_psid_sub(type
, length
, args
);
3124 if (ret
!= BGP_ATTR_PARSE_PROCEED
)
3127 psid_parsed_length
+= length
+ headersz
;
3129 if (psid_parsed_length
> args
->length
) {
3132 "Malformed Prefix SID attribute - TLV overflow by attribute (need %zu for TLV length, have %zu overflowed in UPDATE)",
3133 length
+ headersz
, psid_parsed_length
- (length
+ headersz
));
3134 return bgp_attr_malformed(
3135 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3140 return BGP_ATTR_PARSE_PROCEED
;
3143 /* PMSI tunnel attribute (RFC 6514)
3144 * Basic validation checks done here.
3146 static enum bgp_attr_parse_ret
3147 bgp_attr_pmsi_tunnel(struct bgp_attr_parser_args
*args
)
3149 struct peer
*const peer
= args
->peer
;
3150 struct attr
*const attr
= args
->attr
;
3151 const bgp_size_t length
= args
->length
;
3153 int attr_parse_len
= 2 + BGP_LABEL_BYTES
;
3155 /* Verify that the receiver is expecting "ingress replication" as we
3156 * can only support that.
3158 if (length
< attr_parse_len
) {
3159 flog_err(EC_BGP_ATTR_LEN
, "Bad PMSI tunnel attribute length %d",
3161 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3164 stream_getc(peer
->curr
); /* Flags */
3165 tnl_type
= stream_getc(peer
->curr
);
3166 if (tnl_type
> PMSI_TNLTYPE_MAX
) {
3167 flog_err(EC_BGP_ATTR_PMSI_TYPE
,
3168 "Invalid PMSI tunnel attribute type %d", tnl_type
);
3169 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
3172 if (tnl_type
== PMSI_TNLTYPE_INGR_REPL
) {
3174 flog_err(EC_BGP_ATTR_PMSI_LEN
,
3175 "Bad PMSI tunnel attribute length %d for IR",
3177 return bgp_attr_malformed(
3178 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3183 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
);
3184 bgp_attr_set_pmsi_tnl_type(attr
, tnl_type
);
3185 stream_get(&attr
->label
, peer
->curr
, BGP_LABEL_BYTES
);
3187 /* Forward read pointer of input stream. */
3188 stream_forward_getp(peer
->curr
, length
- attr_parse_len
);
3190 return BGP_ATTR_PARSE_PROCEED
;
3193 /* AIGP attribute (rfc7311) */
3194 static enum bgp_attr_parse_ret
bgp_attr_aigp(struct bgp_attr_parser_args
*args
)
3196 struct peer
*const peer
= args
->peer
;
3197 struct attr
*const attr
= args
->attr
;
3198 const bgp_size_t length
= args
->length
;
3199 uint8_t *s
= stream_pnt(peer
->curr
);
3202 /* If an AIGP attribute is received on a BGP session for which
3203 * AIGP_SESSION is disabled, the attribute MUST be treated exactly
3204 * as if it were an unrecognized non-transitive attribute.
3205 * That is, it "MUST be quietly ignored and not passed along to
3207 * For Internal BGP (IBGP) sessions, and for External BGP (EBGP)
3208 * sessions between members of the same BGP Confederation,
3209 * the default value of AIGP_SESSION SHOULD be "enabled".
3211 if (peer
->sort
== BGP_PEER_EBGP
&&
3212 !CHECK_FLAG(peer
->flags
, PEER_FLAG_AIGP
)) {
3214 "%pBP received AIGP attribute, but eBGP peer do not support it",
3219 if (!bgp_attr_aigp_valid(s
, length
))
3222 /* Extract AIGP Metric TLV */
3223 if (bgp_attr_aigp_get_tlv_metric(s
, length
, &aigp
))
3224 bgp_attr_set_aigp_metric(attr
, aigp
);
3227 stream_forward_getp(peer
->curr
, length
);
3229 return BGP_ATTR_PARSE_PROCEED
;
3232 /* OTC attribute. */
3233 static enum bgp_attr_parse_ret
bgp_attr_otc(struct bgp_attr_parser_args
*args
)
3235 struct peer
*const peer
= args
->peer
;
3236 struct attr
*const attr
= args
->attr
;
3237 const bgp_size_t length
= args
->length
;
3241 flog_err(EC_BGP_ATTR_LEN
, "OTC attribute length isn't 4 [%u]",
3243 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3247 attr
->otc
= stream_getl(peer
->curr
);
3249 flog_err(EC_BGP_ATTR_MAL_AS_PATH
, "OTC attribute value is 0");
3250 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
3254 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_OTC
);
3256 return BGP_ATTR_PARSE_PROCEED
;
3259 /* BGP unknown attribute treatment. */
3260 static enum bgp_attr_parse_ret
3261 bgp_attr_unknown(struct bgp_attr_parser_args
*args
)
3263 bgp_size_t total
= args
->total
;
3264 struct transit
*transit
;
3265 struct peer
*const peer
= args
->peer
;
3266 struct attr
*const attr
= args
->attr
;
3267 uint8_t *const startp
= args
->startp
;
3268 const uint8_t type
= args
->type
;
3269 const uint8_t flag
= args
->flags
;
3270 const bgp_size_t length
= args
->length
;
3272 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
3274 "%s Unknown attribute is received (type %d, length %d)",
3275 peer
->host
, type
, length
);
3277 /* Forward read pointer of input stream. */
3278 stream_forward_getp(peer
->curr
, length
);
3280 /* If any of the mandatory well-known attributes are not recognized,
3281 then the Error Subcode is set to Unrecognized Well-known
3282 Attribute. The Data field contains the unrecognized attribute
3283 (type, length and value). */
3284 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_OPTIONAL
)) {
3285 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_UNREC_ATTR
,
3289 /* Unrecognized non-transitive optional attributes must be quietly
3290 ignored and not passed along to other BGP peers. */
3291 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_TRANS
))
3292 return BGP_ATTR_PARSE_PROCEED
;
3294 /* If a path with recognized transitive optional attribute is
3295 accepted and passed along to other BGP peers and the Partial bit
3296 in the Attribute Flags octet is set to 1 by some previous AS, it
3297 is not set back to 0 by the current AS. */
3298 SET_FLAG(*startp
, BGP_ATTR_FLAG_PARTIAL
);
3300 /* Store transitive attribute to the end of attr->transit. */
3301 transit
= bgp_attr_get_transit(attr
);
3303 transit
= XCALLOC(MTYPE_TRANSIT
, sizeof(struct transit
));
3305 transit
->val
= XREALLOC(MTYPE_TRANSIT_VAL
, transit
->val
,
3306 transit
->length
+ total
);
3308 memcpy(transit
->val
+ transit
->length
, startp
, total
);
3309 transit
->length
+= total
;
3310 bgp_attr_set_transit(attr
, transit
);
3312 return BGP_ATTR_PARSE_PROCEED
;
3315 /* Well-known attribute check. */
3316 static int bgp_attr_check(struct peer
*peer
, struct attr
*attr
)
3320 /* BGP Graceful-Restart End-of-RIB for IPv4 unicast is signaled as an
3322 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
) && !attr
->flag
)
3323 return BGP_ATTR_PARSE_PROCEED
;
3325 /* "An UPDATE message that contains the MP_UNREACH_NLRI is not required
3326 to carry any other path attributes.", though if MP_REACH_NLRI or NLRI
3327 are present, it should. Check for any other attribute being present
3330 if ((!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
)) &&
3331 CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
))))
3332 return BGP_ATTR_PARSE_PROCEED
;
3334 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
)))
3335 type
= BGP_ATTR_ORIGIN
;
3337 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
)))
3338 type
= BGP_ATTR_AS_PATH
;
3340 /* RFC 2858 makes Next-Hop optional/ignored, if MP_REACH_NLRI is present
3342 * NLRI is empty. We can't easily check NLRI empty here though.
3344 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
))
3345 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
)))
3346 type
= BGP_ATTR_NEXT_HOP
;
3348 if (peer
->sort
== BGP_PEER_IBGP
3349 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)))
3350 type
= BGP_ATTR_LOCAL_PREF
;
3352 /* If any of the well-known mandatory attributes are not present
3353 * in an UPDATE message, then "treat-as-withdraw" MUST be used.
3356 flog_warn(EC_BGP_MISSING_ATTRIBUTE
,
3357 "%s Missing well-known attribute %s.", peer
->host
,
3358 lookup_msg(attr_str
, type
, NULL
));
3359 return BGP_ATTR_PARSE_WITHDRAW
;
3361 return BGP_ATTR_PARSE_PROCEED
;
3364 /* Read attribute of update packet. This function is called from
3365 bgp_update_receive() in bgp_packet.c. */
3366 enum bgp_attr_parse_ret
bgp_attr_parse(struct peer
*peer
, struct attr
*attr
,
3368 struct bgp_nlri
*mp_update
,
3369 struct bgp_nlri
*mp_withdraw
)
3371 enum bgp_attr_parse_ret ret
;
3375 uint8_t *startp
, *endp
;
3377 uint8_t seen
[BGP_ATTR_BITMAP_SIZE
];
3378 /* we need the as4_path only until we have synthesized the as_path with
3380 /* same goes for as4_aggregator */
3381 struct aspath
*as4_path
= NULL
;
3382 as_t as4_aggregator
= 0;
3383 struct in_addr as4_aggregator_addr
= {.s_addr
= 0};
3384 struct transit
*transit
;
3386 /* Initialize bitmap. */
3387 memset(seen
, 0, BGP_ATTR_BITMAP_SIZE
);
3389 /* End pointer of BGP attribute. */
3390 endp
= BGP_INPUT_PNT(peer
) + size
;
3392 /* Get attributes to the end of attribute length. */
3393 while (BGP_INPUT_PNT(peer
) < endp
) {
3394 /* Check remaining length check.*/
3395 if (endp
- BGP_INPUT_PNT(peer
) < BGP_ATTR_MIN_LEN
) {
3396 /* XXX warning: long int format, int arg (arg 5) */
3398 EC_BGP_ATTRIBUTE_TOO_SMALL
,
3399 "%s: error BGP attribute length %lu is smaller than min len",
3401 (unsigned long)(endp
3402 - stream_pnt(BGP_INPUT(peer
))));
3404 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3405 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3406 ret
= BGP_ATTR_PARSE_ERROR
;
3410 /* Fetch attribute flag and type. */
3411 startp
= BGP_INPUT_PNT(peer
);
3412 /* "The lower-order four bits of the Attribute Flags octet are
3413 unused. They MUST be zero when sent and MUST be ignored when
3415 flag
= 0xF0 & stream_getc(BGP_INPUT(peer
));
3416 type
= stream_getc(BGP_INPUT(peer
));
3418 /* Check whether Extended-Length applies and is in bounds */
3419 if (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
)
3420 && ((endp
- startp
) < (BGP_ATTR_MIN_LEN
+ 1))) {
3422 EC_BGP_EXT_ATTRIBUTE_TOO_SMALL
,
3423 "%s: Extended length set, but just %lu bytes of attr header",
3425 (unsigned long)(endp
3426 - stream_pnt(BGP_INPUT(peer
))));
3428 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3429 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3430 ret
= BGP_ATTR_PARSE_ERROR
;
3434 /* Check extended attribue length bit. */
3435 if (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
))
3436 length
= stream_getw(BGP_INPUT(peer
));
3438 length
= stream_getc(BGP_INPUT(peer
));
3440 /* If any attribute appears more than once in the UPDATE
3441 message, then the Error Subcode is set to Malformed Attribute
3444 if (CHECK_BITMAP(seen
, type
)) {
3446 EC_BGP_ATTRIBUTE_REPEATED
,
3447 "%s: error BGP attribute type %d appears twice in a message",
3450 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3451 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3452 ret
= BGP_ATTR_PARSE_ERROR
;
3456 /* Set type to bitmap to check duplicate attribute. `type' is
3457 unsigned char so it never overflow bitmap range. */
3459 SET_BITMAP(seen
, type
);
3461 /* Overflow check. */
3462 attr_endp
= BGP_INPUT_PNT(peer
) + length
;
3464 if (attr_endp
> endp
) {
3466 EC_BGP_ATTRIBUTE_TOO_LARGE
,
3467 "%s: BGP type %d length %d is too large, attribute total length is %d. attr_endp is %p. endp is %p",
3468 peer
->host
, type
, length
, size
, attr_endp
,
3472 * If any recognized attribute has an Attribute
3473 * Length that conflicts with the expected length
3474 * (based on the attribute type code), then the
3475 * Error Subcode MUST be set to Attribute Length
3476 * Error. The Data field MUST contain the erroneous
3477 * attribute (type, length, and value).
3479 * We do not currently have a good way to determine the
3480 * length of the attribute independent of the length
3481 * received in the message. Instead we send the
3482 * minimum between the amount of data we have and the
3483 * amount specified by the attribute length field.
3485 * Instead of directly passing in the packet buffer and
3486 * offset we use the stream_get* functions to read into
3487 * a stack buffer, since they perform bounds checking
3488 * and we are working with untrusted data.
3490 unsigned char ndata
[peer
->max_packet_size
];
3491 memset(ndata
, 0x00, sizeof(ndata
));
3493 CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
) ? 2 : 1;
3494 /* Rewind to end of flag field */
3495 stream_rewind_getp(BGP_INPUT(peer
), (1 + lfl
));
3497 stream_get(&ndata
[0], BGP_INPUT(peer
), 1);
3499 stream_get(&ndata
[1], BGP_INPUT(peer
), lfl
);
3501 size_t atl
= attr_endp
- startp
;
3502 size_t ndl
= MIN(atl
, STREAM_READABLE(BGP_INPUT(peer
)));
3503 stream_get(&ndata
[lfl
+ 1], BGP_INPUT(peer
), ndl
);
3505 bgp_notify_send_with_data(
3506 peer
, BGP_NOTIFY_UPDATE_ERR
,
3507 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
, ndata
,
3510 ret
= BGP_ATTR_PARSE_ERROR
;
3514 struct bgp_attr_parser_args attr_args
= {
3521 .total
= attr_endp
- startp
,
3525 /* If any recognized attribute has Attribute Flags that conflict
3526 with the Attribute Type Code, then the Error Subcode is set
3528 Attribute Flags Error. The Data field contains the erroneous
3529 attribute (type, length and value). */
3530 if (bgp_attr_flag_invalid(&attr_args
)) {
3531 ret
= bgp_attr_malformed(
3532 &attr_args
, BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR
,
3534 if (ret
== BGP_ATTR_PARSE_PROCEED
)
3539 /* OK check attribute and store it's value. */
3541 case BGP_ATTR_ORIGIN
:
3542 ret
= bgp_attr_origin(&attr_args
);
3544 case BGP_ATTR_AS_PATH
:
3545 ret
= bgp_attr_aspath(&attr_args
);
3547 case BGP_ATTR_AS4_PATH
:
3548 ret
= bgp_attr_as4_path(&attr_args
, &as4_path
);
3550 case BGP_ATTR_NEXT_HOP
:
3551 ret
= bgp_attr_nexthop(&attr_args
);
3553 case BGP_ATTR_MULTI_EXIT_DISC
:
3554 ret
= bgp_attr_med(&attr_args
);
3556 case BGP_ATTR_LOCAL_PREF
:
3557 ret
= bgp_attr_local_pref(&attr_args
);
3559 case BGP_ATTR_ATOMIC_AGGREGATE
:
3560 ret
= bgp_attr_atomic(&attr_args
);
3562 case BGP_ATTR_AGGREGATOR
:
3563 ret
= bgp_attr_aggregator(&attr_args
);
3565 case BGP_ATTR_AS4_AGGREGATOR
:
3566 ret
= bgp_attr_as4_aggregator(&attr_args
,
3568 &as4_aggregator_addr
);
3570 case BGP_ATTR_COMMUNITIES
:
3571 ret
= bgp_attr_community(&attr_args
);
3573 case BGP_ATTR_LARGE_COMMUNITIES
:
3574 ret
= bgp_attr_large_community(&attr_args
);
3576 case BGP_ATTR_ORIGINATOR_ID
:
3577 ret
= bgp_attr_originator_id(&attr_args
);
3579 case BGP_ATTR_CLUSTER_LIST
:
3580 ret
= bgp_attr_cluster_list(&attr_args
);
3582 case BGP_ATTR_MP_REACH_NLRI
:
3583 ret
= bgp_mp_reach_parse(&attr_args
, mp_update
);
3585 case BGP_ATTR_MP_UNREACH_NLRI
:
3586 ret
= bgp_mp_unreach_parse(&attr_args
, mp_withdraw
);
3588 case BGP_ATTR_EXT_COMMUNITIES
:
3589 ret
= bgp_attr_ext_communities(&attr_args
);
3591 #ifdef ENABLE_BGP_VNC_ATTR
3594 case BGP_ATTR_ENCAP
:
3595 ret
= bgp_attr_encap(type
, peer
, length
, attr
, flag
,
3598 case BGP_ATTR_PREFIX_SID
:
3599 ret
= bgp_attr_prefix_sid(&attr_args
);
3601 case BGP_ATTR_PMSI_TUNNEL
:
3602 ret
= bgp_attr_pmsi_tunnel(&attr_args
);
3604 case BGP_ATTR_IPV6_EXT_COMMUNITIES
:
3605 ret
= bgp_attr_ipv6_ext_communities(&attr_args
);
3608 ret
= bgp_attr_otc(&attr_args
);
3611 ret
= bgp_attr_aigp(&attr_args
);
3614 ret
= bgp_attr_unknown(&attr_args
);
3618 if (ret
== BGP_ATTR_PARSE_ERROR_NOTIFYPLS
) {
3619 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3620 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3621 ret
= BGP_ATTR_PARSE_ERROR
;
3625 if (ret
== BGP_ATTR_PARSE_EOR
) {
3629 if (ret
== BGP_ATTR_PARSE_ERROR
) {
3630 flog_warn(EC_BGP_ATTRIBUTE_PARSE_ERROR
,
3631 "%s: Attribute %s, parse error", peer
->host
,
3632 lookup_msg(attr_str
, type
, NULL
));
3635 if (ret
== BGP_ATTR_PARSE_WITHDRAW
) {
3637 EC_BGP_ATTRIBUTE_PARSE_WITHDRAW
,
3638 "%s: Attribute %s, parse error - treating as withdrawal",
3639 peer
->host
, lookup_msg(attr_str
, type
, NULL
));
3643 /* Check the fetched length. */
3644 if (BGP_INPUT_PNT(peer
) != attr_endp
) {
3645 flog_warn(EC_BGP_ATTRIBUTE_FETCH_ERROR
,
3646 "%s: BGP attribute %s, fetch error",
3647 peer
->host
, lookup_msg(attr_str
, type
, NULL
));
3648 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3649 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3650 ret
= BGP_ATTR_PARSE_ERROR
;
3656 * draft-ietf-idr-bgp-prefix-sid-27#section-3:
3657 * About Prefix-SID path attribute,
3658 * Label-Index TLV(type1) and The Originator SRGB TLV(type-3)
3659 * may only appear in a BGP Prefix-SID attribute attached to
3660 * IPv4/IPv6 Labeled Unicast prefixes ([RFC8277]).
3661 * It MUST be ignored when received for other BGP AFI/SAFI combinations.
3663 if (!attr
->mp_nexthop_len
|| mp_update
->safi
!= SAFI_LABELED_UNICAST
)
3664 attr
->label_index
= BGP_INVALID_LABEL_INDEX
;
3666 /* Check final read pointer is same as end pointer. */
3667 if (BGP_INPUT_PNT(peer
) != endp
) {
3668 flog_warn(EC_BGP_ATTRIBUTES_MISMATCH
,
3669 "%s: BGP attribute %s, length mismatch", peer
->host
,
3670 lookup_msg(attr_str
, type
, NULL
));
3671 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3672 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3674 ret
= BGP_ATTR_PARSE_ERROR
;
3679 * RFC4271: If the NEXT_HOP attribute field is syntactically incorrect,
3680 * then the Error Subcode MUST be set to Invalid NEXT_HOP Attribute.
3681 * This is implemented below and will result in a NOTIFICATION. If the
3682 * NEXT_HOP attribute is semantically incorrect, the error SHOULD be
3683 * logged, and the route SHOULD be ignored. In this case, a NOTIFICATION
3684 * message SHOULD NOT be sent. This is implemented elsewhere.
3686 * RFC4760: An UPDATE message that carries no NLRI, other than the one
3687 * encoded in the MP_REACH_NLRI attribute, SHOULD NOT carry the NEXT_HOP
3688 * attribute. If such a message contains the NEXT_HOP attribute, the BGP
3689 * speaker that receives the message SHOULD ignore this attribute.
3691 if (CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
))
3692 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
))) {
3693 if (bgp_attr_nexthop_valid(peer
, attr
) < 0) {
3694 ret
= BGP_ATTR_PARSE_ERROR
;
3699 /* Check all mandatory well-known attributes are present */
3700 ret
= bgp_attr_check(peer
, attr
);
3705 * At this place we can see whether we got AS4_PATH and/or
3706 * AS4_AGGREGATOR from a 16Bit peer and act accordingly.
3707 * We can not do this before we've read all attributes because
3708 * the as4 handling does not say whether AS4_PATH has to be sent
3709 * after AS_PATH or not - and when AS4_AGGREGATOR will be send
3710 * in relationship to AGGREGATOR.
3711 * So, to be defensive, we are not relying on any order and read
3712 * all attributes first, including these 32bit ones, and now,
3713 * afterwards, we look what and if something is to be done for as4.
3715 * It is possible to not have AS_PATH, e.g. GR EoR and sole
3718 /* actually... this doesn't ever return failure currently, but
3719 * better safe than sorry */
3720 if (CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
))
3721 && bgp_attr_munge_as4_attrs(peer
, attr
, as4_path
, as4_aggregator
,
3722 &as4_aggregator_addr
)) {
3723 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3724 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3725 ret
= BGP_ATTR_PARSE_ERROR
;
3730 * Finally do the checks on the aspath we did not do yet
3731 * because we waited for a potentially synthesized aspath.
3733 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
))) {
3734 ret
= bgp_attr_aspath_check(peer
, attr
);
3735 if (ret
!= BGP_ATTR_PARSE_PROCEED
)
3739 ret
= BGP_ATTR_PARSE_PROCEED
;
3743 * At this stage, we have done all fiddling with as4, and the
3744 * resulting info is in attr->aggregator resp. attr->aspath so
3745 * we can chuck as4_aggregator and as4_path alltogether in order
3749 * unintern - it is in the hash
3750 * The flag that we got this is still there, but that
3751 * does not do any trouble
3753 aspath_unintern(&as4_path
);
3755 transit
= bgp_attr_get_transit(attr
);
3756 if (ret
!= BGP_ATTR_PARSE_ERROR
) {
3757 /* Finally intern unknown attribute. */
3759 bgp_attr_set_transit(attr
, transit_intern(transit
));
3760 if (attr
->encap_subtlvs
)
3761 attr
->encap_subtlvs
= encap_intern(attr
->encap_subtlvs
,
3763 #ifdef ENABLE_BGP_VNC
3764 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
3765 bgp_attr_get_vnc_subtlvs(attr
);
3768 bgp_attr_set_vnc_subtlvs(
3770 encap_intern(vnc_subtlvs
, VNC_SUBTLV_TYPE
));
3774 transit_free(transit
);
3775 bgp_attr_set_transit(attr
, NULL
);
3778 bgp_attr_flush_encap(attr
);
3782 transit
= bgp_attr_get_transit(attr
);
3784 assert(transit
->refcnt
> 0);
3785 if (attr
->encap_subtlvs
)
3786 assert(attr
->encap_subtlvs
->refcnt
> 0);
3787 #ifdef ENABLE_BGP_VNC
3788 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
3789 bgp_attr_get_vnc_subtlvs(attr
);
3792 assert(vnc_subtlvs
->refcnt
> 0);
3799 * Extract the tunnel type from extended community
3801 void bgp_attr_extcom_tunnel_type(struct attr
*attr
,
3802 bgp_encap_types
*tunnel_type
)
3804 struct ecommunity
*ecom
;
3810 ecom
= bgp_attr_get_ecommunity(attr
);
3811 if (!ecom
|| !ecom
->size
)
3814 for (i
= 0; i
< ecom
->size
; i
++) {
3816 uint8_t type
, sub_type
;
3818 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
3821 if (!(type
== ECOMMUNITY_ENCODE_OPAQUE
&&
3822 sub_type
== ECOMMUNITY_OPAQUE_SUBTYPE_ENCAP
))
3824 *tunnel_type
= ((pnt
[6] << 8) | pnt
[7]);
3831 size_t bgp_packet_mpattr_start(struct stream
*s
, struct peer
*peer
, afi_t afi
,
3832 safi_t safi
, struct bpacket_attr_vec_arr
*vecarr
,
3836 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
3837 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
3840 /* Set extended bit always to encode the attribute length as 2 bytes */
3841 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_EXTLEN
);
3842 stream_putc(s
, BGP_ATTR_MP_REACH_NLRI
);
3843 sizep
= stream_get_endp(s
);
3844 stream_putw(s
, 0); /* Marker: Attribute length. */
3847 /* Convert AFI, SAFI to values for packet. */
3848 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
3850 stream_putw(s
, pkt_afi
); /* AFI */
3851 stream_putc(s
, pkt_safi
); /* SAFI */
3855 && (safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
3856 || safi
== SAFI_MPLS_VPN
|| safi
== SAFI_MULTICAST
))
3857 nh_afi
= peer_cap_enhe(peer
, afi
, safi
) ? AFI_IP6
: AFI_IP
;
3858 else if (safi
== SAFI_FLOWSPEC
)
3861 nh_afi
= BGP_NEXTHOP_AFI_FROM_NHLEN(attr
->mp_nexthop_len
);
3864 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
, attr
);
3869 case SAFI_MULTICAST
:
3870 case SAFI_LABELED_UNICAST
:
3872 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
3876 stream_putl(s
, 0); /* RD = 0, per RFC */
3878 stream_put(s
, &attr
->mp_nexthop_global_in
, 4);
3883 stream_put(s
, &attr
->mp_nexthop_global_in
, 4);
3886 if (attr
->mp_nexthop_len
== 0)
3887 stream_putc(s
, 0); /* no nexthop for flowspec */
3889 stream_putc(s
, attr
->mp_nexthop_len
);
3890 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
3895 assert(!"SAFI's UNSPEC or MAX being specified are a DEV ESCAPE");
3902 case SAFI_MULTICAST
:
3903 case SAFI_LABELED_UNICAST
:
3905 if (attr
->mp_nexthop_len
3906 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
3908 BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
);
3909 stream_put(s
, &attr
->mp_nexthop_global
,
3911 stream_put(s
, &attr
->mp_nexthop_local
,
3914 stream_putc(s
, IPV6_MAX_BYTELEN
);
3915 stream_put(s
, &attr
->mp_nexthop_global
,
3919 case SAFI_MPLS_VPN
: {
3920 if (attr
->mp_nexthop_len
3921 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
3923 stream_putl(s
, 0); /* RD = 0, per RFC */
3925 stream_put(s
, &attr
->mp_nexthop_global
,
3927 stream_putl(s
, 0); /* RD = 0, per RFC */
3929 stream_put(s
, &attr
->mp_nexthop_local
,
3933 stream_putl(s
, 0); /* RD = 0, per RFC */
3935 stream_put(s
, &attr
->mp_nexthop_global
,
3940 stream_putc(s
, IPV6_MAX_BYTELEN
);
3941 stream_put(s
, &attr
->mp_nexthop_global
,
3945 stream_putc(s
, 0); /* no nexthop for flowspec */
3949 assert(!"SAFI's UNSPEC or MAX being specified are a DEV ESCAPE");
3954 if (safi
!= SAFI_FLOWSPEC
)
3956 EC_BGP_ATTR_NH_SEND_LEN
,
3957 "Bad nexthop when sending to %s, AFI %u SAFI %u nhlen %d",
3958 peer
->host
, afi
, safi
, attr
->mp_nexthop_len
);
3962 assert(!"DEV ESCAPE: AFI_UNSPEC or AFI_MAX should not be used here");
3971 void bgp_packet_mpattr_prefix(struct stream
*s
, afi_t afi
, safi_t safi
,
3972 const struct prefix
*p
,
3973 const struct prefix_rd
*prd
, mpls_label_t
*label
,
3974 uint32_t num_labels
, bool addpath_capable
,
3975 uint32_t addpath_tx_id
, struct attr
*attr
)
3980 assert(!"Dev escape usage of SAFI_UNSPEC or MAX");
3983 if (addpath_capable
)
3984 stream_putl(s
, addpath_tx_id
);
3985 /* Label, RD, Prefix write. */
3986 stream_putc(s
, p
->prefixlen
+ 88);
3987 stream_put(s
, label
, BGP_LABEL_BYTES
);
3988 stream_put(s
, prd
->val
, 8);
3989 stream_put(s
, &p
->u
.prefix
, PSIZE(p
->prefixlen
));
3992 if (afi
== AFI_L2VPN
)
3993 /* EVPN prefix - contents depend on type */
3994 bgp_evpn_encode_prefix(s
, p
, prd
, label
, num_labels
,
3995 attr
, addpath_capable
,
3998 assert(!"Add encoding bits here for other AFI's");
4000 case SAFI_LABELED_UNICAST
:
4001 /* Prefix write with label. */
4002 stream_put_labeled_prefix(s
, p
, label
, addpath_capable
,
4006 stream_putc(s
, p
->u
.prefix_flowspec
.prefixlen
);
4007 stream_put(s
, (const void *)p
->u
.prefix_flowspec
.ptr
,
4008 p
->u
.prefix_flowspec
.prefixlen
);
4012 case SAFI_MULTICAST
:
4013 stream_put_prefix_addpath(s
, p
, addpath_capable
, addpath_tx_id
);
4016 assert(!"Please add proper encoding of SAFI_ENCAP");
4021 size_t bgp_packet_mpattr_prefix_size(afi_t afi
, safi_t safi
,
4022 const struct prefix
*p
)
4024 int size
= PSIZE(p
->prefixlen
);
4029 assert(!"Attempting to figure size for a SAFI_UNSPEC/SAFI_MAX this is a DEV ESCAPE");
4032 case SAFI_MULTICAST
:
4038 /* This has to be wrong, but I don't know what to put here */
4039 assert(!"Do we try to use this?");
4041 case SAFI_LABELED_UNICAST
:
4042 size
+= BGP_LABEL_BYTES
;
4046 * TODO: Maximum possible for type-2, type-3 and type-5
4048 if (afi
== AFI_L2VPN
)
4051 assert(!"Attempting to figure size for SAFI_EVPN and !AFI_L2VPN and FRR will not have the proper values");
4054 size
= ((struct prefix_fs
*)p
)->prefix
.prefixlen
;
4062 * Encodes the tunnel encapsulation attribute,
4063 * and with ENABLE_BGP_VNC the VNC attribute which uses
4064 * almost the same TLV format
4066 static void bgp_packet_mpattr_tea(struct bgp
*bgp
, struct peer
*peer
,
4067 struct stream
*s
, struct attr
*attr
,
4070 unsigned int attrlenfield
= 0;
4071 unsigned int attrhdrlen
= 0;
4072 struct bgp_attr_encap_subtlv
*subtlvs
;
4073 struct bgp_attr_encap_subtlv
*st
;
4074 const char *attrname
;
4076 if (!attr
|| (attrtype
== BGP_ATTR_ENCAP
4077 && (!attr
->encap_tunneltype
4078 || attr
->encap_tunneltype
== BGP_ENCAP_TYPE_MPLS
)))
4082 case BGP_ATTR_ENCAP
:
4083 attrname
= "Tunnel Encap";
4084 subtlvs
= attr
->encap_subtlvs
;
4085 if (subtlvs
== NULL
) /* nothing to do */
4088 * The tunnel encap attr has an "outer" tlv.
4090 * L = total length of subtlvs,
4091 * V = concatenated subtlvs.
4093 attrlenfield
= 2 + 2; /* T + L */
4094 attrhdrlen
= 1 + 1; /* subTLV T + L */
4097 #ifdef ENABLE_BGP_VNC_ATTR
4100 subtlvs
= bgp_attr_get_vnc_subtlvs(attr
);
4101 if (subtlvs
== NULL
) /* nothing to do */
4103 attrlenfield
= 0; /* no outer T + L */
4104 attrhdrlen
= 2 + 2; /* subTLV T + L */
4112 /* compute attr length */
4113 for (st
= subtlvs
; st
; st
= st
->next
) {
4114 attrlenfield
+= (attrhdrlen
+ st
->length
);
4117 if (attrlenfield
> 0xffff) {
4118 zlog_info("%s attribute is too long (length=%d), can't send it",
4119 attrname
, attrlenfield
);
4123 if (attrlenfield
> 0xff) {
4124 /* 2-octet length field */
4126 BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
4127 | BGP_ATTR_FLAG_EXTLEN
);
4128 stream_putc(s
, attrtype
);
4129 stream_putw(s
, attrlenfield
& 0xffff);
4131 /* 1-octet length field */
4132 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
);
4133 stream_putc(s
, attrtype
);
4134 stream_putc(s
, attrlenfield
& 0xff);
4137 if (attrtype
== BGP_ATTR_ENCAP
) {
4138 /* write outer T+L */
4139 stream_putw(s
, attr
->encap_tunneltype
);
4140 stream_putw(s
, attrlenfield
- 4);
4143 /* write each sub-tlv */
4144 for (st
= subtlvs
; st
; st
= st
->next
) {
4145 if (attrtype
== BGP_ATTR_ENCAP
) {
4146 stream_putc(s
, st
->type
);
4147 stream_putc(s
, st
->length
);
4148 #ifdef ENABLE_BGP_VNC
4150 stream_putw(s
, st
->type
);
4151 stream_putw(s
, st
->length
);
4154 stream_put(s
, st
->value
, st
->length
);
4158 void bgp_packet_mpattr_end(struct stream
*s
, size_t sizep
)
4160 /* Set MP attribute length. Don't count the (2) bytes used to encode
4162 stream_putw_at(s
, sizep
, (stream_get_endp(s
) - sizep
) - 2);
4165 static bool bgp_append_local_as(struct peer
*peer
, afi_t afi
, safi_t safi
)
4167 if (!BGP_AS_IS_PRIVATE(peer
->local_as
)
4168 || (BGP_AS_IS_PRIVATE(peer
->local_as
)
4169 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4170 PEER_FLAG_REMOVE_PRIVATE_AS
)
4171 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4172 PEER_FLAG_REMOVE_PRIVATE_AS_ALL
)
4173 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4174 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
)
4175 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4176 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
)))
4181 /* Make attribute packet. */
4182 bgp_size_t
bgp_packet_attribute(struct bgp
*bgp
, struct peer
*peer
,
4183 struct stream
*s
, struct attr
*attr
,
4184 struct bpacket_attr_vec_arr
*vecarr
,
4185 struct prefix
*p
, afi_t afi
, safi_t safi
,
4186 struct peer
*from
, struct prefix_rd
*prd
,
4187 mpls_label_t
*label
, uint32_t num_labels
,
4188 bool addpath_capable
, uint32_t addpath_tx_id
,
4189 struct bgp_path_info
*bpi
)
4192 size_t aspath_sizep
;
4193 struct aspath
*aspath
;
4194 int send_as4_path
= 0;
4195 int send_as4_aggregator
= 0;
4196 bool use32bit
= CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
4197 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
4202 /* Remember current pointer. */
4203 cp
= stream_get_endp(s
);
4206 && !((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
4207 && !peer_cap_enhe(peer
, afi
, safi
))) {
4208 size_t mpattrlen_pos
= 0;
4210 mpattrlen_pos
= bgp_packet_mpattr_start(s
, peer
, afi
, safi
,
4212 bgp_packet_mpattr_prefix(s
, afi
, safi
, p
, prd
, label
,
4213 num_labels
, addpath_capable
,
4214 addpath_tx_id
, attr
);
4215 bgp_packet_mpattr_end(s
, mpattrlen_pos
);
4218 /* Origin attribute. */
4219 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4220 stream_putc(s
, BGP_ATTR_ORIGIN
);
4222 stream_putc(s
, attr
->origin
);
4224 /* AS path attribute. */
4226 /* If remote-peer is EBGP */
4227 if (peer
->sort
== BGP_PEER_EBGP
4228 && (!CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4229 PEER_FLAG_AS_PATH_UNCHANGED
)
4230 || attr
->aspath
->segments
== NULL
)
4231 && (!CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4232 PEER_FLAG_RSERVER_CLIENT
))) {
4233 aspath
= aspath_dup(attr
->aspath
);
4235 /* Even though we may not be configured for confederations we
4237 * RXed an AS_PATH with AS_CONFED_SEQUENCE or AS_CONFED_SET */
4238 aspath
= aspath_delete_confed_seq(aspath
);
4240 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
4241 /* Stuff our path CONFED_ID on the front */
4242 aspath
= aspath_add_seq(aspath
, bgp
->confed_id
);
4244 if (peer
->change_local_as
) {
4245 /* If replace-as is specified, we only use the
4246 change_local_as when
4247 advertising routes. */
4248 if (!CHECK_FLAG(peer
->flags
,
4249 PEER_FLAG_LOCAL_AS_REPLACE_AS
))
4250 if (bgp_append_local_as(peer
, afi
,
4252 aspath
= aspath_add_seq(
4253 aspath
, peer
->local_as
);
4254 aspath
= aspath_add_seq(aspath
,
4255 peer
->change_local_as
);
4257 aspath
= aspath_add_seq(aspath
, peer
->local_as
);
4260 } else if (peer
->sort
== BGP_PEER_CONFED
) {
4261 /* A confed member, so we need to do the AS_CONFED_SEQUENCE
4263 aspath
= aspath_dup(attr
->aspath
);
4264 aspath
= aspath_add_confed_seq(aspath
, peer
->local_as
);
4266 aspath
= attr
->aspath
;
4268 /* If peer is not AS4 capable, then:
4269 * - send the created AS_PATH out as AS4_PATH (optional, transitive),
4270 * but ensure that no AS_CONFED_SEQUENCE and AS_CONFED_SET path
4272 * types are in it (i.e. exclude them if they are there)
4273 * AND do this only if there is at least one asnum > 65535 in the
4275 * - send an AS_PATH out, but put 16Bit ASnums in it, not 32bit, and
4277 * all ASnums > 65535 to BGP_AS_TRANS
4280 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_EXTLEN
);
4281 stream_putc(s
, BGP_ATTR_AS_PATH
);
4282 aspath_sizep
= stream_get_endp(s
);
4284 stream_putw_at(s
, aspath_sizep
, aspath_put(s
, aspath
, use32bit
));
4286 /* OLD session may need NEW_AS_PATH sent, if there are 4-byte ASNs
4289 if (!use32bit
&& aspath_has_as4(aspath
))
4291 1; /* we'll do this later, at the correct place */
4293 /* Nexthop attribute. */
4294 if (afi
== AFI_IP
&& safi
== SAFI_UNICAST
4295 && !peer_cap_enhe(peer
, afi
, safi
)) {
4296 afi_t nh_afi
= BGP_NEXTHOP_AFI_FROM_NHLEN(attr
->mp_nexthop_len
);
4298 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
)) {
4299 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4300 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4301 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
,
4304 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4305 } else if (peer_cap_enhe(from
, afi
, safi
)
4306 || (nh_afi
== AFI_IP6
)) {
4308 * Likely this is the case when an IPv4 prefix was
4309 * received with Extended Next-hop capability in this
4310 * or another vrf and is now being advertised to
4311 * non-ENHE peers. Since peer_cap_enhe only checks
4312 * peers in this vrf, also check the nh_afi to catch
4313 * the case where the originator was in another vrf.
4314 * Setting the mandatory (ipv4) next-hop attribute here
4315 * to enable implicit next-hop self with correct A-F
4316 * (ipv4 address family).
4318 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4319 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4320 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
,
4323 stream_put_ipv4(s
, 0);
4327 /* MED attribute. */
4328 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
)
4329 || bgp
->maxmed_active
) {
4330 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4331 stream_putc(s
, BGP_ATTR_MULTI_EXIT_DISC
);
4333 stream_putl(s
, (bgp
->maxmed_active
? bgp
->maxmed_value
4337 /* Local preference. */
4338 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->sort
== BGP_PEER_CONFED
) {
4339 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4340 stream_putc(s
, BGP_ATTR_LOCAL_PREF
);
4342 stream_putl(s
, attr
->local_pref
);
4345 /* Atomic aggregate. */
4346 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
)) {
4347 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4348 stream_putc(s
, BGP_ATTR_ATOMIC_AGGREGATE
);
4353 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
)) {
4354 /* Common to BGP_ATTR_AGGREGATOR, regardless of ASN size */
4355 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4356 stream_putc(s
, BGP_ATTR_AGGREGATOR
);
4359 /* AS4 capable peer */
4361 stream_putl(s
, attr
->aggregator_as
);
4363 /* 2-byte AS peer */
4366 /* Is ASN representable in 2-bytes? Or must AS_TRANS be
4368 if (attr
->aggregator_as
> UINT16_MAX
) {
4369 stream_putw(s
, BGP_AS_TRANS
);
4371 /* we have to send AS4_AGGREGATOR, too.
4372 * we'll do that later in order to send
4373 * attributes in ascending
4376 send_as4_aggregator
= 1;
4378 stream_putw(s
, (uint16_t)attr
->aggregator_as
);
4380 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4383 /* Community attribute. */
4384 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
)
4385 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
))) {
4386 struct community
*comm
= NULL
;
4388 comm
= bgp_attr_get_community(attr
);
4389 if (comm
->size
* 4 > 255) {
4391 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4392 | BGP_ATTR_FLAG_EXTLEN
);
4393 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4394 stream_putw(s
, comm
->size
* 4);
4397 BGP_ATTR_FLAG_OPTIONAL
4398 | BGP_ATTR_FLAG_TRANS
);
4399 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4400 stream_putc(s
, comm
->size
* 4);
4402 stream_put(s
, comm
->val
, comm
->size
* 4);
4406 * Large Community attribute.
4408 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4409 PEER_FLAG_SEND_LARGE_COMMUNITY
)
4410 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
))) {
4411 if (lcom_length(bgp_attr_get_lcommunity(attr
)) > 255) {
4413 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4414 | BGP_ATTR_FLAG_EXTLEN
);
4415 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4417 lcom_length(bgp_attr_get_lcommunity(attr
)));
4420 BGP_ATTR_FLAG_OPTIONAL
4421 | BGP_ATTR_FLAG_TRANS
);
4422 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4424 lcom_length(bgp_attr_get_lcommunity(attr
)));
4426 stream_put(s
, bgp_attr_get_lcommunity(attr
)->val
,
4427 lcom_length(bgp_attr_get_lcommunity(attr
)));
4430 /* Route Reflector. */
4431 if (peer
->sort
== BGP_PEER_IBGP
&& from
4432 && from
->sort
== BGP_PEER_IBGP
) {
4433 struct cluster_list
*cluster
= bgp_attr_get_cluster(attr
);
4435 /* Originator ID. */
4436 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4437 stream_putc(s
, BGP_ATTR_ORIGINATOR_ID
);
4440 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
))
4441 stream_put_in_addr(s
, &attr
->originator_id
);
4443 stream_put_in_addr(s
, &from
->remote_id
);
4446 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4447 stream_putc(s
, BGP_ATTR_CLUSTER_LIST
);
4450 stream_putc(s
, cluster
->length
+ 4);
4451 /* If this peer configuration's parent BGP has
4453 if (bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
4454 stream_put_in_addr(s
, &bgp
->cluster_id
);
4456 stream_put_in_addr(s
, &bgp
->router_id
);
4457 stream_put(s
, cluster
->list
, cluster
->length
);
4460 /* If this peer configuration's parent BGP has
4462 if (bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
4463 stream_put_in_addr(s
, &bgp
->cluster_id
);
4465 stream_put_in_addr(s
, &bgp
->router_id
);
4469 /* Extended Communities attribute. */
4470 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
)
4471 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
))) {
4472 struct ecommunity
*ecomm
= bgp_attr_get_ecommunity(attr
);
4473 bool transparent
= CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4474 PEER_FLAG_RSERVER_CLIENT
) &&
4476 CHECK_FLAG(from
->af_flags
[afi
][safi
],
4477 PEER_FLAG_RSERVER_CLIENT
);
4479 if (peer
->sort
== BGP_PEER_IBGP
||
4480 peer
->sort
== BGP_PEER_CONFED
|| transparent
) {
4481 if (ecomm
->size
* 8 > 255) {
4483 BGP_ATTR_FLAG_OPTIONAL
4484 | BGP_ATTR_FLAG_TRANS
4485 | BGP_ATTR_FLAG_EXTLEN
);
4486 stream_putc(s
, BGP_ATTR_EXT_COMMUNITIES
);
4487 stream_putw(s
, ecomm
->size
* 8);
4490 BGP_ATTR_FLAG_OPTIONAL
4491 | BGP_ATTR_FLAG_TRANS
);
4492 stream_putc(s
, BGP_ATTR_EXT_COMMUNITIES
);
4493 stream_putc(s
, ecomm
->size
* 8);
4495 stream_put(s
, ecomm
->val
, ecomm
->size
* 8);
4499 int ecom_tr_size
= 0;
4502 for (i
= 0; i
< ecomm
->size
; i
++) {
4503 pnt
= ecomm
->val
+ (i
* 8);
4506 if (CHECK_FLAG(tbit
,
4507 ECOMMUNITY_FLAG_NON_TRANSITIVE
))
4514 if (ecom_tr_size
* 8 > 255) {
4517 BGP_ATTR_FLAG_OPTIONAL
4518 | BGP_ATTR_FLAG_TRANS
4519 | BGP_ATTR_FLAG_EXTLEN
);
4521 BGP_ATTR_EXT_COMMUNITIES
);
4522 stream_putw(s
, ecom_tr_size
* 8);
4526 BGP_ATTR_FLAG_OPTIONAL
4527 | BGP_ATTR_FLAG_TRANS
);
4529 BGP_ATTR_EXT_COMMUNITIES
);
4530 stream_putc(s
, ecom_tr_size
* 8);
4533 for (i
= 0; i
< ecomm
->size
; i
++) {
4534 pnt
= ecomm
->val
+ (i
* 8);
4539 ECOMMUNITY_FLAG_NON_TRANSITIVE
))
4542 stream_put(s
, pnt
, 8);
4548 /* Label index attribute. */
4549 if (safi
== SAFI_LABELED_UNICAST
) {
4550 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
)) {
4551 uint32_t label_index
;
4553 label_index
= attr
->label_index
;
4555 if (label_index
!= BGP_INVALID_LABEL_INDEX
) {
4557 BGP_ATTR_FLAG_OPTIONAL
4558 | BGP_ATTR_FLAG_TRANS
);
4559 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4561 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX
);
4563 BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
4564 stream_putc(s
, 0); // reserved
4565 stream_putw(s
, 0); // flags
4566 stream_putl(s
, label_index
);
4571 /* SRv6 Service Information Attribute. */
4572 if ((afi
== AFI_IP
|| afi
== AFI_IP6
) && safi
== SAFI_MPLS_VPN
) {
4573 if (attr
->srv6_l3vpn
) {
4574 uint8_t subtlv_len
=
4575 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
4577 + BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO_LENGTH
;
4578 uint8_t tlv_len
= subtlv_len
+ BGP_ATTR_MIN_LEN
+ 1;
4579 uint8_t attr_len
= tlv_len
+ BGP_ATTR_MIN_LEN
;
4580 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
4581 | BGP_ATTR_FLAG_TRANS
);
4582 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4583 stream_putc(s
, attr_len
);
4584 stream_putc(s
, BGP_PREFIX_SID_SRV6_L3_SERVICE
);
4585 stream_putw(s
, tlv_len
);
4586 stream_putc(s
, 0); /* reserved */
4587 stream_putc(s
, BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO
);
4588 stream_putw(s
, subtlv_len
);
4589 stream_putc(s
, 0); /* reserved */
4590 stream_put(s
, &attr
->srv6_l3vpn
->sid
,
4591 sizeof(attr
->srv6_l3vpn
->sid
)); /* sid */
4592 stream_putc(s
, 0); /* sid_flags */
4595 ->endpoint_behavior
); /* endpoint */
4596 stream_putc(s
, 0); /* reserved */
4599 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE
);
4602 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
);
4603 stream_putc(s
, attr
->srv6_l3vpn
->loc_block_len
);
4604 stream_putc(s
, attr
->srv6_l3vpn
->loc_node_len
);
4605 stream_putc(s
, attr
->srv6_l3vpn
->func_len
);
4606 stream_putc(s
, attr
->srv6_l3vpn
->arg_len
);
4607 stream_putc(s
, attr
->srv6_l3vpn
->transposition_len
);
4608 stream_putc(s
, attr
->srv6_l3vpn
->transposition_offset
);
4609 } else if (attr
->srv6_vpn
) {
4610 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
4611 | BGP_ATTR_FLAG_TRANS
);
4612 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4613 stream_putc(s
, 22); /* tlv len */
4614 stream_putc(s
, BGP_PREFIX_SID_VPN_SID
);
4615 stream_putw(s
, 0x13); /* tlv len */
4616 stream_putc(s
, 0x00); /* reserved */
4617 stream_putc(s
, 0x01); /* sid_type */
4618 stream_putc(s
, 0x00); /* sif_flags */
4619 stream_put(s
, &attr
->srv6_vpn
->sid
,
4620 sizeof(attr
->srv6_vpn
->sid
)); /* sid */
4624 if (send_as4_path
) {
4625 /* If the peer is NOT As4 capable, AND */
4626 /* there are ASnums > 65535 in path THEN
4627 * give out AS4_PATH */
4629 /* Get rid of all AS_CONFED_SEQUENCE and AS_CONFED_SET
4631 * Hm, I wonder... confederation things *should* only be at
4632 * the beginning of an aspath, right? Then we should use
4633 * aspath_delete_confed_seq for this, because it is already
4635 * Folks, talk to me: what is reasonable here!?
4637 aspath
= aspath_delete_confed_seq(aspath
);
4640 BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
4641 | BGP_ATTR_FLAG_EXTLEN
);
4642 stream_putc(s
, BGP_ATTR_AS4_PATH
);
4643 aspath_sizep
= stream_get_endp(s
);
4645 stream_putw_at(s
, aspath_sizep
, aspath_put(s
, aspath
, 1));
4648 if (aspath
!= attr
->aspath
)
4649 aspath_free(aspath
);
4651 if (send_as4_aggregator
) {
4652 /* send AS4_AGGREGATOR, at this place */
4653 /* this section of code moved here in order to ensure the
4655 * *ascending* order of attributes
4657 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4658 stream_putc(s
, BGP_ATTR_AS4_AGGREGATOR
);
4660 stream_putl(s
, attr
->aggregator_as
);
4661 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4664 if (((afi
== AFI_IP
|| afi
== AFI_IP6
)
4665 && (safi
== SAFI_ENCAP
|| safi
== SAFI_MPLS_VPN
))
4666 || (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
)) {
4667 /* Tunnel Encap attribute */
4668 bgp_packet_mpattr_tea(bgp
, peer
, s
, attr
, BGP_ATTR_ENCAP
);
4670 #ifdef ENABLE_BGP_VNC_ATTR
4672 bgp_packet_mpattr_tea(bgp
, peer
, s
, attr
, BGP_ATTR_VNC
);
4677 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
)) {
4678 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4679 stream_putc(s
, BGP_ATTR_PMSI_TUNNEL
);
4680 stream_putc(s
, 9); // Length
4681 stream_putc(s
, 0); // Flags
4682 stream_putc(s
, bgp_attr_get_pmsi_tnl_type(attr
));
4683 stream_put(s
, &(attr
->label
),
4684 BGP_LABEL_BYTES
); // MPLS Label / VXLAN VNI
4685 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4686 // Unicast tunnel endpoint IP address
4690 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_OTC
)) {
4691 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4692 stream_putc(s
, BGP_ATTR_OTC
);
4694 stream_putl(s
, attr
->otc
);
4698 if (bpi
&& attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_AIGP
) &&
4699 (CHECK_FLAG(peer
->flags
, PEER_FLAG_AIGP
) ||
4700 peer
->sort
!= BGP_PEER_EBGP
)) {
4701 /* At the moment only AIGP Metric TLV exists for AIGP
4702 * attribute. If more comes in, do not forget to update
4703 * attr_len variable to include new ones.
4705 uint8_t attr_len
= BGP_AIGP_TLV_METRIC_LEN
;
4707 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4708 stream_putc(s
, BGP_ATTR_AIGP
);
4709 stream_putc(s
, attr_len
);
4710 stream_put_bgp_aigp_tlv_metric(s
, bpi
);
4713 /* Unknown transit attribute. */
4714 struct transit
*transit
= bgp_attr_get_transit(attr
);
4717 stream_put(s
, transit
->val
, transit
->length
);
4719 /* Return total size of attribute. */
4720 return stream_get_endp(s
) - cp
;
4723 size_t bgp_packet_mpunreach_start(struct stream
*s
, afi_t afi
, safi_t safi
)
4725 unsigned long attrlen_pnt
;
4726 iana_afi_t pkt_afi
= IANA_AFI_IPV4
;
4727 iana_safi_t pkt_safi
= IANA_SAFI_UNICAST
;
4729 /* Set extended bit always to encode the attribute length as 2 bytes */
4730 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_EXTLEN
);
4731 stream_putc(s
, BGP_ATTR_MP_UNREACH_NLRI
);
4733 attrlen_pnt
= stream_get_endp(s
);
4734 stream_putw(s
, 0); /* Length of this attribute. */
4736 /* Convert AFI, SAFI to values for packet. */
4737 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
4739 stream_putw(s
, pkt_afi
);
4740 stream_putc(s
, pkt_safi
);
4745 void bgp_packet_mpunreach_prefix(struct stream
*s
, const struct prefix
*p
,
4746 afi_t afi
, safi_t safi
,
4747 const struct prefix_rd
*prd
,
4748 mpls_label_t
*label
, uint32_t num_labels
,
4749 bool addpath_capable
, uint32_t addpath_tx_id
,
4752 uint8_t wlabel
[4] = {0x80, 0x00, 0x00};
4754 if (safi
== SAFI_LABELED_UNICAST
) {
4755 label
= (mpls_label_t
*)wlabel
;
4759 bgp_packet_mpattr_prefix(s
, afi
, safi
, p
, prd
, label
, num_labels
,
4760 addpath_capable
, addpath_tx_id
, attr
);
4763 void bgp_packet_mpunreach_end(struct stream
*s
, size_t attrlen_pnt
)
4765 bgp_packet_mpattr_end(s
, attrlen_pnt
);
4768 /* Initialization of attribute. */
4769 void bgp_attr_init(void)
4782 void bgp_attr_finish(void)
4787 ecommunity_finish();
4788 lcommunity_finish();
4795 /* Make attribute packet. */
4796 void bgp_dump_routes_attr(struct stream
*s
, struct bgp_path_info
*bpi
,
4797 const struct prefix
*prefix
)
4802 struct aspath
*aspath
;
4803 bool addpath_capable
= false;
4804 uint32_t addpath_tx_id
= 0;
4805 struct attr
*attr
= bpi
->attr
;
4807 /* Remember current pointer. */
4808 cp
= stream_get_endp(s
);
4810 /* Place holder of length. */
4813 /* Origin attribute. */
4814 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4815 stream_putc(s
, BGP_ATTR_ORIGIN
);
4817 stream_putc(s
, attr
->origin
);
4819 aspath
= attr
->aspath
;
4821 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_EXTLEN
);
4822 stream_putc(s
, BGP_ATTR_AS_PATH
);
4823 aspath_lenp
= stream_get_endp(s
);
4826 stream_putw_at(s
, aspath_lenp
, aspath_put(s
, aspath
, 1));
4828 /* Nexthop attribute. */
4829 /* If it's an IPv6 prefix, don't dump the IPv4 nexthop to save space */
4830 if (prefix
!= NULL
&& prefix
->family
!= AF_INET6
) {
4831 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4832 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4834 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4837 /* MED attribute. */
4838 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
)) {
4839 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4840 stream_putc(s
, BGP_ATTR_MULTI_EXIT_DISC
);
4842 stream_putl(s
, attr
->med
);
4845 /* Local preference. */
4846 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)) {
4847 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4848 stream_putc(s
, BGP_ATTR_LOCAL_PREF
);
4850 stream_putl(s
, attr
->local_pref
);
4853 /* Atomic aggregate. */
4854 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
)) {
4855 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4856 stream_putc(s
, BGP_ATTR_ATOMIC_AGGREGATE
);
4861 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
)) {
4862 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4863 stream_putc(s
, BGP_ATTR_AGGREGATOR
);
4865 stream_putl(s
, attr
->aggregator_as
);
4866 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4869 /* Community attribute. */
4870 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
)) {
4871 struct community
*comm
= NULL
;
4873 comm
= bgp_attr_get_community(attr
);
4874 if (comm
->size
* 4 > 255) {
4876 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4877 | BGP_ATTR_FLAG_EXTLEN
);
4878 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4879 stream_putw(s
, comm
->size
* 4);
4882 BGP_ATTR_FLAG_OPTIONAL
4883 | BGP_ATTR_FLAG_TRANS
);
4884 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4885 stream_putc(s
, comm
->size
* 4);
4887 stream_put(s
, comm
->val
, comm
->size
* 4);
4890 /* Large Community attribute. */
4891 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
)) {
4892 if (lcom_length(bgp_attr_get_lcommunity(attr
)) > 255) {
4894 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4895 | BGP_ATTR_FLAG_EXTLEN
);
4896 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4898 lcom_length(bgp_attr_get_lcommunity(attr
)));
4901 BGP_ATTR_FLAG_OPTIONAL
4902 | BGP_ATTR_FLAG_TRANS
);
4903 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4905 lcom_length(bgp_attr_get_lcommunity(attr
)));
4908 stream_put(s
, bgp_attr_get_lcommunity(attr
)->val
,
4909 lcom_length(bgp_attr_get_lcommunity(attr
)));
4912 /* Add a MP_NLRI attribute to dump the IPv6 next hop */
4913 if (prefix
!= NULL
&& prefix
->family
== AF_INET6
4914 && (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL
4915 || attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)) {
4918 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4919 stream_putc(s
, BGP_ATTR_MP_REACH_NLRI
);
4920 sizep
= stream_get_endp(s
);
4923 stream_putc(s
, 0); /* Marker: Attribute length. */
4924 stream_putw(s
, AFI_IP6
); /* AFI */
4925 stream_putc(s
, SAFI_UNICAST
); /* SAFI */
4928 stream_putc(s
, attr
->mp_nexthop_len
);
4929 stream_put(s
, &attr
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
4930 if (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
4931 stream_put(s
, &attr
->mp_nexthop_local
,
4938 stream_put_prefix_addpath(s
, prefix
, addpath_capable
,
4941 /* Set MP attribute length. */
4942 stream_putc_at(s
, sizep
, (stream_get_endp(s
) - sizep
) - 1);
4946 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
)) {
4947 if (attr
->label_index
!= BGP_INVALID_LABEL_INDEX
) {
4949 BGP_ATTR_FLAG_OPTIONAL
4950 | BGP_ATTR_FLAG_TRANS
);
4951 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4953 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX
);
4954 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
4955 stream_putc(s
, 0); // reserved
4956 stream_putw(s
, 0); // flags
4957 stream_putl(s
, attr
->label_index
);
4962 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_OTC
)) {
4963 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4964 stream_putc(s
, BGP_ATTR_OTC
);
4966 stream_putl(s
, attr
->otc
);
4970 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_AIGP
)) {
4971 /* At the moment only AIGP Metric TLV exists for AIGP
4972 * attribute. If more comes in, do not forget to update
4973 * attr_len variable to include new ones.
4975 uint8_t attr_len
= BGP_AIGP_TLV_METRIC_LEN
;
4977 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4978 stream_putc(s
, BGP_ATTR_AIGP
);
4979 stream_putc(s
, attr_len
);
4980 stream_put_bgp_aigp_tlv_metric(s
, bpi
);
4983 /* Return total size of attribute. */
4984 len
= stream_get_endp(s
) - cp
- 2;
4985 stream_putw_at(s
, cp
, len
);