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_DPA
, "DPA"},
72 {BGP_ATTR_ADVERTISER
, "ADVERTISER"},
73 {BGP_ATTR_RCID_PATH
, "RCID_PATH"},
74 {BGP_ATTR_MP_REACH_NLRI
, "MP_REACH_NLRI"},
75 {BGP_ATTR_MP_UNREACH_NLRI
, "MP_UNREACH_NLRI"},
76 {BGP_ATTR_EXT_COMMUNITIES
, "EXT_COMMUNITIES"},
77 {BGP_ATTR_AS4_PATH
, "AS4_PATH"},
78 {BGP_ATTR_AS4_AGGREGATOR
, "AS4_AGGREGATOR"},
79 {BGP_ATTR_AS_PATHLIMIT
, "AS_PATHLIMIT"},
80 {BGP_ATTR_PMSI_TUNNEL
, "PMSI_TUNNEL_ATTRIBUTE"},
81 {BGP_ATTR_ENCAP
, "ENCAP"},
82 #ifdef ENABLE_BGP_VNC_ATTR
83 {BGP_ATTR_VNC
, "VNC"},
85 {BGP_ATTR_LARGE_COMMUNITIES
, "LARGE_COMMUNITY"},
86 {BGP_ATTR_PREFIX_SID
, "PREFIX_SID"},
87 {BGP_ATTR_IPV6_EXT_COMMUNITIES
, "IPV6_EXT_COMMUNITIES"},
90 static const struct message attr_flag_str
[] = {
91 {BGP_ATTR_FLAG_OPTIONAL
, "Optional"},
92 {BGP_ATTR_FLAG_TRANS
, "Transitive"},
93 {BGP_ATTR_FLAG_PARTIAL
, "Partial"},
94 /* bgp_attr_flags_diagnose() relies on this bit being last in
96 {BGP_ATTR_FLAG_EXTLEN
, "Extended Length"},
99 static struct hash
*cluster_hash
;
101 static void *cluster_hash_alloc(void *p
)
103 const struct cluster_list
*val
= (const struct cluster_list
*)p
;
104 struct cluster_list
*cluster
;
106 cluster
= XMALLOC(MTYPE_CLUSTER
, sizeof(struct cluster_list
));
107 cluster
->length
= val
->length
;
109 if (cluster
->length
) {
110 cluster
->list
= XMALLOC(MTYPE_CLUSTER_VAL
, val
->length
);
111 memcpy(cluster
->list
, val
->list
, val
->length
);
113 cluster
->list
= NULL
;
120 /* Cluster list related functions. */
121 static struct cluster_list
*cluster_parse(struct in_addr
*pnt
, int length
)
123 struct cluster_list tmp
= {};
124 struct cluster_list
*cluster
;
127 tmp
.list
= length
== 0 ? NULL
: pnt
;
129 cluster
= hash_get(cluster_hash
, &tmp
, cluster_hash_alloc
);
134 bool cluster_loop_check(struct cluster_list
*cluster
, struct in_addr originator
)
138 for (i
= 0; i
< cluster
->length
/ 4; i
++)
139 if (cluster
->list
[i
].s_addr
== originator
.s_addr
)
144 static unsigned int cluster_hash_key_make(const void *p
)
146 const struct cluster_list
*cluster
= p
;
148 return jhash(cluster
->list
, cluster
->length
, 0);
151 static bool cluster_hash_cmp(const void *p1
, const void *p2
)
153 const struct cluster_list
*cluster1
= p1
;
154 const struct cluster_list
*cluster2
= p2
;
156 if (cluster1
->list
== cluster2
->list
)
159 if (!cluster1
->list
|| !cluster2
->list
)
162 if (cluster1
->length
!= cluster2
->length
)
165 return (memcmp(cluster1
->list
, cluster2
->list
, cluster1
->length
) == 0);
168 static void cluster_free(struct cluster_list
*cluster
)
170 XFREE(MTYPE_CLUSTER_VAL
, cluster
->list
);
171 XFREE(MTYPE_CLUSTER
, cluster
);
174 static struct cluster_list
*cluster_intern(struct cluster_list
*cluster
)
176 struct cluster_list
*find
;
178 find
= hash_get(cluster_hash
, cluster
, cluster_hash_alloc
);
184 static void cluster_unintern(struct cluster_list
**cluster
)
186 if ((*cluster
)->refcnt
)
187 (*cluster
)->refcnt
--;
189 if ((*cluster
)->refcnt
== 0) {
190 void *p
= hash_release(cluster_hash
, *cluster
);
191 assert(p
== *cluster
);
192 cluster_free(*cluster
);
197 static void cluster_init(void)
199 cluster_hash
= hash_create(cluster_hash_key_make
, cluster_hash_cmp
,
203 static void cluster_finish(void)
205 hash_clean(cluster_hash
, (void (*)(void *))cluster_free
);
206 hash_free(cluster_hash
);
210 static struct hash
*encap_hash
= NULL
;
211 #ifdef ENABLE_BGP_VNC
212 static struct hash
*vnc_hash
= NULL
;
214 static struct hash
*srv6_l3vpn_hash
;
215 static struct hash
*srv6_vpn_hash
;
217 struct bgp_attr_encap_subtlv
*encap_tlv_dup(struct bgp_attr_encap_subtlv
*orig
)
219 struct bgp_attr_encap_subtlv
*new;
220 struct bgp_attr_encap_subtlv
*tail
;
221 struct bgp_attr_encap_subtlv
*p
;
223 for (p
= orig
, tail
= new = NULL
; p
; p
= p
->next
) {
224 int size
= sizeof(struct bgp_attr_encap_subtlv
) + p
->length
;
226 tail
->next
= XCALLOC(MTYPE_ENCAP_TLV
, size
);
229 tail
= new = XCALLOC(MTYPE_ENCAP_TLV
, size
);
232 memcpy(tail
, p
, size
);
239 static void encap_free(struct bgp_attr_encap_subtlv
*p
)
241 struct bgp_attr_encap_subtlv
*next
;
245 XFREE(MTYPE_ENCAP_TLV
, p
);
250 void bgp_attr_flush_encap(struct attr
*attr
)
255 if (attr
->encap_subtlvs
) {
256 encap_free(attr
->encap_subtlvs
);
257 attr
->encap_subtlvs
= NULL
;
259 #ifdef ENABLE_BGP_VNC
260 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
261 bgp_attr_get_vnc_subtlvs(attr
);
264 encap_free(vnc_subtlvs
);
265 bgp_attr_set_vnc_subtlvs(attr
, NULL
);
271 * Compare encap sub-tlv chains
276 * This algorithm could be made faster if needed
278 static bool encap_same(const struct bgp_attr_encap_subtlv
*h1
,
279 const struct bgp_attr_encap_subtlv
*h2
)
281 const struct bgp_attr_encap_subtlv
*p
;
282 const struct bgp_attr_encap_subtlv
*q
;
286 if (h1
== NULL
|| h2
== NULL
)
289 for (p
= h1
; p
; p
= p
->next
) {
290 for (q
= h2
; q
; q
= q
->next
) {
291 if ((p
->type
== q
->type
) && (p
->length
== q
->length
)
292 && !memcmp(p
->value
, q
->value
, p
->length
)) {
301 for (p
= h2
; p
; p
= p
->next
) {
302 for (q
= h1
; q
; q
= q
->next
) {
303 if ((p
->type
== q
->type
) && (p
->length
== q
->length
)
304 && !memcmp(p
->value
, q
->value
, p
->length
)) {
316 static void *encap_hash_alloc(void *p
)
318 /* Encap structure is already allocated. */
324 #ifdef ENABLE_BGP_VNC
329 static struct bgp_attr_encap_subtlv
*
330 encap_intern(struct bgp_attr_encap_subtlv
*encap
, encap_subtlv_type type
)
332 struct bgp_attr_encap_subtlv
*find
;
333 struct hash
*hash
= encap_hash
;
334 #ifdef ENABLE_BGP_VNC
335 if (type
== VNC_SUBTLV_TYPE
)
339 find
= hash_get(hash
, encap
, encap_hash_alloc
);
347 static void encap_unintern(struct bgp_attr_encap_subtlv
**encapp
,
348 encap_subtlv_type type
)
350 struct bgp_attr_encap_subtlv
*encap
= *encapp
;
354 if (encap
->refcnt
== 0) {
355 struct hash
*hash
= encap_hash
;
356 #ifdef ENABLE_BGP_VNC
357 if (type
== VNC_SUBTLV_TYPE
)
360 hash_release(hash
, encap
);
366 static unsigned int encap_hash_key_make(const void *p
)
368 const struct bgp_attr_encap_subtlv
*encap
= p
;
370 return jhash(encap
->value
, encap
->length
, 0);
373 static bool encap_hash_cmp(const void *p1
, const void *p2
)
375 return encap_same((const struct bgp_attr_encap_subtlv
*)p1
,
376 (const struct bgp_attr_encap_subtlv
*)p2
);
379 static void encap_init(void)
381 encap_hash
= hash_create(encap_hash_key_make
, encap_hash_cmp
,
383 #ifdef ENABLE_BGP_VNC
384 vnc_hash
= hash_create(encap_hash_key_make
, encap_hash_cmp
,
389 static void encap_finish(void)
391 hash_clean(encap_hash
, (void (*)(void *))encap_free
);
392 hash_free(encap_hash
);
394 #ifdef ENABLE_BGP_VNC
395 hash_clean(vnc_hash
, (void (*)(void *))encap_free
);
401 static bool overlay_index_same(const struct attr
*a1
, const struct attr
*a2
)
410 return !memcmp(bgp_attr_get_evpn_overlay(a1
),
411 bgp_attr_get_evpn_overlay(a2
),
412 sizeof(struct bgp_route_evpn
));
415 /* Unknown transit attribute. */
416 static struct hash
*transit_hash
;
418 static void transit_free(struct transit
*transit
)
420 XFREE(MTYPE_TRANSIT_VAL
, transit
->val
);
421 XFREE(MTYPE_TRANSIT
, transit
);
424 static void *transit_hash_alloc(void *p
)
426 /* Transit structure is already allocated. */
430 static struct transit
*transit_intern(struct transit
*transit
)
432 struct transit
*find
;
434 find
= hash_get(transit_hash
, transit
, transit_hash_alloc
);
436 transit_free(transit
);
442 static void transit_unintern(struct transit
**transit
)
444 if ((*transit
)->refcnt
)
445 (*transit
)->refcnt
--;
447 if ((*transit
)->refcnt
== 0) {
448 hash_release(transit_hash
, *transit
);
449 transit_free(*transit
);
454 static void *srv6_l3vpn_hash_alloc(void *p
)
459 static void srv6_l3vpn_free(struct bgp_attr_srv6_l3vpn
*l3vpn
)
461 XFREE(MTYPE_BGP_SRV6_L3VPN
, l3vpn
);
464 static struct bgp_attr_srv6_l3vpn
*
465 srv6_l3vpn_intern(struct bgp_attr_srv6_l3vpn
*l3vpn
)
467 struct bgp_attr_srv6_l3vpn
*find
;
469 find
= hash_get(srv6_l3vpn_hash
, l3vpn
, srv6_l3vpn_hash_alloc
);
471 srv6_l3vpn_free(l3vpn
);
476 static void srv6_l3vpn_unintern(struct bgp_attr_srv6_l3vpn
**l3vpnp
)
478 struct bgp_attr_srv6_l3vpn
*l3vpn
= *l3vpnp
;
483 if (l3vpn
->refcnt
== 0) {
484 hash_release(srv6_l3vpn_hash
, l3vpn
);
485 srv6_l3vpn_free(l3vpn
);
490 static void *srv6_vpn_hash_alloc(void *p
)
495 static void srv6_vpn_free(struct bgp_attr_srv6_vpn
*vpn
)
497 XFREE(MTYPE_BGP_SRV6_VPN
, vpn
);
500 static struct bgp_attr_srv6_vpn
*srv6_vpn_intern(struct bgp_attr_srv6_vpn
*vpn
)
502 struct bgp_attr_srv6_vpn
*find
;
504 find
= hash_get(srv6_vpn_hash
, vpn
, srv6_vpn_hash_alloc
);
511 static void srv6_vpn_unintern(struct bgp_attr_srv6_vpn
**vpnp
)
513 struct bgp_attr_srv6_vpn
*vpn
= *vpnp
;
518 if (vpn
->refcnt
== 0) {
519 hash_release(srv6_vpn_hash
, vpn
);
525 static uint32_t srv6_l3vpn_hash_key_make(const void *p
)
527 const struct bgp_attr_srv6_l3vpn
*l3vpn
= p
;
530 key
= jhash(&l3vpn
->sid
, 16, key
);
531 key
= jhash_1word(l3vpn
->sid_flags
, key
);
532 key
= jhash_1word(l3vpn
->endpoint_behavior
, key
);
533 key
= jhash_1word(l3vpn
->loc_block_len
, key
);
534 key
= jhash_1word(l3vpn
->loc_node_len
, key
);
535 key
= jhash_1word(l3vpn
->func_len
, key
);
536 key
= jhash_1word(l3vpn
->arg_len
, key
);
537 key
= jhash_1word(l3vpn
->transposition_len
, key
);
538 key
= jhash_1word(l3vpn
->transposition_offset
, key
);
542 static bool srv6_l3vpn_hash_cmp(const void *p1
, const void *p2
)
544 const struct bgp_attr_srv6_l3vpn
*l3vpn1
= p1
;
545 const struct bgp_attr_srv6_l3vpn
*l3vpn2
= p2
;
547 return sid_same(&l3vpn1
->sid
, &l3vpn2
->sid
)
548 && l3vpn1
->sid_flags
== l3vpn2
->sid_flags
549 && l3vpn1
->endpoint_behavior
== l3vpn2
->endpoint_behavior
550 && l3vpn1
->loc_block_len
== l3vpn2
->loc_block_len
551 && l3vpn1
->loc_node_len
== l3vpn2
->loc_node_len
552 && l3vpn1
->func_len
== l3vpn2
->func_len
553 && l3vpn1
->arg_len
== l3vpn2
->arg_len
554 && l3vpn1
->transposition_len
== l3vpn2
->transposition_len
555 && l3vpn1
->transposition_offset
== l3vpn2
->transposition_offset
;
558 static bool srv6_l3vpn_same(const struct bgp_attr_srv6_l3vpn
*h1
,
559 const struct bgp_attr_srv6_l3vpn
*h2
)
563 else if (h1
== NULL
|| h2
== NULL
)
566 return srv6_l3vpn_hash_cmp((const void *)h1
, (const void *)h2
);
569 static unsigned int srv6_vpn_hash_key_make(const void *p
)
571 const struct bgp_attr_srv6_vpn
*vpn
= p
;
574 key
= jhash(&vpn
->sid
, 16, key
);
575 key
= jhash_1word(vpn
->sid_flags
, key
);
579 static bool srv6_vpn_hash_cmp(const void *p1
, const void *p2
)
581 const struct bgp_attr_srv6_vpn
*vpn1
= p1
;
582 const struct bgp_attr_srv6_vpn
*vpn2
= p2
;
584 return sid_same(&vpn1
->sid
, &vpn2
->sid
)
585 && vpn1
->sid_flags
== vpn2
->sid_flags
;
588 static bool srv6_vpn_same(const struct bgp_attr_srv6_vpn
*h1
,
589 const struct bgp_attr_srv6_vpn
*h2
)
593 else if (h1
== NULL
|| h2
== NULL
)
596 return srv6_vpn_hash_cmp((const void *)h1
, (const void *)h2
);
599 static void srv6_init(void)
602 hash_create(srv6_l3vpn_hash_key_make
, srv6_l3vpn_hash_cmp
,
603 "BGP Prefix-SID SRv6-L3VPN-Service-TLV");
604 srv6_vpn_hash
= hash_create(srv6_vpn_hash_key_make
, srv6_vpn_hash_cmp
,
605 "BGP Prefix-SID SRv6-VPN-Service-TLV");
608 static void srv6_finish(void)
610 hash_clean(srv6_l3vpn_hash
, (void (*)(void *))srv6_l3vpn_free
);
611 hash_free(srv6_l3vpn_hash
);
612 srv6_l3vpn_hash
= NULL
;
613 hash_clean(srv6_vpn_hash
, (void (*)(void *))srv6_vpn_free
);
614 hash_free(srv6_vpn_hash
);
615 srv6_vpn_hash
= NULL
;
618 static unsigned int transit_hash_key_make(const void *p
)
620 const struct transit
*transit
= p
;
622 return jhash(transit
->val
, transit
->length
, 0);
625 static bool transit_hash_cmp(const void *p1
, const void *p2
)
627 const struct transit
*transit1
= p1
;
628 const struct transit
*transit2
= p2
;
630 return (transit1
->length
== transit2
->length
631 && memcmp(transit1
->val
, transit2
->val
, transit1
->length
) == 0);
634 static void transit_init(void)
636 transit_hash
= hash_create(transit_hash_key_make
, transit_hash_cmp
,
640 static void transit_finish(void)
642 hash_clean(transit_hash
, (void (*)(void *))transit_free
);
643 hash_free(transit_hash
);
647 /* Attribute hash routines. */
648 static struct hash
*attrhash
;
650 unsigned long int attr_count(void)
652 return attrhash
->count
;
655 unsigned long int attr_unknown_count(void)
657 return transit_hash
->count
;
660 unsigned int attrhash_key_make(const void *p
)
662 const struct attr
*attr
= (struct attr
*)p
;
664 #define MIX(val) key = jhash_1word(val, key)
665 #define MIX3(a, b, c) key = jhash_3words((a), (b), (c), key)
667 MIX3(attr
->origin
, attr
->nexthop
.s_addr
, attr
->med
);
668 MIX3(attr
->local_pref
, attr
->aggregator_as
,
669 attr
->aggregator_addr
.s_addr
);
670 MIX3(attr
->weight
, attr
->mp_nexthop_global_in
.s_addr
,
671 attr
->originator_id
.s_addr
);
672 MIX3(attr
->tag
, attr
->label
, attr
->label_index
);
675 MIX(aspath_key_make(attr
->aspath
));
677 MIX(community_hash_make(attr
->community
));
679 if (attr
->lcommunity
)
680 MIX(lcommunity_hash_make(attr
->lcommunity
));
681 if (attr
->ecommunity
)
682 MIX(ecommunity_hash_make(attr
->ecommunity
));
683 if (bgp_attr_get_ipv6_ecommunity(attr
))
684 MIX(ecommunity_hash_make(bgp_attr_get_ipv6_ecommunity(attr
)));
685 if (bgp_attr_get_cluster(attr
))
686 MIX(cluster_hash_key_make(bgp_attr_get_cluster(attr
)));
687 if (bgp_attr_get_transit(attr
))
688 MIX(transit_hash_key_make(bgp_attr_get_transit(attr
)));
689 if (attr
->encap_subtlvs
)
690 MIX(encap_hash_key_make(attr
->encap_subtlvs
));
691 if (attr
->srv6_l3vpn
)
692 MIX(srv6_l3vpn_hash_key_make(attr
->srv6_l3vpn
));
694 MIX(srv6_vpn_hash_key_make(attr
->srv6_vpn
));
695 #ifdef ENABLE_BGP_VNC
696 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
697 bgp_attr_get_vnc_subtlvs(attr
);
699 MIX(encap_hash_key_make(vnc_subtlvs
));
701 MIX(attr
->mp_nexthop_len
);
702 key
= jhash(attr
->mp_nexthop_global
.s6_addr
, IPV6_MAX_BYTELEN
, key
);
703 key
= jhash(attr
->mp_nexthop_local
.s6_addr
, IPV6_MAX_BYTELEN
, key
);
704 MIX3(attr
->nh_ifindex
, attr
->nh_lla_ifindex
, attr
->distance
);
705 MIX(attr
->rmap_table_id
);
712 bool attrhash_cmp(const void *p1
, const void *p2
)
714 const struct attr
*attr1
= p1
;
715 const struct attr
*attr2
= p2
;
717 if (attr1
->flag
== attr2
->flag
&& attr1
->origin
== attr2
->origin
718 && attr1
->nexthop
.s_addr
== attr2
->nexthop
.s_addr
719 && attr1
->aspath
== attr2
->aspath
720 && attr1
->community
== attr2
->community
&& attr1
->med
== attr2
->med
721 && attr1
->local_pref
== attr2
->local_pref
722 && attr1
->rmap_change_flags
== attr2
->rmap_change_flags
) {
723 if (attr1
->aggregator_as
== attr2
->aggregator_as
724 && attr1
->aggregator_addr
.s_addr
725 == attr2
->aggregator_addr
.s_addr
726 && attr1
->weight
== attr2
->weight
727 && attr1
->tag
== attr2
->tag
728 && attr1
->label_index
== attr2
->label_index
729 && attr1
->mp_nexthop_len
== attr2
->mp_nexthop_len
730 && attr1
->ecommunity
== attr2
->ecommunity
731 && bgp_attr_get_ipv6_ecommunity(attr1
)
732 == bgp_attr_get_ipv6_ecommunity(attr2
)
733 && attr1
->lcommunity
== attr2
->lcommunity
734 && bgp_attr_get_cluster(attr1
)
735 == bgp_attr_get_cluster(attr2
)
736 && bgp_attr_get_transit(attr1
)
737 == bgp_attr_get_transit(attr2
)
738 && attr1
->rmap_table_id
== attr2
->rmap_table_id
739 && (attr1
->encap_tunneltype
== attr2
->encap_tunneltype
)
740 && encap_same(attr1
->encap_subtlvs
, attr2
->encap_subtlvs
)
741 #ifdef ENABLE_BGP_VNC
742 && encap_same(bgp_attr_get_vnc_subtlvs(attr1
),
743 bgp_attr_get_vnc_subtlvs(attr2
))
745 && IPV6_ADDR_SAME(&attr1
->mp_nexthop_global
,
746 &attr2
->mp_nexthop_global
)
747 && IPV6_ADDR_SAME(&attr1
->mp_nexthop_local
,
748 &attr2
->mp_nexthop_local
)
749 && IPV4_ADDR_SAME(&attr1
->mp_nexthop_global_in
,
750 &attr2
->mp_nexthop_global_in
)
751 && IPV4_ADDR_SAME(&attr1
->originator_id
,
752 &attr2
->originator_id
)
753 && overlay_index_same(attr1
, attr2
)
754 && !memcmp(&attr1
->esi
, &attr2
->esi
, sizeof(esi_t
))
755 && attr1
->es_flags
== attr2
->es_flags
756 && attr1
->mm_sync_seqnum
== attr2
->mm_sync_seqnum
757 && attr1
->df_pref
== attr2
->df_pref
758 && attr1
->df_alg
== attr2
->df_alg
759 && attr1
->nh_ifindex
== attr2
->nh_ifindex
760 && attr1
->nh_lla_ifindex
== attr2
->nh_lla_ifindex
761 && attr1
->distance
== attr2
->distance
762 && srv6_l3vpn_same(attr1
->srv6_l3vpn
, attr2
->srv6_l3vpn
)
763 && srv6_vpn_same(attr1
->srv6_vpn
, attr2
->srv6_vpn
)
764 && attr1
->srte_color
== attr2
->srte_color
765 && attr1
->nh_type
== attr2
->nh_type
766 && attr1
->bh_type
== attr2
->bh_type
)
773 static void attrhash_init(void)
776 hash_create(attrhash_key_make
, attrhash_cmp
, "BGP Attributes");
780 * special for hash_clean below
782 static void attr_vfree(void *attr
)
784 XFREE(MTYPE_ATTR
, attr
);
787 static void attrhash_finish(void)
789 hash_clean(attrhash
, attr_vfree
);
794 static void attr_show_all_iterator(struct hash_bucket
*bucket
, struct vty
*vty
)
796 struct attr
*attr
= bucket
->data
;
797 char sid_str
[BUFSIZ
];
799 vty_out(vty
, "attr[%ld] nexthop %pI4\n", attr
->refcnt
, &attr
->nexthop
);
802 if (attr
->srv6_l3vpn
)
803 inet_ntop(AF_INET6
, &attr
->srv6_l3vpn
->sid
, sid_str
, BUFSIZ
);
804 else if (attr
->srv6_vpn
)
805 inet_ntop(AF_INET6
, &attr
->srv6_vpn
->sid
, sid_str
, BUFSIZ
);
808 "\tflags: %" PRIu64
" distance: %u med: %u local_pref: %u origin: %u weight: %u label: %u sid: %s\n",
809 attr
->flag
, attr
->distance
, attr
->med
, attr
->local_pref
,
810 attr
->origin
, attr
->weight
, attr
->label
, sid_str
);
813 void attr_show_all(struct vty
*vty
)
815 hash_iterate(attrhash
, (void (*)(struct hash_bucket
*,
816 void *))attr_show_all_iterator
,
820 static void *bgp_attr_hash_alloc(void *p
)
822 struct attr
*val
= (struct attr
*)p
;
825 attr
= XMALLOC(MTYPE_ATTR
, sizeof(struct attr
));
827 if (val
->encap_subtlvs
) {
828 val
->encap_subtlvs
= NULL
;
830 #ifdef ENABLE_BGP_VNC
831 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
832 bgp_attr_get_vnc_subtlvs(val
);
835 bgp_attr_set_vnc_subtlvs(val
, NULL
);
838 val
->srv6_l3vpn
= NULL
;
840 val
->srv6_vpn
= NULL
;
846 /* Internet argument attribute. */
847 struct attr
*bgp_attr_intern(struct attr
*attr
)
850 struct ecommunity
*ecomm
;
852 /* Intern referenced strucutre. */
854 if (!attr
->aspath
->refcnt
)
855 attr
->aspath
= aspath_intern(attr
->aspath
);
857 attr
->aspath
->refcnt
++;
859 if (attr
->community
) {
860 if (!attr
->community
->refcnt
)
861 attr
->community
= community_intern(attr
->community
);
863 attr
->community
->refcnt
++;
866 if (attr
->ecommunity
) {
867 if (!attr
->ecommunity
->refcnt
)
868 attr
->ecommunity
= ecommunity_intern(attr
->ecommunity
);
870 attr
->ecommunity
->refcnt
++;
873 ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
876 bgp_attr_set_ipv6_ecommunity(attr
,
877 ecommunity_intern(ecomm
));
882 if (attr
->lcommunity
) {
883 if (!attr
->lcommunity
->refcnt
)
884 attr
->lcommunity
= lcommunity_intern(attr
->lcommunity
);
886 attr
->lcommunity
->refcnt
++;
889 struct cluster_list
*cluster
= bgp_attr_get_cluster(attr
);
892 if (!cluster
->refcnt
)
893 bgp_attr_set_cluster(attr
, cluster_intern(cluster
));
898 struct transit
*transit
= bgp_attr_get_transit(attr
);
901 if (!transit
->refcnt
)
902 bgp_attr_set_transit(attr
, transit_intern(transit
));
906 if (attr
->encap_subtlvs
) {
907 if (!attr
->encap_subtlvs
->refcnt
)
908 attr
->encap_subtlvs
= encap_intern(attr
->encap_subtlvs
,
911 attr
->encap_subtlvs
->refcnt
++;
913 if (attr
->srv6_l3vpn
) {
914 if (!attr
->srv6_l3vpn
->refcnt
)
915 attr
->srv6_l3vpn
= srv6_l3vpn_intern(attr
->srv6_l3vpn
);
917 attr
->srv6_l3vpn
->refcnt
++;
919 if (attr
->srv6_vpn
) {
920 if (!attr
->srv6_vpn
->refcnt
)
921 attr
->srv6_vpn
= srv6_vpn_intern(attr
->srv6_vpn
);
923 attr
->srv6_vpn
->refcnt
++;
925 #ifdef ENABLE_BGP_VNC
926 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
927 bgp_attr_get_vnc_subtlvs(attr
);
930 if (!vnc_subtlvs
->refcnt
)
931 bgp_attr_set_vnc_subtlvs(
933 encap_intern(vnc_subtlvs
, VNC_SUBTLV_TYPE
));
935 vnc_subtlvs
->refcnt
++;
939 /* At this point, attr only contains intern'd pointers. that means
940 * if we find it in attrhash, it has all the same pointers and we
941 * correctly updated the refcounts on these.
942 * If we don't find it, we need to allocate a one because in all
943 * cases this returns a new reference to a hashed attr, but the input
945 find
= (struct attr
*)hash_get(attrhash
, attr
, bgp_attr_hash_alloc
);
951 /* Make network statement's attribute. */
952 struct attr
*bgp_attr_default_set(struct attr
*attr
, uint8_t origin
)
954 memset(attr
, 0, sizeof(struct attr
));
956 attr
->origin
= origin
;
957 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
958 attr
->aspath
= aspath_empty();
959 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
960 attr
->weight
= BGP_ATTR_DEFAULT_WEIGHT
;
962 attr
->label_index
= BGP_INVALID_LABEL_INDEX
;
963 attr
->label
= MPLS_INVALID_LABEL
;
964 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
965 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
970 /* Create the attributes for an aggregate */
971 struct attr
*bgp_attr_aggregate_intern(
972 struct bgp
*bgp
, uint8_t origin
, struct aspath
*aspath
,
973 struct community
*community
, struct ecommunity
*ecommunity
,
974 struct lcommunity
*lcommunity
, struct bgp_aggregate
*aggregate
,
975 uint8_t atomic_aggregate
, const struct prefix
*p
)
981 memset(&attr
, 0, sizeof(struct attr
));
983 /* Origin attribute. */
984 attr
.origin
= origin
;
985 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
987 /* AS path attribute. */
989 attr
.aspath
= aspath_intern(aspath
);
991 attr
.aspath
= aspath_empty();
992 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
994 /* Next hop attribute. */
995 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
998 uint32_t gshut
= COMMUNITY_GSHUT
;
1000 /* If we are not shutting down ourselves and we are
1001 * aggregating a route that contains the GSHUT community we
1002 * need to remove that community when creating the aggregate */
1003 if (!bgp_in_graceful_shutdown(bgp
)
1004 && community_include(community
, gshut
)) {
1005 community_del_val(community
, &gshut
);
1008 attr
.community
= community
;
1009 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
);
1013 attr
.ecommunity
= ecommunity
;
1014 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
1018 attr
.lcommunity
= lcommunity
;
1019 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
);
1022 if (bgp_in_graceful_shutdown(bgp
))
1023 bgp_attr_add_gshut_community(&attr
);
1025 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1026 attr
.label
= MPLS_INVALID_LABEL
;
1027 attr
.weight
= BGP_ATTR_DEFAULT_WEIGHT
;
1028 attr
.mp_nexthop_len
= IPV6_MAX_BYTELEN
;
1029 if (!aggregate
->as_set
|| atomic_aggregate
)
1030 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
);
1031 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
);
1032 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
))
1033 attr
.aggregator_as
= bgp
->confed_id
;
1035 attr
.aggregator_as
= bgp
->as
;
1036 attr
.aggregator_addr
= bgp
->router_id
;
1037 attr
.label_index
= BGP_INVALID_LABEL_INDEX
;
1038 attr
.label
= MPLS_INVALID_LABEL
;
1040 /* Apply route-map */
1041 if (aggregate
->rmap
.name
) {
1042 struct attr attr_tmp
= attr
;
1043 struct bgp_path_info rmap_path
;
1045 memset(&rmap_path
, 0, sizeof(struct bgp_path_info
));
1046 rmap_path
.peer
= bgp
->peer_self
;
1047 rmap_path
.attr
= &attr_tmp
;
1049 SET_FLAG(bgp
->peer_self
->rmap_type
, PEER_RMAP_TYPE_AGGREGATE
);
1051 ret
= route_map_apply(aggregate
->rmap
.map
, p
, &rmap_path
);
1053 bgp
->peer_self
->rmap_type
= 0;
1055 if (ret
== RMAP_DENYMATCH
) {
1056 /* Free uninterned attribute. */
1057 bgp_attr_flush(&attr_tmp
);
1059 /* Unintern original. */
1060 aspath_unintern(&attr
.aspath
);
1064 if (bgp_in_graceful_shutdown(bgp
))
1065 bgp_attr_add_gshut_community(&attr_tmp
);
1067 new = bgp_attr_intern(&attr_tmp
);
1070 if (bgp_in_graceful_shutdown(bgp
))
1071 bgp_attr_add_gshut_community(&attr
);
1073 new = bgp_attr_intern(&attr
);
1076 /* Always release the 'intern()'ed AS Path. */
1077 aspath_unintern(&attr
.aspath
);
1082 /* Unintern just the sub-components of the attr, but not the attr */
1083 void bgp_attr_unintern_sub(struct attr
*attr
)
1085 struct ecommunity
*ecomm
;
1086 struct cluster_list
*cluster
;
1088 /* aspath refcount shoud be decrement. */
1090 aspath_unintern(&attr
->aspath
);
1091 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
));
1093 if (attr
->community
)
1094 community_unintern(&attr
->community
);
1095 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
));
1097 ecommunity_unintern(&attr
->ecommunity
);
1098 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
));
1100 ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
1101 ecommunity_unintern(&ecomm
);
1102 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_IPV6_EXT_COMMUNITIES
));
1103 bgp_attr_set_ipv6_ecommunity(attr
, NULL
);
1105 if (attr
->lcommunity
)
1106 lcommunity_unintern(&attr
->lcommunity
);
1107 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
));
1109 cluster
= bgp_attr_get_cluster(attr
);
1111 cluster_unintern(&cluster
);
1112 bgp_attr_set_cluster(attr
, cluster
);
1114 UNSET_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST
));
1116 struct transit
*transit
= bgp_attr_get_transit(attr
);
1119 transit_unintern(&transit
);
1120 bgp_attr_set_transit(attr
, transit
);
1123 if (attr
->encap_subtlvs
)
1124 encap_unintern(&attr
->encap_subtlvs
, ENCAP_SUBTLV_TYPE
);
1126 #ifdef ENABLE_BGP_VNC
1127 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
1128 bgp_attr_get_vnc_subtlvs(attr
);
1131 encap_unintern(&vnc_subtlvs
, VNC_SUBTLV_TYPE
);
1132 bgp_attr_set_vnc_subtlvs(attr
, vnc_subtlvs
);
1136 if (attr
->srv6_l3vpn
)
1137 srv6_l3vpn_unintern(&attr
->srv6_l3vpn
);
1140 srv6_vpn_unintern(&attr
->srv6_vpn
);
1144 * We have some show commands that let you experimentally
1145 * apply a route-map. When we apply the route-map
1146 * we are reseting values but not saving them for
1147 * posterity via intern'ing( because route-maps don't
1148 * do that) but at this point in time we need
1149 * to compare the new attr to the old and if the
1150 * routemap has changed it we need to, as Snoop Dog says,
1151 * Drop it like it's hot
1153 void bgp_attr_undup(struct attr
*new, struct attr
*old
)
1155 if (new->aspath
!= old
->aspath
)
1156 aspath_free(new->aspath
);
1158 if (new->community
!= old
->community
)
1159 community_free(&new->community
);
1161 if (new->ecommunity
!= old
->ecommunity
)
1162 ecommunity_free(&new->ecommunity
);
1164 if (new->lcommunity
!= old
->lcommunity
)
1165 lcommunity_free(&new->lcommunity
);
1167 if (new->srv6_l3vpn
!= old
->srv6_l3vpn
) {
1168 srv6_l3vpn_free(new->srv6_l3vpn
);
1169 new->srv6_l3vpn
= NULL
;
1172 if (new->srv6_vpn
!= old
->srv6_vpn
) {
1173 srv6_vpn_free(new->srv6_vpn
);
1174 new->srv6_vpn
= NULL
;
1178 /* Free bgp attribute and aspath. */
1179 void bgp_attr_unintern(struct attr
**pattr
)
1181 struct attr
*attr
= *pattr
;
1185 /* Decrement attribute reference. */
1190 /* If reference becomes zero then free attribute object. */
1191 if (attr
->refcnt
== 0) {
1192 ret
= hash_release(attrhash
, attr
);
1193 assert(ret
!= NULL
);
1194 XFREE(MTYPE_ATTR
, attr
);
1198 bgp_attr_unintern_sub(&tmp
);
1201 void bgp_attr_flush(struct attr
*attr
)
1203 struct ecommunity
*ecomm
;
1204 struct cluster_list
*cluster
;
1206 if (attr
->aspath
&& !attr
->aspath
->refcnt
) {
1207 aspath_free(attr
->aspath
);
1208 attr
->aspath
= NULL
;
1210 if (attr
->community
&& !attr
->community
->refcnt
)
1211 community_free(&attr
->community
);
1212 if (attr
->ecommunity
&& !attr
->ecommunity
->refcnt
)
1213 ecommunity_free(&attr
->ecommunity
);
1214 ecomm
= bgp_attr_get_ipv6_ecommunity(attr
);
1215 if (ecomm
&& !ecomm
->refcnt
)
1216 ecommunity_free(&ecomm
);
1217 bgp_attr_set_ipv6_ecommunity(attr
, NULL
);
1218 if (attr
->lcommunity
&& !attr
->lcommunity
->refcnt
)
1219 lcommunity_free(&attr
->lcommunity
);
1221 cluster
= bgp_attr_get_cluster(attr
);
1222 if (cluster
&& !cluster
->refcnt
) {
1223 cluster_free(cluster
);
1224 bgp_attr_set_cluster(attr
, NULL
);
1227 struct transit
*transit
= bgp_attr_get_transit(attr
);
1229 if (transit
&& !transit
->refcnt
) {
1230 transit_free(transit
);
1231 bgp_attr_set_transit(attr
, NULL
);
1233 if (attr
->encap_subtlvs
&& !attr
->encap_subtlvs
->refcnt
) {
1234 encap_free(attr
->encap_subtlvs
);
1235 attr
->encap_subtlvs
= NULL
;
1237 if (attr
->srv6_l3vpn
&& !attr
->srv6_l3vpn
->refcnt
) {
1238 srv6_l3vpn_free(attr
->srv6_l3vpn
);
1239 attr
->srv6_l3vpn
= NULL
;
1241 if (attr
->srv6_vpn
&& !attr
->srv6_vpn
->refcnt
) {
1242 srv6_vpn_free(attr
->srv6_vpn
);
1243 attr
->srv6_vpn
= NULL
;
1245 #ifdef ENABLE_BGP_VNC
1246 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
1247 bgp_attr_get_vnc_subtlvs(attr
);
1249 if (vnc_subtlvs
&& !vnc_subtlvs
->refcnt
) {
1250 encap_free(vnc_subtlvs
);
1251 bgp_attr_set_vnc_subtlvs(attr
, NULL
);
1256 /* Implement draft-scudder-idr-optional-transitive behaviour and
1257 * avoid resetting sessions for malformed attributes which are
1258 * are partial/optional and hence where the error likely was not
1259 * introduced by the sending neighbour.
1261 static bgp_attr_parse_ret_t
1262 bgp_attr_malformed(struct bgp_attr_parser_args
*args
, uint8_t subcode
,
1265 struct peer
*const peer
= args
->peer
;
1266 struct attr
*const attr
= args
->attr
;
1267 const uint8_t flags
= args
->flags
;
1268 /* startp and length must be special-cased, as whether or not to
1269 * send the attribute data with the NOTIFY depends on the error,
1270 * the caller therefore signals this with the seperate length argument
1272 uint8_t *notify_datap
= (length
> 0 ? args
->startp
: NULL
);
1274 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1275 char attr_str
[BUFSIZ
] = {0};
1277 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1279 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1282 /* Only relax error handling for eBGP peers */
1283 if (peer
->sort
!= BGP_PEER_EBGP
) {
1284 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
, subcode
,
1285 notify_datap
, length
);
1286 return BGP_ATTR_PARSE_ERROR
;
1289 /* Adjust the stream getp to the end of the attribute, in case we can
1290 * still proceed but the caller hasn't read all the attribute.
1292 stream_set_getp(BGP_INPUT(peer
),
1293 (args
->startp
- STREAM_DATA(BGP_INPUT(peer
)))
1296 switch (args
->type
) {
1297 /* where an attribute is relatively inconsequential, e.g. it does not
1298 * affect route selection, and can be safely ignored, then any such
1299 * attributes which are malformed should just be ignored and the route
1300 * processed as normal.
1302 case BGP_ATTR_AS4_AGGREGATOR
:
1303 case BGP_ATTR_AGGREGATOR
:
1304 case BGP_ATTR_ATOMIC_AGGREGATE
:
1305 return BGP_ATTR_PARSE_PROCEED
;
1307 /* Core attributes, particularly ones which may influence route
1308 * selection, should be treat-as-withdraw.
1310 case BGP_ATTR_ORIGIN
:
1311 case BGP_ATTR_AS_PATH
:
1312 case BGP_ATTR_NEXT_HOP
:
1313 case BGP_ATTR_MULTI_EXIT_DISC
:
1314 case BGP_ATTR_LOCAL_PREF
:
1315 case BGP_ATTR_COMMUNITIES
:
1316 case BGP_ATTR_EXT_COMMUNITIES
:
1317 case BGP_ATTR_IPV6_EXT_COMMUNITIES
:
1318 case BGP_ATTR_LARGE_COMMUNITIES
:
1319 case BGP_ATTR_ORIGINATOR_ID
:
1320 case BGP_ATTR_CLUSTER_LIST
:
1321 return BGP_ATTR_PARSE_WITHDRAW
;
1322 case BGP_ATTR_MP_REACH_NLRI
:
1323 case BGP_ATTR_MP_UNREACH_NLRI
:
1324 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
, subcode
,
1325 notify_datap
, length
);
1326 return BGP_ATTR_PARSE_ERROR
;
1329 /* Partial optional attributes that are malformed should not cause
1330 * the whole session to be reset. Instead treat it as a withdrawal
1331 * of the routes, if possible.
1333 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
)
1334 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1335 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_PARTIAL
))
1336 return BGP_ATTR_PARSE_WITHDRAW
;
1338 /* default to reset */
1339 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
1342 /* Find out what is wrong with the path attribute flag bits and log the error.
1343 "Flag bits" here stand for Optional, Transitive and Partial, but not for
1344 Extended Length. Checking O/T/P bits at once implies, that the attribute
1345 being diagnosed is defined by RFC as either a "well-known" or an "optional,
1346 non-transitive" attribute. */
1348 bgp_attr_flags_diagnose(struct bgp_attr_parser_args
*args
,
1349 uint8_t desired_flags
/* how RFC says it must be */
1352 uint8_t seen
= 0, i
;
1353 uint8_t real_flags
= args
->flags
;
1354 const uint8_t attr_code
= args
->type
;
1356 desired_flags
&= ~BGP_ATTR_FLAG_EXTLEN
;
1357 real_flags
&= ~BGP_ATTR_FLAG_EXTLEN
;
1358 for (i
= 0; i
<= 2; i
++) /* O,T,P, but not E */
1359 if (CHECK_FLAG(desired_flags
, attr_flag_str
[i
].key
)
1360 != CHECK_FLAG(real_flags
, attr_flag_str
[i
].key
)) {
1361 flog_err(EC_BGP_ATTR_FLAG
,
1362 "%s attribute must%s be flagged as \"%s\"",
1363 lookup_msg(attr_str
, attr_code
, NULL
),
1364 CHECK_FLAG(desired_flags
, attr_flag_str
[i
].key
)
1367 attr_flag_str
[i
].str
);
1372 "Strange, %s called for attr %s, but no problem found with flags (real flags 0x%x, desired 0x%x)",
1373 __func__
, lookup_msg(attr_str
, attr_code
, NULL
),
1374 real_flags
, desired_flags
);
1378 /* Required flags for attributes. EXTLEN will be masked off when testing,
1379 * as will PARTIAL for optional+transitive attributes.
1381 const uint8_t attr_flags_values
[] = {
1382 [BGP_ATTR_ORIGIN
] = BGP_ATTR_FLAG_TRANS
,
1383 [BGP_ATTR_AS_PATH
] = BGP_ATTR_FLAG_TRANS
,
1384 [BGP_ATTR_NEXT_HOP
] = BGP_ATTR_FLAG_TRANS
,
1385 [BGP_ATTR_MULTI_EXIT_DISC
] = BGP_ATTR_FLAG_OPTIONAL
,
1386 [BGP_ATTR_LOCAL_PREF
] = BGP_ATTR_FLAG_TRANS
,
1387 [BGP_ATTR_ATOMIC_AGGREGATE
] = BGP_ATTR_FLAG_TRANS
,
1388 [BGP_ATTR_AGGREGATOR
] = BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
,
1389 [BGP_ATTR_COMMUNITIES
] = BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
,
1390 [BGP_ATTR_ORIGINATOR_ID
] = BGP_ATTR_FLAG_OPTIONAL
,
1391 [BGP_ATTR_CLUSTER_LIST
] = BGP_ATTR_FLAG_OPTIONAL
,
1392 [BGP_ATTR_MP_REACH_NLRI
] = BGP_ATTR_FLAG_OPTIONAL
,
1393 [BGP_ATTR_MP_UNREACH_NLRI
] = BGP_ATTR_FLAG_OPTIONAL
,
1394 [BGP_ATTR_EXT_COMMUNITIES
] =
1395 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1396 [BGP_ATTR_AS4_PATH
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1397 [BGP_ATTR_AS4_AGGREGATOR
] =
1398 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1399 [BGP_ATTR_PMSI_TUNNEL
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1400 [BGP_ATTR_LARGE_COMMUNITIES
] =
1401 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1402 [BGP_ATTR_PREFIX_SID
] = BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1403 [BGP_ATTR_IPV6_EXT_COMMUNITIES
] =
1404 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
,
1406 static const size_t attr_flags_values_max
= array_size(attr_flags_values
) - 1;
1408 static bool bgp_attr_flag_invalid(struct bgp_attr_parser_args
*args
)
1410 uint8_t mask
= BGP_ATTR_FLAG_EXTLEN
;
1411 const uint8_t flags
= args
->flags
;
1412 const uint8_t attr_code
= args
->type
;
1414 /* there may be attributes we don't know about */
1415 if (attr_code
> attr_flags_values_max
)
1417 if (attr_flags_values
[attr_code
] == 0)
1420 /* RFC4271, "For well-known attributes, the Transitive bit MUST be set
1424 if (!CHECK_FLAG(BGP_ATTR_FLAG_OPTIONAL
, flags
)
1425 && !CHECK_FLAG(BGP_ATTR_FLAG_TRANS
, flags
)) {
1428 "%s well-known attributes must have transitive flag set (%x)",
1429 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1433 /* "For well-known attributes and for optional non-transitive
1435 * the Partial bit MUST be set to 0."
1437 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_PARTIAL
)) {
1438 if (!CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)) {
1439 flog_err(EC_BGP_ATTR_FLAG
,
1440 "%s well-known attribute must NOT have the partial flag set (%x)",
1441 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1444 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1445 && !CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
)) {
1446 flog_err(EC_BGP_ATTR_FLAG
,
1447 "%s optional + transitive attribute must NOT have the partial flag set (%x)",
1448 lookup_msg(attr_str
, attr_code
, NULL
), flags
);
1453 /* Optional transitive attributes may go through speakers that don't
1454 * reocgnise them and set the Partial bit.
1456 if (CHECK_FLAG(flags
, BGP_ATTR_FLAG_OPTIONAL
)
1457 && CHECK_FLAG(flags
, BGP_ATTR_FLAG_TRANS
))
1458 SET_FLAG(mask
, BGP_ATTR_FLAG_PARTIAL
);
1460 if ((flags
& ~mask
) == attr_flags_values
[attr_code
])
1463 bgp_attr_flags_diagnose(args
, attr_flags_values
[attr_code
]);
1467 /* Get origin attribute of the update message. */
1468 static bgp_attr_parse_ret_t
bgp_attr_origin(struct bgp_attr_parser_args
*args
)
1470 struct peer
*const peer
= args
->peer
;
1471 struct attr
*const attr
= args
->attr
;
1472 const bgp_size_t length
= args
->length
;
1474 /* If any recognized attribute has Attribute Length that conflicts
1475 with the expected length (based on the attribute type code), then
1476 the Error Subcode is set to Attribute Length Error. The Data
1477 field contains the erroneous attribute (type, length and
1480 flog_err(EC_BGP_ATTR_LEN
,
1481 "Origin attribute length is not one %d", length
);
1482 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1486 /* Fetch origin attribute. */
1487 attr
->origin
= stream_getc(BGP_INPUT(peer
));
1489 /* If the ORIGIN attribute has an undefined value, then the Error
1490 Subcode is set to Invalid Origin Attribute. The Data field
1491 contains the unrecognized attribute (type, length and value). */
1492 if ((attr
->origin
!= BGP_ORIGIN_IGP
) && (attr
->origin
!= BGP_ORIGIN_EGP
)
1493 && (attr
->origin
!= BGP_ORIGIN_INCOMPLETE
)) {
1494 flog_err(EC_BGP_ATTR_ORIGIN
,
1495 "Origin attribute value is invalid %d", attr
->origin
);
1496 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_INVAL_ORIGIN
,
1500 /* Set oring attribute flag. */
1501 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
);
1506 /* Parse AS path information. This function is wrapper of
1508 static int bgp_attr_aspath(struct bgp_attr_parser_args
*args
)
1510 struct attr
*const attr
= args
->attr
;
1511 struct peer
*const peer
= args
->peer
;
1512 const bgp_size_t length
= args
->length
;
1515 * peer with AS4 => will get 4Byte ASnums
1516 * otherwise, will get 16 Bit
1518 attr
->aspath
= aspath_parse(
1520 CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1521 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
));
1523 /* In case of IBGP, length will be zero. */
1524 if (!attr
->aspath
) {
1525 flog_err(EC_BGP_ATTR_MAL_AS_PATH
,
1526 "Malformed AS path from %s, length is %d", peer
->host
,
1528 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1532 /* Set aspath attribute flag. */
1533 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
);
1535 return BGP_ATTR_PARSE_PROCEED
;
1538 static bgp_attr_parse_ret_t
bgp_attr_aspath_check(struct peer
*const peer
,
1539 struct attr
*const attr
)
1541 /* These checks were part of bgp_attr_aspath, but with
1542 * as4 we should to check aspath things when
1543 * aspath synthesizing with as4_path has already taken place.
1544 * Otherwise we check ASPATH and use the synthesized thing, and that is
1546 * So do the checks later, i.e. here
1548 struct aspath
*aspath
;
1550 /* Confederation sanity check. */
1551 if ((peer
->sort
== BGP_PEER_CONFED
1552 && !aspath_left_confed_check(attr
->aspath
))
1553 || (peer
->sort
== BGP_PEER_EBGP
1554 && aspath_confed_check(attr
->aspath
))) {
1555 flog_err(EC_BGP_ATTR_MAL_AS_PATH
, "Malformed AS path from %s",
1557 return BGP_ATTR_PARSE_WITHDRAW
;
1560 /* First AS check for EBGP. */
1561 if (CHECK_FLAG(peer
->flags
, PEER_FLAG_ENFORCE_FIRST_AS
)) {
1562 if (peer
->sort
== BGP_PEER_EBGP
1563 && !aspath_firstas_check(attr
->aspath
, peer
->as
)) {
1564 flog_err(EC_BGP_ATTR_FIRST_AS
,
1565 "%s incorrect first AS (must be %u)",
1566 peer
->host
, peer
->as
);
1567 return BGP_ATTR_PARSE_WITHDRAW
;
1571 /* Codification of AS 0 Processing */
1572 if (peer
->sort
== BGP_PEER_EBGP
&& aspath_check_as_zero(attr
->aspath
)) {
1574 EC_BGP_ATTR_MAL_AS_PATH
,
1575 "Malformed AS path, AS number is 0 in the path from %s",
1577 return BGP_ATTR_PARSE_WITHDRAW
;
1580 /* local-as prepend */
1581 if (peer
->change_local_as
1582 && !CHECK_FLAG(peer
->flags
, PEER_FLAG_LOCAL_AS_NO_PREPEND
)) {
1583 aspath
= aspath_dup(attr
->aspath
);
1584 aspath
= aspath_add_seq(aspath
, peer
->change_local_as
);
1585 aspath_unintern(&attr
->aspath
);
1586 attr
->aspath
= aspath_intern(aspath
);
1589 return BGP_ATTR_PARSE_PROCEED
;
1592 /* Parse AS4 path information. This function is another wrapper of
1594 static int bgp_attr_as4_path(struct bgp_attr_parser_args
*args
,
1595 struct aspath
**as4_path
)
1597 struct peer
*const peer
= args
->peer
;
1598 struct attr
*const attr
= args
->attr
;
1599 const bgp_size_t length
= args
->length
;
1601 *as4_path
= aspath_parse(peer
->curr
, length
, 1);
1603 /* In case of IBGP, length will be zero. */
1605 flog_err(EC_BGP_ATTR_MAL_AS_PATH
,
1606 "Malformed AS4 path from %s, length is %d", peer
->host
,
1608 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_MAL_AS_PATH
,
1612 /* Set aspath attribute flag. */
1613 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
);
1615 return BGP_ATTR_PARSE_PROCEED
;
1619 * Check that the nexthop attribute is valid.
1621 bgp_attr_parse_ret_t
1622 bgp_attr_nexthop_valid(struct peer
*peer
, struct attr
*attr
)
1624 in_addr_t nexthop_h
;
1626 nexthop_h
= ntohl(attr
->nexthop
.s_addr
);
1627 if ((IPV4_NET0(nexthop_h
) || IPV4_NET127(nexthop_h
)
1628 || IPV4_CLASS_DE(nexthop_h
))
1629 && !BGP_DEBUG(allow_martians
, ALLOW_MARTIANS
)) {
1630 uint8_t data
[7]; /* type(2) + length(1) + nhop(4) */
1631 char buf
[INET_ADDRSTRLEN
];
1633 inet_ntop(AF_INET
, &attr
->nexthop
.s_addr
, buf
,
1635 flog_err(EC_BGP_ATTR_MARTIAN_NH
, "Martian nexthop %s",
1637 data
[0] = BGP_ATTR_FLAG_TRANS
;
1638 data
[1] = BGP_ATTR_NEXT_HOP
;
1639 data
[2] = BGP_ATTR_NHLEN_IPV4
;
1640 memcpy(&data
[3], &attr
->nexthop
.s_addr
, BGP_ATTR_NHLEN_IPV4
);
1641 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
1642 BGP_NOTIFY_UPDATE_INVAL_NEXT_HOP
,
1644 return BGP_ATTR_PARSE_ERROR
;
1647 return BGP_ATTR_PARSE_PROCEED
;
1650 /* Nexthop attribute. */
1651 static bgp_attr_parse_ret_t
bgp_attr_nexthop(struct bgp_attr_parser_args
*args
)
1653 struct peer
*const peer
= args
->peer
;
1654 struct attr
*const attr
= args
->attr
;
1655 const bgp_size_t length
= args
->length
;
1657 /* Check nexthop attribute length. */
1659 flog_err(EC_BGP_ATTR_LEN
,
1660 "Nexthop attribute length isn't four [%d]", length
);
1662 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1666 attr
->nexthop
.s_addr
= stream_get_ipv4(peer
->curr
);
1667 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
1669 return BGP_ATTR_PARSE_PROCEED
;
1672 /* MED atrribute. */
1673 static bgp_attr_parse_ret_t
bgp_attr_med(struct bgp_attr_parser_args
*args
)
1675 struct peer
*const peer
= args
->peer
;
1676 struct attr
*const attr
= args
->attr
;
1677 const bgp_size_t length
= args
->length
;
1681 flog_err(EC_BGP_ATTR_LEN
,
1682 "MED attribute length isn't four [%d]", length
);
1684 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1688 attr
->med
= stream_getl(peer
->curr
);
1690 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
);
1692 return BGP_ATTR_PARSE_PROCEED
;
1695 /* Local preference attribute. */
1696 static bgp_attr_parse_ret_t
1697 bgp_attr_local_pref(struct bgp_attr_parser_args
*args
)
1699 struct peer
*const peer
= args
->peer
;
1700 struct attr
*const attr
= args
->attr
;
1701 const bgp_size_t length
= args
->length
;
1703 /* if received from an internal neighbor, it SHALL be considered
1704 * malformed if its length is not equal to 4. If malformed, the
1705 * UPDATE message SHALL be handled using the approach of "treat-as-
1708 if (peer
->sort
== BGP_PEER_IBGP
&& length
!= 4) {
1709 flog_err(EC_BGP_ATTR_LEN
,
1710 "LOCAL_PREF attribute length isn't 4 [%u]", length
);
1711 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1715 /* If it is contained in an UPDATE message that is received from an
1716 external peer, then this attribute MUST be ignored by the
1717 receiving speaker. */
1718 if (peer
->sort
== BGP_PEER_EBGP
) {
1719 STREAM_FORWARD_GETP(peer
->curr
, length
);
1720 return BGP_ATTR_PARSE_PROCEED
;
1723 STREAM_GETL(peer
->curr
, attr
->local_pref
);
1725 /* Set the local-pref flag. */
1726 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
);
1728 return BGP_ATTR_PARSE_PROCEED
;
1731 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1735 /* Atomic aggregate. */
1736 static int bgp_attr_atomic(struct bgp_attr_parser_args
*args
)
1738 struct attr
*const attr
= args
->attr
;
1739 const bgp_size_t length
= args
->length
;
1743 flog_err(EC_BGP_ATTR_LEN
,
1744 "ATOMIC_AGGREGATE attribute length isn't 0 [%u]",
1746 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1750 /* Set atomic aggregate flag. */
1751 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
);
1753 return BGP_ATTR_PARSE_PROCEED
;
1756 /* Aggregator attribute */
1757 static int bgp_attr_aggregator(struct bgp_attr_parser_args
*args
)
1759 struct peer
*const peer
= args
->peer
;
1760 struct attr
*const attr
= args
->attr
;
1761 const bgp_size_t length
= args
->length
;
1766 /* peer with AS4 will send 4 Byte AS, peer without will send 2 Byte */
1767 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
1768 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
))
1771 if (length
!= wantedlen
) {
1772 flog_err(EC_BGP_ATTR_LEN
,
1773 "AGGREGATOR attribute length isn't %u [%u]", wantedlen
,
1775 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1779 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
))
1780 aggregator_as
= stream_getl(peer
->curr
);
1782 aggregator_as
= stream_getw(peer
->curr
);
1784 attr
->aggregator_as
= aggregator_as
;
1785 attr
->aggregator_addr
.s_addr
= stream_get_ipv4(peer
->curr
);
1787 /* Codification of AS 0 Processing */
1788 if (aggregator_as
== BGP_AS_ZERO
) {
1789 flog_err(EC_BGP_ATTR_LEN
,
1790 "%s: AGGREGATOR AS number is 0 for aspath: %s",
1791 peer
->host
, aspath_print(attr
->aspath
));
1793 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1794 char attr_str
[BUFSIZ
] = {0};
1796 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1798 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1801 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
);
1804 return BGP_ATTR_PARSE_PROCEED
;
1807 /* New Aggregator attribute */
1808 static bgp_attr_parse_ret_t
1809 bgp_attr_as4_aggregator(struct bgp_attr_parser_args
*args
,
1810 as_t
*as4_aggregator_as
,
1811 struct in_addr
*as4_aggregator_addr
)
1813 struct peer
*const peer
= args
->peer
;
1814 struct attr
*const attr
= args
->attr
;
1815 const bgp_size_t length
= args
->length
;
1819 flog_err(EC_BGP_ATTR_LEN
, "New Aggregator length is not 8 [%d]",
1821 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
1825 aggregator_as
= stream_getl(peer
->curr
);
1827 *as4_aggregator_as
= aggregator_as
;
1828 as4_aggregator_addr
->s_addr
= stream_get_ipv4(peer
->curr
);
1830 /* Codification of AS 0 Processing */
1831 if (aggregator_as
== BGP_AS_ZERO
) {
1832 flog_err(EC_BGP_ATTR_LEN
,
1833 "%s: AS4_AGGREGATOR AS number is 0 for aspath: %s",
1834 peer
->host
, aspath_print(attr
->aspath
));
1836 if (bgp_debug_update(peer
, NULL
, NULL
, 1)) {
1837 char attr_str
[BUFSIZ
] = {0};
1839 bgp_dump_attr(attr
, attr_str
, sizeof(attr_str
));
1841 zlog_debug("%s: attributes: %s", __func__
, attr_str
);
1844 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
);
1847 return BGP_ATTR_PARSE_PROCEED
;
1850 /* Munge Aggregator and New-Aggregator, AS_PATH and NEW_AS_PATH.
1852 static bgp_attr_parse_ret_t
1853 bgp_attr_munge_as4_attrs(struct peer
*const peer
, struct attr
*const attr
,
1854 struct aspath
*as4_path
, as_t as4_aggregator
,
1855 struct in_addr
*as4_aggregator_addr
)
1857 int ignore_as4_path
= 0;
1858 struct aspath
*newpath
;
1860 if (!attr
->aspath
) {
1861 /* NULL aspath shouldn't be possible as bgp_attr_parse should
1863 * checked that all well-known, mandatory attributes were
1866 * Can only be a problem with peer itself - hard error
1868 return BGP_ATTR_PARSE_ERROR
;
1871 if (CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)) {
1872 /* peer can do AS4, so we ignore AS4_PATH and AS4_AGGREGATOR
1874 * It is worth a warning though, because the peer really
1875 * should not send them
1877 if (BGP_DEBUG(as4
, AS4
)) {
1878 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
)))
1879 zlog_debug("[AS4] %s %s AS4_PATH", peer
->host
,
1880 "AS4 capable peer, yet it sent");
1883 & (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
)))
1884 zlog_debug("[AS4] %s %s AS4_AGGREGATOR",
1886 "AS4 capable peer, yet it sent");
1889 return BGP_ATTR_PARSE_PROCEED
;
1892 /* We have a asn16 peer. First, look for AS4_AGGREGATOR
1893 * because that may override AS4_PATH
1895 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_AGGREGATOR
))) {
1896 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
))) {
1898 * if the as_number in aggregator is not AS_TRANS,
1899 * then AS4_AGGREGATOR and AS4_PATH shall be ignored
1900 * and the Aggregator shall be taken as
1901 * info on the aggregating node, and the AS_PATH
1902 * shall be taken as the AS_PATH
1904 * the Aggregator shall be ignored and the
1905 * AS4_AGGREGATOR shall be taken as the
1906 * Aggregating node and the AS_PATH is to be
1907 * constructed "as in all other cases"
1909 if (attr
->aggregator_as
!= BGP_AS_TRANS
) {
1911 if (BGP_DEBUG(as4
, AS4
))
1913 "[AS4] %s BGP not AS4 capable peer send AGGREGATOR != AS_TRANS and AS4_AGGREGATOR, so ignore AS4_AGGREGATOR and AS4_PATH",
1915 ignore_as4_path
= 1;
1917 /* "New_aggregator shall be taken as aggregator"
1919 attr
->aggregator_as
= as4_aggregator
;
1920 attr
->aggregator_addr
.s_addr
=
1921 as4_aggregator_addr
->s_addr
;
1924 /* We received a AS4_AGGREGATOR but no AGGREGATOR.
1925 * That is bogus - but reading the conditions
1926 * we have to handle AS4_AGGREGATOR as if it were
1927 * AGGREGATOR in that case
1929 if (BGP_DEBUG(as4
, AS4
))
1931 "[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",
1933 attr
->aggregator_as
= as4_aggregator
;
1934 /* sweep it under the carpet and simulate a "good"
1936 attr
->flag
|= (ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
));
1940 /* need to reconcile NEW_AS_PATH and AS_PATH */
1941 if (!ignore_as4_path
1942 && (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS4_PATH
)))) {
1943 newpath
= aspath_reconcile_as4(attr
->aspath
, as4_path
);
1945 return BGP_ATTR_PARSE_ERROR
;
1947 aspath_unintern(&attr
->aspath
);
1948 attr
->aspath
= aspath_intern(newpath
);
1950 return BGP_ATTR_PARSE_PROCEED
;
1953 /* Community attribute. */
1954 static bgp_attr_parse_ret_t
1955 bgp_attr_community(struct bgp_attr_parser_args
*args
)
1957 struct peer
*const peer
= args
->peer
;
1958 struct attr
*const attr
= args
->attr
;
1959 const bgp_size_t length
= args
->length
;
1962 attr
->community
= NULL
;
1963 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
1968 community_parse((uint32_t *)stream_pnt(peer
->curr
), length
);
1970 /* XXX: fix community_parse to use stream API and remove this */
1971 stream_forward_getp(peer
->curr
, length
);
1973 /* The Community attribute SHALL be considered malformed if its
1974 * length is not a non-zero multiple of 4.
1976 if (!attr
->community
)
1977 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
1980 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
);
1982 return BGP_ATTR_PARSE_PROCEED
;
1985 /* Originator ID attribute. */
1986 static bgp_attr_parse_ret_t
1987 bgp_attr_originator_id(struct bgp_attr_parser_args
*args
)
1989 struct peer
*const peer
= args
->peer
;
1990 struct attr
*const attr
= args
->attr
;
1991 const bgp_size_t length
= args
->length
;
1993 /* if received from an internal neighbor, it SHALL be considered
1994 * malformed if its length is not equal to 4. If malformed, the
1995 * UPDATE message SHALL be handled using the approach of "treat-as-
1999 flog_err(EC_BGP_ATTR_LEN
, "Bad originator ID length %d",
2002 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2006 attr
->originator_id
.s_addr
= stream_get_ipv4(peer
->curr
);
2008 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
);
2010 return BGP_ATTR_PARSE_PROCEED
;
2013 /* Cluster list attribute. */
2014 static bgp_attr_parse_ret_t
2015 bgp_attr_cluster_list(struct bgp_attr_parser_args
*args
)
2017 struct peer
*const peer
= args
->peer
;
2018 struct attr
*const attr
= args
->attr
;
2019 const bgp_size_t length
= args
->length
;
2021 /* if received from an internal neighbor, it SHALL be considered
2022 * malformed if its length is not a non-zero multiple of 4. If
2023 * malformed, the UPDATE message SHALL be handled using the approach
2024 * of "treat-as-withdraw".
2026 if (length
== 0 || length
% 4) {
2027 flog_err(EC_BGP_ATTR_LEN
, "Bad cluster list length %d", length
);
2029 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2033 bgp_attr_set_cluster(
2034 attr
, cluster_parse((struct in_addr
*)stream_pnt(peer
->curr
),
2037 /* XXX: Fix cluster_parse to use stream API and then remove this */
2038 stream_forward_getp(peer
->curr
, length
);
2040 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_CLUSTER_LIST
);
2042 return BGP_ATTR_PARSE_PROCEED
;
2045 /* Multiprotocol reachability information parse. */
2046 int bgp_mp_reach_parse(struct bgp_attr_parser_args
*args
,
2047 struct bgp_nlri
*mp_update
)
2051 iana_safi_t pkt_safi
;
2053 bgp_size_t nlri_len
;
2056 struct peer
*const peer
= args
->peer
;
2057 struct attr
*const attr
= args
->attr
;
2058 const bgp_size_t length
= args
->length
;
2060 /* Set end of packet. */
2061 s
= BGP_INPUT(peer
);
2062 start
= stream_get_getp(s
);
2064 /* safe to read statically sized header? */
2065 #define BGP_MP_REACH_MIN_SIZE 5
2066 #define LEN_LEFT (length - (stream_get_getp(s) - start))
2067 if ((length
> STREAM_READABLE(s
)) || (length
< BGP_MP_REACH_MIN_SIZE
)) {
2068 zlog_info("%s: %s sent invalid length, %lu, of MP_REACH_NLRI",
2069 __func__
, peer
->host
, (unsigned long)length
);
2070 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2073 /* Load AFI, SAFI. */
2074 pkt_afi
= stream_getw(s
);
2075 pkt_safi
= stream_getc(s
);
2077 /* Convert AFI, SAFI to internal values, check. */
2078 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
2079 /* Log if AFI or SAFI is unrecognized. This is not an error
2081 * the attribute is otherwise malformed.
2083 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
2085 "%s sent unrecognizable AFI, %s or, SAFI, %s, of MP_REACH_NLRI",
2086 peer
->host
, iana_afi2str(pkt_afi
),
2087 iana_safi2str(pkt_safi
));
2088 return BGP_ATTR_PARSE_ERROR
;
2091 /* Get nexthop length. */
2092 attr
->mp_nexthop_len
= stream_getc(s
);
2094 if (LEN_LEFT
< attr
->mp_nexthop_len
) {
2096 "%s: %s sent next-hop length, %u, in MP_REACH_NLRI which goes past the end of attribute",
2097 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2098 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2101 /* Nexthop length check. */
2102 switch (attr
->mp_nexthop_len
) {
2104 if (safi
!= SAFI_FLOWSPEC
) {
2105 zlog_info("%s: %s sent wrong next-hop length, %d, in MP_REACH_NLRI",
2106 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2107 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2110 case BGP_ATTR_NHLEN_VPNV4
:
2111 stream_getl(s
); /* RD high */
2112 stream_getl(s
); /* RD low */
2114 * NOTE: intentional fall through
2115 * - for consistency in rx processing
2117 * The following comment is to signal GCC this intention
2118 * and suppress the warning
2121 case BGP_ATTR_NHLEN_IPV4
:
2122 stream_get(&attr
->mp_nexthop_global_in
, s
, IPV4_MAX_BYTELEN
);
2123 /* Probably needed for RFC 2283 */
2124 if (attr
->nexthop
.s_addr
== INADDR_ANY
)
2125 memcpy(&attr
->nexthop
.s_addr
,
2126 &attr
->mp_nexthop_global_in
, IPV4_MAX_BYTELEN
);
2128 case BGP_ATTR_NHLEN_IPV6_GLOBAL
:
2129 case BGP_ATTR_NHLEN_VPNV6_GLOBAL
:
2130 if (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_VPNV6_GLOBAL
) {
2131 stream_getl(s
); /* RD high */
2132 stream_getl(s
); /* RD low */
2134 stream_get(&attr
->mp_nexthop_global
, s
, IPV6_MAX_BYTELEN
);
2135 if (IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_global
)) {
2136 if (!peer
->nexthop
.ifp
) {
2137 zlog_warn("%s sent a v6 global attribute but address is a V6 LL and there's no peer interface information. Hence, withdrawing",
2139 return BGP_ATTR_PARSE_WITHDRAW
;
2141 attr
->nh_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2144 case BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
:
2145 case BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
:
2146 if (attr
->mp_nexthop_len
2147 == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
) {
2148 stream_getl(s
); /* RD high */
2149 stream_getl(s
); /* RD low */
2151 stream_get(&attr
->mp_nexthop_global
, s
, IPV6_MAX_BYTELEN
);
2152 if (IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_global
)) {
2153 if (!peer
->nexthop
.ifp
) {
2154 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",
2156 return BGP_ATTR_PARSE_WITHDRAW
;
2158 attr
->nh_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2160 if (attr
->mp_nexthop_len
2161 == BGP_ATTR_NHLEN_VPNV6_GLOBAL_AND_LL
) {
2162 stream_getl(s
); /* RD high */
2163 stream_getl(s
); /* RD low */
2165 stream_get(&attr
->mp_nexthop_local
, s
, IPV6_MAX_BYTELEN
);
2166 if (!IN6_IS_ADDR_LINKLOCAL(&attr
->mp_nexthop_local
)) {
2167 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2169 "%s sent next-hops %pI6 and %pI6. Ignoring non-LL value",
2170 peer
->host
, &attr
->mp_nexthop_global
,
2171 &attr
->mp_nexthop_local
);
2173 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
2175 if (!peer
->nexthop
.ifp
) {
2176 zlog_warn("%s sent a v6 LL next-hop and there's no peer interface information. Hence, withdrawing",
2178 return BGP_ATTR_PARSE_WITHDRAW
;
2180 attr
->nh_lla_ifindex
= peer
->nexthop
.ifp
->ifindex
;
2183 zlog_info("%s: %s sent wrong next-hop length, %d, in MP_REACH_NLRI",
2184 __func__
, peer
->host
, attr
->mp_nexthop_len
);
2185 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2189 zlog_info("%s: %s sent SNPA which couldn't be read",
2190 __func__
, peer
->host
);
2191 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2196 if ((val
= stream_getc(s
)))
2198 EC_BGP_DEFUNCT_SNPA_LEN
,
2199 "%s sent non-zero value, %u, for defunct SNPA-length field",
2203 /* must have nrli_len, what is left of the attribute */
2204 nlri_len
= LEN_LEFT
;
2205 if (nlri_len
> STREAM_READABLE(s
)) {
2206 zlog_info("%s: %s sent MP_REACH_NLRI which couldn't be read",
2207 __func__
, peer
->host
);
2208 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2212 zlog_info("%s: %s sent a zero-length NLRI. Hence, treating as a EOR marker",
2213 __func__
, peer
->host
);
2215 mp_update
->afi
= afi
;
2216 mp_update
->safi
= safi
;
2217 return BGP_ATTR_PARSE_EOR
;
2220 mp_update
->afi
= afi
;
2221 mp_update
->safi
= safi
;
2222 mp_update
->nlri
= stream_pnt(s
);
2223 mp_update
->length
= nlri_len
;
2225 stream_forward_getp(s
, nlri_len
);
2227 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
);
2229 return BGP_ATTR_PARSE_PROCEED
;
2233 /* Multiprotocol unreachable parse */
2234 int bgp_mp_unreach_parse(struct bgp_attr_parser_args
*args
,
2235 struct bgp_nlri
*mp_withdraw
)
2240 iana_safi_t pkt_safi
;
2242 uint16_t withdraw_len
;
2243 struct peer
*const peer
= args
->peer
;
2244 struct attr
*const attr
= args
->attr
;
2245 const bgp_size_t length
= args
->length
;
2249 #define BGP_MP_UNREACH_MIN_SIZE 3
2250 if ((length
> STREAM_READABLE(s
)) || (length
< BGP_MP_UNREACH_MIN_SIZE
))
2251 return BGP_ATTR_PARSE_ERROR_NOTIFYPLS
;
2253 pkt_afi
= stream_getw(s
);
2254 pkt_safi
= stream_getc(s
);
2256 /* Convert AFI, SAFI to internal values, check. */
2257 if (bgp_map_afi_safi_iana2int(pkt_afi
, pkt_safi
, &afi
, &safi
)) {
2258 /* Log if AFI or SAFI is unrecognized. This is not an error
2260 * the attribute is otherwise malformed.
2262 if (bgp_debug_update(peer
, NULL
, NULL
, 0))
2264 "%s: MP_UNREACH received AFI %s or SAFI %s is unrecognized",
2265 peer
->host
, iana_afi2str(pkt_afi
),
2266 iana_safi2str(pkt_safi
));
2267 return BGP_ATTR_PARSE_ERROR
;
2270 withdraw_len
= length
- BGP_MP_UNREACH_MIN_SIZE
;
2272 mp_withdraw
->afi
= afi
;
2273 mp_withdraw
->safi
= safi
;
2274 mp_withdraw
->nlri
= stream_pnt(s
);
2275 mp_withdraw
->length
= withdraw_len
;
2277 stream_forward_getp(s
, withdraw_len
);
2279 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
);
2281 return BGP_ATTR_PARSE_PROCEED
;
2284 /* Large Community attribute. */
2285 static bgp_attr_parse_ret_t
2286 bgp_attr_large_community(struct bgp_attr_parser_args
*args
)
2288 struct peer
*const peer
= args
->peer
;
2289 struct attr
*const attr
= args
->attr
;
2290 const bgp_size_t length
= args
->length
;
2293 * Large community follows new attribute format.
2296 attr
->lcommunity
= NULL
;
2297 /* Empty extcomm doesn't seem to be invalid per se */
2298 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2302 attr
->lcommunity
= lcommunity_parse(stream_pnt(peer
->curr
), length
);
2303 /* XXX: fix ecommunity_parse to use stream API */
2304 stream_forward_getp(peer
->curr
, length
);
2306 if (!attr
->lcommunity
)
2307 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2310 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
);
2312 return BGP_ATTR_PARSE_PROCEED
;
2315 /* Extended Community attribute. */
2316 static bgp_attr_parse_ret_t
2317 bgp_attr_ext_communities(struct bgp_attr_parser_args
*args
)
2319 struct peer
*const peer
= args
->peer
;
2320 struct attr
*const attr
= args
->attr
;
2321 const bgp_size_t length
= args
->length
;
2326 attr
->ecommunity
= NULL
;
2327 /* Empty extcomm doesn't seem to be invalid per se */
2328 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2332 attr
->ecommunity
= ecommunity_parse(
2333 stream_pnt(peer
->curr
), length
,
2334 CHECK_FLAG(peer
->flags
,
2335 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
));
2336 /* XXX: fix ecommunity_parse to use stream API */
2337 stream_forward_getp(peer
->curr
, length
);
2339 /* The Extended Community attribute SHALL be considered malformed if
2340 * its length is not a non-zero multiple of 8.
2342 if (!attr
->ecommunity
)
2343 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2346 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
2348 /* Extract DF election preference and mobility sequence number */
2349 attr
->df_pref
= bgp_attr_df_pref_from_ec(attr
, &attr
->df_alg
);
2351 /* Extract MAC mobility sequence number, if any. */
2352 attr
->mm_seqnum
= bgp_attr_mac_mobility_seqnum(attr
, &sticky
);
2353 attr
->sticky
= sticky
;
2355 /* Check if this is a Gateway MAC-IP advertisement */
2356 attr
->default_gw
= bgp_attr_default_gw(attr
);
2358 /* Handle scenario where router flag ecommunity is not
2359 * set but default gw ext community is present.
2360 * Use default gateway, set and propogate R-bit.
2362 if (attr
->default_gw
)
2363 attr
->router_flag
= 1;
2365 /* Check EVPN Neighbor advertisement flags, R-bit */
2366 bgp_attr_evpn_na_flag(attr
, &attr
->router_flag
, &proxy
);
2368 attr
->es_flags
|= ATTR_ES_PROXY_ADVERT
;
2370 /* Extract the Rmac, if any */
2371 if (bgp_attr_rmac(attr
, &attr
->rmac
)) {
2372 if (bgp_debug_update(peer
, NULL
, NULL
, 1)
2373 && bgp_mac_exist(&attr
->rmac
))
2374 zlog_debug("%s: router mac %pEA is self mac", __func__
,
2378 /* Get the tunnel type from encap extended community */
2379 bgp_attr_extcom_tunnel_type(attr
,
2380 (bgp_encap_types
*)&attr
->encap_tunneltype
);
2382 /* Extract link bandwidth, if any. */
2383 (void)ecommunity_linkbw_present(attr
->ecommunity
, &attr
->link_bw
);
2385 return BGP_ATTR_PARSE_PROCEED
;
2388 /* IPv6 Extended Community attribute. */
2389 static bgp_attr_parse_ret_t
2390 bgp_attr_ipv6_ext_communities(struct bgp_attr_parser_args
*args
)
2392 struct peer
*const peer
= args
->peer
;
2393 struct attr
*const attr
= args
->attr
;
2394 const bgp_size_t length
= args
->length
;
2395 struct ecommunity
*ipv6_ecomm
= NULL
;
2398 bgp_attr_set_ipv6_ecommunity(attr
, ipv6_ecomm
);
2399 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2403 ipv6_ecomm
= ecommunity_parse_ipv6(
2404 stream_pnt(peer
->curr
), length
,
2405 CHECK_FLAG(peer
->flags
,
2406 PEER_FLAG_DISABLE_LINK_BW_ENCODING_IEEE
));
2407 bgp_attr_set_ipv6_ecommunity(attr
, ipv6_ecomm
);
2409 /* XXX: fix ecommunity_parse to use stream API */
2410 stream_forward_getp(peer
->curr
, length
);
2413 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2416 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_IPV6_EXT_COMMUNITIES
);
2418 return BGP_ATTR_PARSE_PROCEED
;
2421 /* Parse Tunnel Encap attribute in an UPDATE */
2422 static int bgp_attr_encap(uint8_t type
, struct peer
*peer
, /* IN */
2423 bgp_size_t length
, /* IN: attr's length field */
2424 struct attr
*attr
, /* IN: caller already allocated */
2425 uint8_t flag
, /* IN: attr's flags field */
2429 uint16_t tunneltype
= 0;
2431 total
= length
+ (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
) ? 4 : 3);
2433 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_TRANS
)
2434 || !CHECK_FLAG(flag
, BGP_ATTR_FLAG_OPTIONAL
)) {
2436 "Tunnel Encap attribute flag isn't optional and transitive %d",
2438 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
2439 BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR
,
2444 if (BGP_ATTR_ENCAP
== type
) {
2445 /* read outer TLV type and length */
2446 uint16_t tlv_length
;
2450 "Tunnel Encap attribute not long enough to contain outer T,L");
2451 bgp_notify_send_with_data(
2452 peer
, BGP_NOTIFY_UPDATE_ERR
,
2453 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
, startp
, total
);
2456 tunneltype
= stream_getw(BGP_INPUT(peer
));
2457 tlv_length
= stream_getw(BGP_INPUT(peer
));
2460 if (tlv_length
!= length
) {
2461 zlog_info("%s: tlv_length(%d) != length(%d)",
2462 __func__
, tlv_length
, length
);
2466 while (length
>= 4) {
2467 uint16_t subtype
= 0;
2468 uint16_t sublength
= 0;
2469 struct bgp_attr_encap_subtlv
*tlv
;
2471 if (BGP_ATTR_ENCAP
== type
) {
2472 subtype
= stream_getc(BGP_INPUT(peer
));
2473 sublength
= stream_getc(BGP_INPUT(peer
));
2475 #ifdef ENABLE_BGP_VNC
2477 subtype
= stream_getw(BGP_INPUT(peer
));
2478 sublength
= stream_getw(BGP_INPUT(peer
));
2483 if (sublength
> length
) {
2485 "Tunnel Encap attribute sub-tlv length %d exceeds remaining length %d",
2487 bgp_notify_send_with_data(
2488 peer
, BGP_NOTIFY_UPDATE_ERR
,
2489 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
, startp
, total
);
2493 /* alloc and copy sub-tlv */
2494 /* TBD make sure these are freed when attributes are released */
2495 tlv
= XCALLOC(MTYPE_ENCAP_TLV
,
2496 sizeof(struct bgp_attr_encap_subtlv
) + sublength
);
2497 tlv
->type
= subtype
;
2498 tlv
->length
= sublength
;
2499 stream_get(tlv
->value
, peer
->curr
, sublength
);
2500 length
-= sublength
;
2502 /* attach tlv to encap chain */
2503 if (BGP_ATTR_ENCAP
== type
) {
2504 struct bgp_attr_encap_subtlv
*stlv_last
;
2505 for (stlv_last
= attr
->encap_subtlvs
;
2506 stlv_last
&& stlv_last
->next
;
2507 stlv_last
= stlv_last
->next
)
2510 stlv_last
->next
= tlv
;
2512 attr
->encap_subtlvs
= tlv
;
2514 #ifdef ENABLE_BGP_VNC
2516 struct bgp_attr_encap_subtlv
*stlv_last
;
2517 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
2518 bgp_attr_get_vnc_subtlvs(attr
);
2520 for (stlv_last
= vnc_subtlvs
;
2521 stlv_last
&& stlv_last
->next
;
2522 stlv_last
= stlv_last
->next
)
2525 stlv_last
->next
= tlv
;
2527 bgp_attr_set_vnc_subtlvs(attr
, tlv
);
2532 if (BGP_ATTR_ENCAP
== type
) {
2533 attr
->encap_tunneltype
= tunneltype
;
2537 /* spurious leftover data */
2539 "Tunnel Encap attribute length is bad: %d leftover octets",
2541 bgp_notify_send_with_data(peer
, BGP_NOTIFY_UPDATE_ERR
,
2542 BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2551 /* SRv6 Service Data Sub-Sub-TLV attribute
2552 * draft-ietf-bess-srv6-services-07
2554 static bgp_attr_parse_ret_t
2555 bgp_attr_srv6_service_data(struct bgp_attr_parser_args
*args
)
2557 struct peer
*const peer
= args
->peer
;
2558 struct attr
*const attr
= args
->attr
;
2559 uint8_t type
, loc_block_len
, loc_node_len
, func_len
, arg_len
,
2560 transposition_len
, transposition_offset
;
2562 size_t headersz
= sizeof(type
) + sizeof(length
);
2564 if (STREAM_READABLE(peer
->curr
) < headersz
) {
2567 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
2568 headersz
, STREAM_READABLE(peer
->curr
));
2569 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2573 type
= stream_getc(peer
->curr
);
2574 length
= stream_getw(peer
->curr
);
2576 if (STREAM_READABLE(peer
->curr
) < length
) {
2579 "Malformed SRv6 Service Data Sub-Sub-TLV attribute - insufficent data (need %hu for attribute data, have %zu remaining in UPDATE)",
2580 length
, STREAM_READABLE(peer
->curr
));
2581 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2585 if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE
) {
2586 loc_block_len
= stream_getc(peer
->curr
);
2587 loc_node_len
= stream_getc(peer
->curr
);
2588 func_len
= stream_getc(peer
->curr
);
2589 arg_len
= stream_getc(peer
->curr
);
2590 transposition_len
= stream_getc(peer
->curr
);
2591 transposition_offset
= stream_getc(peer
->curr
);
2593 /* Log SRv6 Service Data Sub-Sub-TLV */
2594 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
)) {
2596 "%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",
2597 __func__
, loc_block_len
, loc_node_len
, func_len
,
2598 arg_len
, transposition_len
,
2599 transposition_offset
);
2602 attr
->srv6_l3vpn
->loc_block_len
= loc_block_len
;
2603 attr
->srv6_l3vpn
->loc_node_len
= loc_node_len
;
2604 attr
->srv6_l3vpn
->func_len
= func_len
;
2605 attr
->srv6_l3vpn
->arg_len
= arg_len
;
2606 attr
->srv6_l3vpn
->transposition_len
= transposition_len
;
2607 attr
->srv6_l3vpn
->transposition_offset
= transposition_offset
;
2611 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2613 "%s attr SRv6 Service Data Sub-Sub-TLV sub-sub-type=%u is not supported, skipped",
2616 stream_forward_getp(peer
->curr
, length
);
2619 return BGP_ATTR_PARSE_PROCEED
;
2622 /* SRv6 Service Sub-TLV attribute
2623 * draft-ietf-bess-srv6-services-07
2625 static bgp_attr_parse_ret_t
2626 bgp_attr_srv6_service(struct bgp_attr_parser_args
*args
)
2628 struct peer
*const peer
= args
->peer
;
2629 struct attr
*const attr
= args
->attr
;
2630 struct in6_addr ipv6_sid
;
2631 uint8_t type
, sid_flags
;
2632 uint16_t length
, endpoint_behavior
;
2633 size_t headersz
= sizeof(type
) + sizeof(length
);
2634 bgp_attr_parse_ret_t err
;
2637 if (STREAM_READABLE(peer
->curr
) < headersz
) {
2640 "Malformed SRv6 Service Sub-TLV attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
2641 headersz
, STREAM_READABLE(peer
->curr
));
2642 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2646 type
= stream_getc(peer
->curr
);
2647 length
= stream_getw(peer
->curr
);
2649 if (STREAM_READABLE(peer
->curr
) < length
) {
2652 "Malformed SRv6 Service Sub-TLV attribute - insufficent data (need %hu for attribute data, have %zu remaining in UPDATE)",
2653 length
, STREAM_READABLE(peer
->curr
));
2654 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2658 if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO
) {
2659 stream_getc(peer
->curr
);
2660 stream_get(&ipv6_sid
, peer
->curr
, sizeof(ipv6_sid
));
2661 sid_flags
= stream_getc(peer
->curr
);
2662 endpoint_behavior
= stream_getw(peer
->curr
);
2663 stream_getc(peer
->curr
);
2665 /* Log SRv6 Service Sub-TLV */
2666 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
)) {
2667 inet_ntop(AF_INET6
, &ipv6_sid
, buf
, sizeof(buf
));
2669 "%s: srv6-l3-srv sid %s, sid-flags 0x%02x, end-behaviour 0x%04x",
2670 __func__
, buf
, sid_flags
, endpoint_behavior
);
2673 /* Configure from Info */
2674 if (attr
->srv6_l3vpn
) {
2675 flog_err(EC_BGP_ATTRIBUTE_REPEATED
,
2676 "Prefix SID SRv6 L3VPN field repeated");
2677 return bgp_attr_malformed(
2678 args
, BGP_NOTIFY_UPDATE_MAL_ATTR
, args
->total
);
2680 attr
->srv6_l3vpn
= XCALLOC(MTYPE_BGP_SRV6_L3VPN
,
2681 sizeof(struct bgp_attr_srv6_l3vpn
));
2682 sid_copy(&attr
->srv6_l3vpn
->sid
, &ipv6_sid
);
2683 attr
->srv6_l3vpn
->sid_flags
= sid_flags
;
2684 attr
->srv6_l3vpn
->endpoint_behavior
= endpoint_behavior
;
2685 attr
->srv6_l3vpn
->loc_block_len
= 0;
2686 attr
->srv6_l3vpn
->loc_node_len
= 0;
2687 attr
->srv6_l3vpn
->func_len
= 0;
2688 attr
->srv6_l3vpn
->arg_len
= 0;
2689 attr
->srv6_l3vpn
->transposition_len
= 0;
2690 attr
->srv6_l3vpn
->transposition_offset
= 0;
2692 // Sub-Sub-TLV found
2693 if (length
> BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO_LENGTH
) {
2694 err
= bgp_attr_srv6_service_data(args
);
2696 if (err
!= BGP_ATTR_PARSE_PROCEED
)
2700 attr
->srv6_l3vpn
= srv6_l3vpn_intern(attr
->srv6_l3vpn
);
2703 /* Placeholder code for unsupported type */
2705 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2707 "%s attr SRv6 Service Sub-TLV sub-type=%u is not supported, skipped",
2710 stream_forward_getp(peer
->curr
, length
);
2713 return BGP_ATTR_PARSE_PROCEED
;
2717 * Read an individual SID value returning how much data we have read
2718 * Returns 0 if there was an error that needs to be passed up the stack
2720 static bgp_attr_parse_ret_t
bgp_attr_psid_sub(uint8_t type
, uint16_t length
,
2721 struct bgp_attr_parser_args
*args
)
2723 struct peer
*const peer
= args
->peer
;
2724 struct attr
*const attr
= args
->attr
;
2725 uint32_t label_index
;
2726 struct in6_addr ipv6_sid
;
2728 uint32_t srgb_range
;
2730 uint8_t sid_type
, sid_flags
;
2733 if (type
== BGP_PREFIX_SID_LABEL_INDEX
) {
2734 if (STREAM_READABLE(peer
->curr
) < length
2735 || length
!= BGP_PREFIX_SID_LABEL_INDEX_LENGTH
) {
2736 flog_err(EC_BGP_ATTR_LEN
,
2737 "Prefix SID label index length is %hu instead of %u",
2738 length
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
2739 return bgp_attr_malformed(args
,
2740 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2744 /* Ignore flags and reserved */
2745 stream_getc(peer
->curr
);
2746 stream_getw(peer
->curr
);
2748 /* Fetch the label index and see if it is valid. */
2749 label_index
= stream_getl(peer
->curr
);
2750 if (label_index
== BGP_INVALID_LABEL_INDEX
)
2751 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
2754 /* Store label index; subsequently, we'll check on
2756 attr
->label_index
= label_index
;
2759 /* Placeholder code for the IPv6 SID type */
2760 else if (type
== BGP_PREFIX_SID_IPV6
) {
2761 if (STREAM_READABLE(peer
->curr
) < length
2762 || length
!= BGP_PREFIX_SID_IPV6_LENGTH
) {
2763 flog_err(EC_BGP_ATTR_LEN
,
2764 "Prefix SID IPv6 length is %hu instead of %u",
2765 length
, BGP_PREFIX_SID_IPV6_LENGTH
);
2766 return bgp_attr_malformed(args
,
2767 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2771 /* Ignore reserved */
2772 stream_getc(peer
->curr
);
2773 stream_getw(peer
->curr
);
2775 stream_get(&ipv6_sid
, peer
->curr
, 16);
2778 /* Placeholder code for the Originator SRGB type */
2779 else if (type
== BGP_PREFIX_SID_ORIGINATOR_SRGB
) {
2781 * ietf-idr-bgp-prefix-sid-05:
2782 * Length is the total length of the value portion of the
2783 * TLV: 2 + multiple of 6.
2785 * peer->curr stream readp should be at the beginning of the 16
2786 * bit flag field at this point in the code.
2790 * Check that the TLV length field is sane: at least 2 bytes of
2791 * flag, and at least 1 SRGB (these are 6 bytes each)
2793 if (length
< (2 + BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
)) {
2796 "Prefix SID Originator SRGB length field claims length of %hu bytes, but the minimum for this TLV type is %u",
2798 2 + BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
);
2799 return bgp_attr_malformed(
2800 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2805 * Check that we actually have at least as much data as
2806 * specified by the length field
2808 if (STREAM_READABLE(peer
->curr
) < length
) {
2809 flog_err(EC_BGP_ATTR_LEN
,
2810 "Prefix SID Originator SRGB specifies length %hu, but only %zu bytes remain",
2811 length
, STREAM_READABLE(peer
->curr
));
2812 return bgp_attr_malformed(
2813 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2818 * Check that the portion of the TLV containing the sequence of
2819 * SRGBs corresponds to a multiple of the SRGB size; to get
2820 * that length, we skip the 16 bit flags field
2822 stream_getw(peer
->curr
);
2824 if (length
% BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
) {
2827 "Prefix SID Originator SRGB length field claims attribute SRGB sequence section is %hubytes, but it must be a multiple of %u",
2828 length
, BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
);
2829 return bgp_attr_malformed(
2830 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2834 srgb_count
= length
/ BGP_PREFIX_SID_ORIGINATOR_SRGB_LENGTH
;
2836 for (int i
= 0; i
< srgb_count
; i
++) {
2837 stream_get(&srgb_base
, peer
->curr
, 3);
2838 stream_get(&srgb_range
, peer
->curr
, 3);
2842 /* Placeholder code for the VPN-SID Service type */
2843 else if (type
== BGP_PREFIX_SID_VPN_SID
) {
2844 if (STREAM_READABLE(peer
->curr
) < length
2845 || length
!= BGP_PREFIX_SID_VPN_SID_LENGTH
) {
2846 flog_err(EC_BGP_ATTR_LEN
,
2847 "Prefix SID VPN SID length is %hu instead of %u",
2848 length
, BGP_PREFIX_SID_VPN_SID_LENGTH
);
2849 return bgp_attr_malformed(args
,
2850 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2854 /* Parse VPN-SID Sub-TLV */
2855 stream_getc(peer
->curr
); /* reserved */
2856 sid_type
= stream_getc(peer
->curr
); /* sid_type */
2857 sid_flags
= stream_getc(peer
->curr
); /* sid_flags */
2858 stream_get(&ipv6_sid
, peer
->curr
,
2859 sizeof(ipv6_sid
)); /* sid_value */
2861 /* Log VPN-SID Sub-TLV */
2862 if (BGP_DEBUG(vpn
, VPN_LEAK_LABEL
)) {
2863 inet_ntop(AF_INET6
, &ipv6_sid
, buf
, sizeof(buf
));
2865 "%s: vpn-sid: sid %s, sid-type 0x%02x sid-flags 0x%02x",
2866 __func__
, buf
, sid_type
, sid_flags
);
2869 /* Configure from Info */
2870 if (attr
->srv6_vpn
) {
2871 flog_err(EC_BGP_ATTRIBUTE_REPEATED
,
2872 "Prefix SID SRv6 VPN field repeated");
2873 return bgp_attr_malformed(
2874 args
, BGP_NOTIFY_UPDATE_MAL_ATTR
, args
->total
);
2876 attr
->srv6_vpn
= XCALLOC(MTYPE_BGP_SRV6_VPN
,
2877 sizeof(struct bgp_attr_srv6_vpn
));
2878 attr
->srv6_vpn
->sid_flags
= sid_flags
;
2879 sid_copy(&attr
->srv6_vpn
->sid
, &ipv6_sid
);
2880 attr
->srv6_vpn
= srv6_vpn_intern(attr
->srv6_vpn
);
2883 /* Placeholder code for the SRv6 L3 Service type */
2884 else if (type
== BGP_PREFIX_SID_SRV6_L3_SERVICE
) {
2885 if (STREAM_READABLE(peer
->curr
) < length
) {
2888 "Prefix SID SRv6 L3-Service length is %hu, but only %zu bytes remain",
2889 length
, STREAM_READABLE(peer
->curr
));
2890 return bgp_attr_malformed(args
,
2891 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2895 /* ignore reserved */
2896 stream_getc(peer
->curr
);
2898 return bgp_attr_srv6_service(args
);
2901 /* Placeholder code for Unsupported TLV */
2904 if (STREAM_READABLE(peer
->curr
) < length
) {
2907 "Prefix SID SRv6 length is %hu - too long, only %zu remaining in this UPDATE",
2908 length
, STREAM_READABLE(peer
->curr
));
2909 return bgp_attr_malformed(
2910 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2914 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
2916 "%s attr Prefix-SID sub-type=%u is not supported, skipped",
2919 stream_forward_getp(peer
->curr
, length
);
2922 return BGP_ATTR_PARSE_PROCEED
;
2925 /* Prefix SID attribute
2926 * draft-ietf-idr-bgp-prefix-sid-05
2928 bgp_attr_parse_ret_t
bgp_attr_prefix_sid(struct bgp_attr_parser_args
*args
)
2930 struct peer
*const peer
= args
->peer
;
2931 struct attr
*const attr
= args
->attr
;
2932 bgp_attr_parse_ret_t ret
;
2934 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
);
2938 size_t headersz
= sizeof(type
) + sizeof(length
);
2939 size_t psid_parsed_length
= 0;
2941 while (STREAM_READABLE(peer
->curr
) > 0
2942 && psid_parsed_length
< args
->length
) {
2944 if (STREAM_READABLE(peer
->curr
) < headersz
) {
2947 "Malformed Prefix SID attribute - insufficent data (need %zu for attribute header, have %zu remaining in UPDATE)",
2948 headersz
, STREAM_READABLE(peer
->curr
));
2949 return bgp_attr_malformed(
2950 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2954 type
= stream_getc(peer
->curr
);
2955 length
= stream_getw(peer
->curr
);
2957 if (STREAM_READABLE(peer
->curr
) < length
) {
2960 "Malformed Prefix SID attribute - insufficient data (need %hu for attribute body, have %zu remaining in UPDATE)",
2961 length
, STREAM_READABLE(peer
->curr
));
2962 return bgp_attr_malformed(args
,
2963 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2967 ret
= bgp_attr_psid_sub(type
, length
, args
);
2969 if (ret
!= BGP_ATTR_PARSE_PROCEED
)
2972 psid_parsed_length
+= length
+ headersz
;
2974 if (psid_parsed_length
> args
->length
) {
2977 "Malformed Prefix SID attribute - TLV overflow by attribute (need %zu for TLV length, have %zu overflowed in UPDATE)",
2978 length
+ headersz
, psid_parsed_length
- (length
+ headersz
));
2979 return bgp_attr_malformed(
2980 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
2985 return BGP_ATTR_PARSE_PROCEED
;
2988 /* PMSI tunnel attribute (RFC 6514)
2989 * Basic validation checks done here.
2991 static bgp_attr_parse_ret_t
2992 bgp_attr_pmsi_tunnel(struct bgp_attr_parser_args
*args
)
2994 struct peer
*const peer
= args
->peer
;
2995 struct attr
*const attr
= args
->attr
;
2996 const bgp_size_t length
= args
->length
;
2998 int attr_parse_len
= 2 + BGP_LABEL_BYTES
;
3000 /* Verify that the receiver is expecting "ingress replication" as we
3001 * can only support that.
3003 if (length
< attr_parse_len
) {
3004 flog_err(EC_BGP_ATTR_LEN
, "Bad PMSI tunnel attribute length %d",
3006 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3009 stream_getc(peer
->curr
); /* Flags */
3010 tnl_type
= stream_getc(peer
->curr
);
3011 if (tnl_type
> PMSI_TNLTYPE_MAX
) {
3012 flog_err(EC_BGP_ATTR_PMSI_TYPE
,
3013 "Invalid PMSI tunnel attribute type %d", tnl_type
);
3014 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_OPT_ATTR_ERR
,
3017 if (tnl_type
== PMSI_TNLTYPE_INGR_REPL
) {
3019 flog_err(EC_BGP_ATTR_PMSI_LEN
,
3020 "Bad PMSI tunnel attribute length %d for IR",
3022 return bgp_attr_malformed(
3023 args
, BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
,
3028 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
);
3029 bgp_attr_set_pmsi_tnl_type(attr
, tnl_type
);
3030 stream_get(&attr
->label
, peer
->curr
, BGP_LABEL_BYTES
);
3032 /* Forward read pointer of input stream. */
3033 stream_forward_getp(peer
->curr
, length
- attr_parse_len
);
3035 return BGP_ATTR_PARSE_PROCEED
;
3038 /* BGP unknown attribute treatment. */
3039 static bgp_attr_parse_ret_t
bgp_attr_unknown(struct bgp_attr_parser_args
*args
)
3041 bgp_size_t total
= args
->total
;
3042 struct transit
*transit
;
3043 struct peer
*const peer
= args
->peer
;
3044 struct attr
*const attr
= args
->attr
;
3045 uint8_t *const startp
= args
->startp
;
3046 const uint8_t type
= args
->type
;
3047 const uint8_t flag
= args
->flags
;
3048 const bgp_size_t length
= args
->length
;
3050 if (bgp_debug_update(peer
, NULL
, NULL
, 1))
3052 "%s Unknown attribute is received (type %d, length %d)",
3053 peer
->host
, type
, length
);
3055 /* Forward read pointer of input stream. */
3056 stream_forward_getp(peer
->curr
, length
);
3058 /* If any of the mandatory well-known attributes are not recognized,
3059 then the Error Subcode is set to Unrecognized Well-known
3060 Attribute. The Data field contains the unrecognized attribute
3061 (type, length and value). */
3062 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_OPTIONAL
)) {
3063 return bgp_attr_malformed(args
, BGP_NOTIFY_UPDATE_UNREC_ATTR
,
3067 /* Unrecognized non-transitive optional attributes must be quietly
3068 ignored and not passed along to other BGP peers. */
3069 if (!CHECK_FLAG(flag
, BGP_ATTR_FLAG_TRANS
))
3070 return BGP_ATTR_PARSE_PROCEED
;
3072 /* If a path with recognized transitive optional attribute is
3073 accepted and passed along to other BGP peers and the Partial bit
3074 in the Attribute Flags octet is set to 1 by some previous AS, it
3075 is not set back to 0 by the current AS. */
3076 SET_FLAG(*startp
, BGP_ATTR_FLAG_PARTIAL
);
3078 /* Store transitive attribute to the end of attr->transit. */
3079 transit
= bgp_attr_get_transit(attr
);
3081 transit
= XCALLOC(MTYPE_TRANSIT
, sizeof(struct transit
));
3083 transit
->val
= XREALLOC(MTYPE_TRANSIT_VAL
, transit
->val
,
3084 transit
->length
+ total
);
3086 memcpy(transit
->val
+ transit
->length
, startp
, total
);
3087 transit
->length
+= total
;
3088 bgp_attr_set_transit(attr
, transit
);
3090 return BGP_ATTR_PARSE_PROCEED
;
3093 /* Well-known attribute check. */
3094 static int bgp_attr_check(struct peer
*peer
, struct attr
*attr
)
3098 /* BGP Graceful-Restart End-of-RIB for IPv4 unicast is signaled as an
3100 if (CHECK_FLAG(peer
->cap
, PEER_CAP_RESTART_RCV
) && !attr
->flag
)
3101 return BGP_ATTR_PARSE_PROCEED
;
3103 /* "An UPDATE message that contains the MP_UNREACH_NLRI is not required
3104 to carry any other path attributes.", though if MP_REACH_NLRI or NLRI
3105 are present, it should. Check for any other attribute being present
3108 if ((!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
)) &&
3109 CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_UNREACH_NLRI
))))
3110 return BGP_ATTR_PARSE_PROCEED
;
3112 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_ORIGIN
)))
3113 type
= BGP_ATTR_ORIGIN
;
3115 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
)))
3116 type
= BGP_ATTR_AS_PATH
;
3118 /* RFC 2858 makes Next-Hop optional/ignored, if MP_REACH_NLRI is present
3120 * NLRI is empty. We can't easily check NLRI empty here though.
3122 if (!CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
))
3123 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
)))
3124 type
= BGP_ATTR_NEXT_HOP
;
3126 if (peer
->sort
== BGP_PEER_IBGP
3127 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)))
3128 type
= BGP_ATTR_LOCAL_PREF
;
3130 /* If any of the well-known mandatory attributes are not present
3131 * in an UPDATE message, then "treat-as-withdraw" MUST be used.
3134 flog_warn(EC_BGP_MISSING_ATTRIBUTE
,
3135 "%s Missing well-known attribute %s.", peer
->host
,
3136 lookup_msg(attr_str
, type
, NULL
));
3137 return BGP_ATTR_PARSE_WITHDRAW
;
3139 return BGP_ATTR_PARSE_PROCEED
;
3142 /* Read attribute of update packet. This function is called from
3143 bgp_update_receive() in bgp_packet.c. */
3144 bgp_attr_parse_ret_t
bgp_attr_parse(struct peer
*peer
, struct attr
*attr
,
3145 bgp_size_t size
, struct bgp_nlri
*mp_update
,
3146 struct bgp_nlri
*mp_withdraw
)
3148 bgp_attr_parse_ret_t ret
;
3152 uint8_t *startp
, *endp
;
3154 uint8_t seen
[BGP_ATTR_BITMAP_SIZE
];
3155 /* we need the as4_path only until we have synthesized the as_path with
3157 /* same goes for as4_aggregator */
3158 struct aspath
*as4_path
= NULL
;
3159 as_t as4_aggregator
= 0;
3160 struct in_addr as4_aggregator_addr
= {.s_addr
= 0};
3161 struct transit
*transit
;
3163 /* Initialize bitmap. */
3164 memset(seen
, 0, BGP_ATTR_BITMAP_SIZE
);
3166 /* End pointer of BGP attribute. */
3167 endp
= BGP_INPUT_PNT(peer
) + size
;
3169 /* Get attributes to the end of attribute length. */
3170 while (BGP_INPUT_PNT(peer
) < endp
) {
3171 /* Check remaining length check.*/
3172 if (endp
- BGP_INPUT_PNT(peer
) < BGP_ATTR_MIN_LEN
) {
3173 /* XXX warning: long int format, int arg (arg 5) */
3175 EC_BGP_ATTRIBUTE_TOO_SMALL
,
3176 "%s: error BGP attribute length %lu is smaller than min len",
3178 (unsigned long)(endp
3179 - stream_pnt(BGP_INPUT(peer
))));
3181 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3182 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3183 ret
= BGP_ATTR_PARSE_ERROR
;
3187 /* Fetch attribute flag and type. */
3188 startp
= BGP_INPUT_PNT(peer
);
3189 /* "The lower-order four bits of the Attribute Flags octet are
3190 unused. They MUST be zero when sent and MUST be ignored when
3192 flag
= 0xF0 & stream_getc(BGP_INPUT(peer
));
3193 type
= stream_getc(BGP_INPUT(peer
));
3195 /* Check whether Extended-Length applies and is in bounds */
3196 if (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
)
3197 && ((endp
- startp
) < (BGP_ATTR_MIN_LEN
+ 1))) {
3199 EC_BGP_EXT_ATTRIBUTE_TOO_SMALL
,
3200 "%s: Extended length set, but just %lu bytes of attr header",
3202 (unsigned long)(endp
3203 - stream_pnt(BGP_INPUT(peer
))));
3205 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3206 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3207 ret
= BGP_ATTR_PARSE_ERROR
;
3211 /* Check extended attribue length bit. */
3212 if (CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
))
3213 length
= stream_getw(BGP_INPUT(peer
));
3215 length
= stream_getc(BGP_INPUT(peer
));
3217 /* If any attribute appears more than once in the UPDATE
3218 message, then the Error Subcode is set to Malformed Attribute
3221 if (CHECK_BITMAP(seen
, type
)) {
3223 EC_BGP_ATTRIBUTE_REPEATED
,
3224 "%s: error BGP attribute type %d appears twice in a message",
3227 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3228 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3229 ret
= BGP_ATTR_PARSE_ERROR
;
3233 /* Set type to bitmap to check duplicate attribute. `type' is
3234 unsigned char so it never overflow bitmap range. */
3236 SET_BITMAP(seen
, type
);
3238 /* Overflow check. */
3239 attr_endp
= BGP_INPUT_PNT(peer
) + length
;
3241 if (attr_endp
> endp
) {
3243 EC_BGP_ATTRIBUTE_TOO_LARGE
,
3244 "%s: BGP type %d length %d is too large, attribute total length is %d. attr_endp is %p. endp is %p",
3245 peer
->host
, type
, length
, size
, attr_endp
,
3249 * If any recognized attribute has an Attribute
3250 * Length that conflicts with the expected length
3251 * (based on the attribute type code), then the
3252 * Error Subcode MUST be set to Attribute Length
3253 * Error. The Data field MUST contain the erroneous
3254 * attribute (type, length, and value).
3256 * We do not currently have a good way to determine the
3257 * length of the attribute independent of the length
3258 * received in the message. Instead we send the
3259 * minimum between the amount of data we have and the
3260 * amount specified by the attribute length field.
3262 * Instead of directly passing in the packet buffer and
3263 * offset we use the stream_get* functions to read into
3264 * a stack buffer, since they perform bounds checking
3265 * and we are working with untrusted data.
3267 unsigned char ndata
[peer
->max_packet_size
];
3268 memset(ndata
, 0x00, sizeof(ndata
));
3270 CHECK_FLAG(flag
, BGP_ATTR_FLAG_EXTLEN
) ? 2 : 1;
3271 /* Rewind to end of flag field */
3272 stream_rewind_getp(BGP_INPUT(peer
), (1 + lfl
));
3274 stream_get(&ndata
[0], BGP_INPUT(peer
), 1);
3276 stream_get(&ndata
[1], BGP_INPUT(peer
), lfl
);
3278 size_t atl
= attr_endp
- startp
;
3279 size_t ndl
= MIN(atl
, STREAM_READABLE(BGP_INPUT(peer
)));
3280 stream_get(&ndata
[lfl
+ 1], BGP_INPUT(peer
), ndl
);
3282 bgp_notify_send_with_data(
3283 peer
, BGP_NOTIFY_UPDATE_ERR
,
3284 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
, ndata
,
3287 ret
= BGP_ATTR_PARSE_ERROR
;
3291 struct bgp_attr_parser_args attr_args
= {
3298 .total
= attr_endp
- startp
,
3302 /* If any recognized attribute has Attribute Flags that conflict
3303 with the Attribute Type Code, then the Error Subcode is set
3305 Attribute Flags Error. The Data field contains the erroneous
3306 attribute (type, length and value). */
3307 if (bgp_attr_flag_invalid(&attr_args
)) {
3308 ret
= bgp_attr_malformed(
3309 &attr_args
, BGP_NOTIFY_UPDATE_ATTR_FLAG_ERR
,
3311 if (ret
== BGP_ATTR_PARSE_PROCEED
)
3316 /* OK check attribute and store it's value. */
3318 case BGP_ATTR_ORIGIN
:
3319 ret
= bgp_attr_origin(&attr_args
);
3321 case BGP_ATTR_AS_PATH
:
3322 ret
= bgp_attr_aspath(&attr_args
);
3324 case BGP_ATTR_AS4_PATH
:
3325 ret
= bgp_attr_as4_path(&attr_args
, &as4_path
);
3327 case BGP_ATTR_NEXT_HOP
:
3328 ret
= bgp_attr_nexthop(&attr_args
);
3330 case BGP_ATTR_MULTI_EXIT_DISC
:
3331 ret
= bgp_attr_med(&attr_args
);
3333 case BGP_ATTR_LOCAL_PREF
:
3334 ret
= bgp_attr_local_pref(&attr_args
);
3336 case BGP_ATTR_ATOMIC_AGGREGATE
:
3337 ret
= bgp_attr_atomic(&attr_args
);
3339 case BGP_ATTR_AGGREGATOR
:
3340 ret
= bgp_attr_aggregator(&attr_args
);
3342 case BGP_ATTR_AS4_AGGREGATOR
:
3343 ret
= bgp_attr_as4_aggregator(&attr_args
,
3345 &as4_aggregator_addr
);
3347 case BGP_ATTR_COMMUNITIES
:
3348 ret
= bgp_attr_community(&attr_args
);
3350 case BGP_ATTR_LARGE_COMMUNITIES
:
3351 ret
= bgp_attr_large_community(&attr_args
);
3353 case BGP_ATTR_ORIGINATOR_ID
:
3354 ret
= bgp_attr_originator_id(&attr_args
);
3356 case BGP_ATTR_CLUSTER_LIST
:
3357 ret
= bgp_attr_cluster_list(&attr_args
);
3359 case BGP_ATTR_MP_REACH_NLRI
:
3360 ret
= bgp_mp_reach_parse(&attr_args
, mp_update
);
3362 case BGP_ATTR_MP_UNREACH_NLRI
:
3363 ret
= bgp_mp_unreach_parse(&attr_args
, mp_withdraw
);
3365 case BGP_ATTR_EXT_COMMUNITIES
:
3366 ret
= bgp_attr_ext_communities(&attr_args
);
3368 #ifdef ENABLE_BGP_VNC_ATTR
3371 case BGP_ATTR_ENCAP
:
3372 ret
= bgp_attr_encap(type
, peer
, length
, attr
, flag
,
3375 case BGP_ATTR_PREFIX_SID
:
3376 ret
= bgp_attr_prefix_sid(&attr_args
);
3378 case BGP_ATTR_PMSI_TUNNEL
:
3379 ret
= bgp_attr_pmsi_tunnel(&attr_args
);
3381 case BGP_ATTR_IPV6_EXT_COMMUNITIES
:
3382 ret
= bgp_attr_ipv6_ext_communities(&attr_args
);
3385 ret
= bgp_attr_unknown(&attr_args
);
3389 if (ret
== BGP_ATTR_PARSE_ERROR_NOTIFYPLS
) {
3390 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3391 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3392 ret
= BGP_ATTR_PARSE_ERROR
;
3396 if (ret
== BGP_ATTR_PARSE_EOR
) {
3400 if (ret
== BGP_ATTR_PARSE_ERROR
) {
3401 flog_warn(EC_BGP_ATTRIBUTE_PARSE_ERROR
,
3402 "%s: Attribute %s, parse error", peer
->host
,
3403 lookup_msg(attr_str
, type
, NULL
));
3406 if (ret
== BGP_ATTR_PARSE_WITHDRAW
) {
3408 EC_BGP_ATTRIBUTE_PARSE_WITHDRAW
,
3409 "%s: Attribute %s, parse error - treating as withdrawal",
3410 peer
->host
, lookup_msg(attr_str
, type
, NULL
));
3414 /* Check the fetched length. */
3415 if (BGP_INPUT_PNT(peer
) != attr_endp
) {
3416 flog_warn(EC_BGP_ATTRIBUTE_FETCH_ERROR
,
3417 "%s: BGP attribute %s, fetch error",
3418 peer
->host
, lookup_msg(attr_str
, type
, NULL
));
3419 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3420 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3421 ret
= BGP_ATTR_PARSE_ERROR
;
3427 * draft-ietf-idr-bgp-prefix-sid-27#section-3:
3428 * About Prefix-SID path attribute,
3429 * Label-Index TLV(type1) and The Originator SRGB TLV(type-3)
3430 * may only appear in a BGP Prefix-SID attribute attached to
3431 * IPv4/IPv6 Labeled Unicast prefixes ([RFC8277]).
3432 * It MUST be ignored when received for other BGP AFI/SAFI combinations.
3434 if (!attr
->mp_nexthop_len
|| mp_update
->safi
!= SAFI_LABELED_UNICAST
)
3435 attr
->label_index
= BGP_INVALID_LABEL_INDEX
;
3437 /* Check final read pointer is same as end pointer. */
3438 if (BGP_INPUT_PNT(peer
) != endp
) {
3439 flog_warn(EC_BGP_ATTRIBUTES_MISMATCH
,
3440 "%s: BGP attribute %s, length mismatch", peer
->host
,
3441 lookup_msg(attr_str
, type
, NULL
));
3442 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3443 BGP_NOTIFY_UPDATE_ATTR_LENG_ERR
);
3445 ret
= BGP_ATTR_PARSE_ERROR
;
3450 * RFC4271: If the NEXT_HOP attribute field is syntactically incorrect,
3451 * then the Error Subcode MUST be set to Invalid NEXT_HOP Attribute.
3452 * This is implemented below and will result in a NOTIFICATION. If the
3453 * NEXT_HOP attribute is semantically incorrect, the error SHOULD be
3454 * logged, and the route SHOULD be ignored. In this case, a NOTIFICATION
3455 * message SHOULD NOT be sent. This is implemented elsewhere.
3457 * RFC4760: An UPDATE message that carries no NLRI, other than the one
3458 * encoded in the MP_REACH_NLRI attribute, SHOULD NOT carry the NEXT_HOP
3459 * attribute. If such a message contains the NEXT_HOP attribute, the BGP
3460 * speaker that receives the message SHOULD ignore this attribute.
3462 if (CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
))
3463 && !CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_MP_REACH_NLRI
))) {
3464 if (bgp_attr_nexthop_valid(peer
, attr
) < 0) {
3465 ret
= BGP_ATTR_PARSE_ERROR
;
3470 /* Check all mandatory well-known attributes are present */
3471 ret
= bgp_attr_check(peer
, attr
);
3476 * At this place we can see whether we got AS4_PATH and/or
3477 * AS4_AGGREGATOR from a 16Bit peer and act accordingly.
3478 * We can not do this before we've read all attributes because
3479 * the as4 handling does not say whether AS4_PATH has to be sent
3480 * after AS_PATH or not - and when AS4_AGGREGATOR will be send
3481 * in relationship to AGGREGATOR.
3482 * So, to be defensive, we are not relying on any order and read
3483 * all attributes first, including these 32bit ones, and now,
3484 * afterwards, we look what and if something is to be done for as4.
3486 * It is possible to not have AS_PATH, e.g. GR EoR and sole
3489 /* actually... this doesn't ever return failure currently, but
3490 * better safe than sorry */
3491 if (CHECK_FLAG(attr
->flag
, ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
))
3492 && bgp_attr_munge_as4_attrs(peer
, attr
, as4_path
, as4_aggregator
,
3493 &as4_aggregator_addr
)) {
3494 bgp_notify_send(peer
, BGP_NOTIFY_UPDATE_ERR
,
3495 BGP_NOTIFY_UPDATE_MAL_ATTR
);
3496 ret
= BGP_ATTR_PARSE_ERROR
;
3501 * Finally do the checks on the aspath we did not do yet
3502 * because we waited for a potentially synthesized aspath.
3504 if (attr
->flag
& (ATTR_FLAG_BIT(BGP_ATTR_AS_PATH
))) {
3505 ret
= bgp_attr_aspath_check(peer
, attr
);
3506 if (ret
!= BGP_ATTR_PARSE_PROCEED
)
3510 ret
= BGP_ATTR_PARSE_PROCEED
;
3514 * At this stage, we have done all fiddling with as4, and the
3515 * resulting info is in attr->aggregator resp. attr->aspath so
3516 * we can chuck as4_aggregator and as4_path alltogether in order
3521 * unintern - it is in the hash
3522 * The flag that we got this is still there, but that
3523 * does not do any trouble
3525 aspath_unintern(&as4_path
);
3528 transit
= bgp_attr_get_transit(attr
);
3529 if (ret
!= BGP_ATTR_PARSE_ERROR
) {
3530 /* Finally intern unknown attribute. */
3532 bgp_attr_set_transit(attr
, transit_intern(transit
));
3533 if (attr
->encap_subtlvs
)
3534 attr
->encap_subtlvs
= encap_intern(attr
->encap_subtlvs
,
3536 #ifdef ENABLE_BGP_VNC
3537 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
3538 bgp_attr_get_vnc_subtlvs(attr
);
3541 bgp_attr_set_vnc_subtlvs(
3543 encap_intern(vnc_subtlvs
, VNC_SUBTLV_TYPE
));
3547 transit_free(transit
);
3548 bgp_attr_set_transit(attr
, NULL
);
3551 bgp_attr_flush_encap(attr
);
3555 transit
= bgp_attr_get_transit(attr
);
3557 assert(transit
->refcnt
> 0);
3558 if (attr
->encap_subtlvs
)
3559 assert(attr
->encap_subtlvs
->refcnt
> 0);
3560 #ifdef ENABLE_BGP_VNC
3561 struct bgp_attr_encap_subtlv
*vnc_subtlvs
=
3562 bgp_attr_get_vnc_subtlvs(attr
);
3565 assert(vnc_subtlvs
->refcnt
> 0);
3572 * Extract the tunnel type from extended community
3574 void bgp_attr_extcom_tunnel_type(struct attr
*attr
,
3575 bgp_encap_types
*tunnel_type
)
3577 struct ecommunity
*ecom
;
3583 ecom
= attr
->ecommunity
;
3584 if (!ecom
|| !ecom
->size
)
3587 for (i
= 0; i
< ecom
->size
; i
++) {
3589 uint8_t type
, sub_type
;
3591 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
3594 if (!(type
== ECOMMUNITY_ENCODE_OPAQUE
&&
3595 sub_type
== ECOMMUNITY_OPAQUE_SUBTYPE_ENCAP
))
3597 *tunnel_type
= ((pnt
[6] << 8) | pnt
[7]);
3604 size_t bgp_packet_mpattr_start(struct stream
*s
, struct peer
*peer
, afi_t afi
,
3605 safi_t safi
, struct bpacket_attr_vec_arr
*vecarr
,
3610 iana_safi_t pkt_safi
;
3613 /* Set extended bit always to encode the attribute length as 2 bytes */
3614 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_EXTLEN
);
3615 stream_putc(s
, BGP_ATTR_MP_REACH_NLRI
);
3616 sizep
= stream_get_endp(s
);
3617 stream_putw(s
, 0); /* Marker: Attribute length. */
3620 /* Convert AFI, SAFI to values for packet. */
3621 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
3623 stream_putw(s
, pkt_afi
); /* AFI */
3624 stream_putc(s
, pkt_safi
); /* SAFI */
3628 && (safi
== SAFI_UNICAST
|| safi
== SAFI_LABELED_UNICAST
3629 || safi
== SAFI_MPLS_VPN
|| safi
== SAFI_MULTICAST
))
3630 nh_afi
= peer_cap_enhe(peer
, afi
, safi
) ? AFI_IP6
: AFI_IP
;
3631 else if (safi
== SAFI_FLOWSPEC
)
3634 nh_afi
= BGP_NEXTHOP_AFI_FROM_NHLEN(attr
->mp_nexthop_len
);
3637 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
, attr
);
3642 case SAFI_MULTICAST
:
3643 case SAFI_LABELED_UNICAST
:
3645 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
3649 stream_putl(s
, 0); /* RD = 0, per RFC */
3651 stream_put(s
, &attr
->mp_nexthop_global_in
, 4);
3656 stream_put(s
, &attr
->mp_nexthop_global_in
, 4);
3659 if (attr
->mp_nexthop_len
== 0)
3660 stream_putc(s
, 0); /* no nexthop for flowspec */
3662 stream_putc(s
, attr
->mp_nexthop_len
);
3663 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
3672 case SAFI_MULTICAST
:
3673 case SAFI_LABELED_UNICAST
:
3675 if (attr
->mp_nexthop_len
3676 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
3678 BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
);
3679 stream_put(s
, &attr
->mp_nexthop_global
,
3681 stream_put(s
, &attr
->mp_nexthop_local
,
3684 stream_putc(s
, IPV6_MAX_BYTELEN
);
3685 stream_put(s
, &attr
->mp_nexthop_global
,
3689 case SAFI_MPLS_VPN
: {
3690 if (attr
->mp_nexthop_len
3691 == BGP_ATTR_NHLEN_IPV6_GLOBAL
) {
3693 stream_putl(s
, 0); /* RD = 0, per RFC */
3695 stream_put(s
, &attr
->mp_nexthop_global
,
3697 } else if (attr
->mp_nexthop_len
3698 == BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
) {
3700 stream_putl(s
, 0); /* RD = 0, per RFC */
3702 stream_put(s
, &attr
->mp_nexthop_global
,
3704 stream_putl(s
, 0); /* RD = 0, per RFC */
3706 stream_put(s
, &attr
->mp_nexthop_local
,
3711 stream_putc(s
, IPV6_MAX_BYTELEN
);
3712 stream_put(s
, &attr
->mp_nexthop_global
,
3716 stream_putc(s
, 0); /* no nexthop for flowspec */
3722 if (safi
!= SAFI_FLOWSPEC
)
3724 EC_BGP_ATTR_NH_SEND_LEN
,
3725 "Bad nexthop when sending to %s, AFI %u SAFI %u nhlen %d",
3726 peer
->host
, afi
, safi
, attr
->mp_nexthop_len
);
3735 void bgp_packet_mpattr_prefix(struct stream
*s
, afi_t afi
, safi_t safi
,
3736 const struct prefix
*p
,
3737 const struct prefix_rd
*prd
, mpls_label_t
*label
,
3738 uint32_t num_labels
, int addpath_encode
,
3739 uint32_t addpath_tx_id
, struct attr
*attr
)
3741 if (safi
== SAFI_MPLS_VPN
) {
3743 stream_putl(s
, addpath_tx_id
);
3744 /* Label, RD, Prefix write. */
3745 stream_putc(s
, p
->prefixlen
+ 88);
3746 stream_put(s
, label
, BGP_LABEL_BYTES
);
3747 stream_put(s
, prd
->val
, 8);
3748 stream_put(s
, &p
->u
.prefix
, PSIZE(p
->prefixlen
));
3749 } else if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
) {
3750 /* EVPN prefix - contents depend on type */
3751 bgp_evpn_encode_prefix(s
, p
, prd
, label
, num_labels
, attr
,
3752 addpath_encode
, addpath_tx_id
);
3753 } else if (safi
== SAFI_LABELED_UNICAST
) {
3754 /* Prefix write with label. */
3755 stream_put_labeled_prefix(s
, p
, label
, addpath_encode
,
3757 } else if (safi
== SAFI_FLOWSPEC
) {
3758 stream_putc(s
, p
->u
.prefix_flowspec
.prefixlen
);
3759 stream_put(s
, (const void *)p
->u
.prefix_flowspec
.ptr
,
3760 p
->u
.prefix_flowspec
.prefixlen
);
3762 stream_put_prefix_addpath(s
, p
, addpath_encode
, addpath_tx_id
);
3765 size_t bgp_packet_mpattr_prefix_size(afi_t afi
, safi_t safi
,
3766 const struct prefix
*p
)
3768 int size
= PSIZE(p
->prefixlen
);
3769 if (safi
== SAFI_MPLS_VPN
)
3771 else if (safi
== SAFI_LABELED_UNICAST
)
3772 size
+= BGP_LABEL_BYTES
;
3773 else if (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
)
3774 size
+= 232; // TODO: Maximum possible for type-2, type-3 and
3780 * Encodes the tunnel encapsulation attribute,
3781 * and with ENABLE_BGP_VNC the VNC attribute which uses
3782 * almost the same TLV format
3784 static void bgp_packet_mpattr_tea(struct bgp
*bgp
, struct peer
*peer
,
3785 struct stream
*s
, struct attr
*attr
,
3788 unsigned int attrlenfield
= 0;
3789 unsigned int attrhdrlen
= 0;
3790 struct bgp_attr_encap_subtlv
*subtlvs
;
3791 struct bgp_attr_encap_subtlv
*st
;
3792 const char *attrname
;
3794 if (!attr
|| (attrtype
== BGP_ATTR_ENCAP
3795 && (!attr
->encap_tunneltype
3796 || attr
->encap_tunneltype
== BGP_ENCAP_TYPE_MPLS
)))
3800 case BGP_ATTR_ENCAP
:
3801 attrname
= "Tunnel Encap";
3802 subtlvs
= attr
->encap_subtlvs
;
3803 if (subtlvs
== NULL
) /* nothing to do */
3806 * The tunnel encap attr has an "outer" tlv.
3808 * L = total length of subtlvs,
3809 * V = concatenated subtlvs.
3811 attrlenfield
= 2 + 2; /* T + L */
3812 attrhdrlen
= 1 + 1; /* subTLV T + L */
3815 #ifdef ENABLE_BGP_VNC_ATTR
3818 subtlvs
= bgp_attr_get_vnc_subtlvs(attr
);
3819 if (subtlvs
== NULL
) /* nothing to do */
3821 attrlenfield
= 0; /* no outer T + L */
3822 attrhdrlen
= 2 + 2; /* subTLV T + L */
3830 /* compute attr length */
3831 for (st
= subtlvs
; st
; st
= st
->next
) {
3832 attrlenfield
+= (attrhdrlen
+ st
->length
);
3835 if (attrlenfield
> 0xffff) {
3836 zlog_info("%s attribute is too long (length=%d), can't send it",
3837 attrname
, attrlenfield
);
3841 if (attrlenfield
> 0xff) {
3842 /* 2-octet length field */
3844 BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
3845 | BGP_ATTR_FLAG_EXTLEN
);
3846 stream_putc(s
, attrtype
);
3847 stream_putw(s
, attrlenfield
& 0xffff);
3849 /* 1-octet length field */
3850 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
);
3851 stream_putc(s
, attrtype
);
3852 stream_putc(s
, attrlenfield
& 0xff);
3855 if (attrtype
== BGP_ATTR_ENCAP
) {
3856 /* write outer T+L */
3857 stream_putw(s
, attr
->encap_tunneltype
);
3858 stream_putw(s
, attrlenfield
- 4);
3861 /* write each sub-tlv */
3862 for (st
= subtlvs
; st
; st
= st
->next
) {
3863 if (attrtype
== BGP_ATTR_ENCAP
) {
3864 stream_putc(s
, st
->type
);
3865 stream_putc(s
, st
->length
);
3866 #ifdef ENABLE_BGP_VNC
3868 stream_putw(s
, st
->type
);
3869 stream_putw(s
, st
->length
);
3872 stream_put(s
, st
->value
, st
->length
);
3876 void bgp_packet_mpattr_end(struct stream
*s
, size_t sizep
)
3878 /* Set MP attribute length. Don't count the (2) bytes used to encode
3880 stream_putw_at(s
, sizep
, (stream_get_endp(s
) - sizep
) - 2);
3883 static bool bgp_append_local_as(struct peer
*peer
, afi_t afi
, safi_t safi
)
3885 if (!BGP_AS_IS_PRIVATE(peer
->local_as
)
3886 || (BGP_AS_IS_PRIVATE(peer
->local_as
)
3887 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3888 PEER_FLAG_REMOVE_PRIVATE_AS
)
3889 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3890 PEER_FLAG_REMOVE_PRIVATE_AS_ALL
)
3891 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3892 PEER_FLAG_REMOVE_PRIVATE_AS_REPLACE
)
3893 && !CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3894 PEER_FLAG_REMOVE_PRIVATE_AS_ALL_REPLACE
)))
3899 /* Make attribute packet. */
3900 bgp_size_t
bgp_packet_attribute(struct bgp
*bgp
, struct peer
*peer
,
3901 struct stream
*s
, struct attr
*attr
,
3902 struct bpacket_attr_vec_arr
*vecarr
,
3903 struct prefix
*p
, afi_t afi
, safi_t safi
,
3904 struct peer
*from
, struct prefix_rd
*prd
,
3905 mpls_label_t
*label
, uint32_t num_labels
,
3906 int addpath_encode
, uint32_t addpath_tx_id
)
3909 size_t aspath_sizep
;
3910 struct aspath
*aspath
;
3911 int send_as4_path
= 0;
3912 int send_as4_aggregator
= 0;
3913 bool use32bit
= CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_RCV
)
3914 && CHECK_FLAG(peer
->cap
, PEER_CAP_AS4_ADV
);
3919 /* Remember current pointer. */
3920 cp
= stream_get_endp(s
);
3923 && !((afi
== AFI_IP
&& safi
== SAFI_UNICAST
)
3924 && !peer_cap_enhe(peer
, afi
, safi
))) {
3925 size_t mpattrlen_pos
= 0;
3927 mpattrlen_pos
= bgp_packet_mpattr_start(s
, peer
, afi
, safi
,
3929 bgp_packet_mpattr_prefix(s
, afi
, safi
, p
, prd
, label
,
3930 num_labels
, addpath_encode
,
3931 addpath_tx_id
, attr
);
3932 bgp_packet_mpattr_end(s
, mpattrlen_pos
);
3935 /* Origin attribute. */
3936 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
3937 stream_putc(s
, BGP_ATTR_ORIGIN
);
3939 stream_putc(s
, attr
->origin
);
3941 /* AS path attribute. */
3943 /* If remote-peer is EBGP */
3944 if (peer
->sort
== BGP_PEER_EBGP
3945 && (!CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3946 PEER_FLAG_AS_PATH_UNCHANGED
)
3947 || attr
->aspath
->segments
== NULL
)
3948 && (!CHECK_FLAG(peer
->af_flags
[afi
][safi
],
3949 PEER_FLAG_RSERVER_CLIENT
))) {
3950 aspath
= aspath_dup(attr
->aspath
);
3952 /* Even though we may not be configured for confederations we
3954 * RXed an AS_PATH with AS_CONFED_SEQUENCE or AS_CONFED_SET */
3955 aspath
= aspath_delete_confed_seq(aspath
);
3957 if (CHECK_FLAG(bgp
->config
, BGP_CONFIG_CONFEDERATION
)) {
3958 /* Stuff our path CONFED_ID on the front */
3959 aspath
= aspath_add_seq(aspath
, bgp
->confed_id
);
3961 if (peer
->change_local_as
) {
3962 /* If replace-as is specified, we only use the
3963 change_local_as when
3964 advertising routes. */
3965 if (!CHECK_FLAG(peer
->flags
,
3966 PEER_FLAG_LOCAL_AS_REPLACE_AS
))
3967 if (bgp_append_local_as(peer
, afi
,
3969 aspath
= aspath_add_seq(
3970 aspath
, peer
->local_as
);
3971 aspath
= aspath_add_seq(aspath
,
3972 peer
->change_local_as
);
3974 aspath
= aspath_add_seq(aspath
, peer
->local_as
);
3977 } else if (peer
->sort
== BGP_PEER_CONFED
) {
3978 /* A confed member, so we need to do the AS_CONFED_SEQUENCE
3980 aspath
= aspath_dup(attr
->aspath
);
3981 aspath
= aspath_add_confed_seq(aspath
, peer
->local_as
);
3983 aspath
= attr
->aspath
;
3985 /* If peer is not AS4 capable, then:
3986 * - send the created AS_PATH out as AS4_PATH (optional, transitive),
3987 * but ensure that no AS_CONFED_SEQUENCE and AS_CONFED_SET path
3989 * types are in it (i.e. exclude them if they are there)
3990 * AND do this only if there is at least one asnum > 65535 in the
3992 * - send an AS_PATH out, but put 16Bit ASnums in it, not 32bit, and
3994 * all ASnums > 65535 to BGP_AS_TRANS
3997 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_EXTLEN
);
3998 stream_putc(s
, BGP_ATTR_AS_PATH
);
3999 aspath_sizep
= stream_get_endp(s
);
4001 stream_putw_at(s
, aspath_sizep
, aspath_put(s
, aspath
, use32bit
));
4003 /* OLD session may need NEW_AS_PATH sent, if there are 4-byte ASNs
4006 if (!use32bit
&& aspath_has_as4(aspath
))
4008 1; /* we'll do this later, at the correct place */
4010 /* Nexthop attribute. */
4011 if (afi
== AFI_IP
&& safi
== SAFI_UNICAST
4012 && !peer_cap_enhe(peer
, afi
, safi
)) {
4013 afi_t nh_afi
= BGP_NEXTHOP_AFI_FROM_NHLEN(attr
->mp_nexthop_len
);
4015 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
)) {
4016 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4017 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4018 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
,
4021 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4022 } else if (peer_cap_enhe(from
, afi
, safi
)
4023 || (nh_afi
== AFI_IP6
)) {
4025 * Likely this is the case when an IPv4 prefix was
4026 * received with Extended Next-hop capability in this
4027 * or another vrf and is now being advertised to
4028 * non-ENHE peers. Since peer_cap_enhe only checks
4029 * peers in this vrf, also check the nh_afi to catch
4030 * the case where the originator was in another vrf.
4031 * Setting the mandatory (ipv4) next-hop attribute here
4032 * to enable implicit next-hop self with correct A-F
4033 * (ipv4 address family).
4035 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4036 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4037 bpacket_attr_vec_arr_set_vec(vecarr
, BGP_ATTR_VEC_NH
, s
,
4040 stream_put_ipv4(s
, 0);
4044 /* MED attribute. */
4045 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
)
4046 || bgp
->maxmed_active
) {
4047 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4048 stream_putc(s
, BGP_ATTR_MULTI_EXIT_DISC
);
4050 stream_putl(s
, (bgp
->maxmed_active
? bgp
->maxmed_value
4054 /* Local preference. */
4055 if (peer
->sort
== BGP_PEER_IBGP
|| peer
->sort
== BGP_PEER_CONFED
) {
4056 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4057 stream_putc(s
, BGP_ATTR_LOCAL_PREF
);
4059 stream_putl(s
, attr
->local_pref
);
4062 /* Atomic aggregate. */
4063 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
)) {
4064 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4065 stream_putc(s
, BGP_ATTR_ATOMIC_AGGREGATE
);
4070 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
)) {
4071 /* Common to BGP_ATTR_AGGREGATOR, regardless of ASN size */
4072 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4073 stream_putc(s
, BGP_ATTR_AGGREGATOR
);
4076 /* AS4 capable peer */
4078 stream_putl(s
, attr
->aggregator_as
);
4080 /* 2-byte AS peer */
4083 /* Is ASN representable in 2-bytes? Or must AS_TRANS be
4085 if (attr
->aggregator_as
> UINT16_MAX
) {
4086 stream_putw(s
, BGP_AS_TRANS
);
4088 /* we have to send AS4_AGGREGATOR, too.
4089 * we'll do that later in order to send
4090 * attributes in ascending
4093 send_as4_aggregator
= 1;
4095 stream_putw(s
, (uint16_t)attr
->aggregator_as
);
4097 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4100 /* Community attribute. */
4101 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_COMMUNITY
)
4102 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
))) {
4103 if (attr
->community
->size
* 4 > 255) {
4105 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4106 | BGP_ATTR_FLAG_EXTLEN
);
4107 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4108 stream_putw(s
, attr
->community
->size
* 4);
4111 BGP_ATTR_FLAG_OPTIONAL
4112 | BGP_ATTR_FLAG_TRANS
);
4113 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4114 stream_putc(s
, attr
->community
->size
* 4);
4116 stream_put(s
, attr
->community
->val
, attr
->community
->size
* 4);
4120 * Large Community attribute.
4122 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
],
4123 PEER_FLAG_SEND_LARGE_COMMUNITY
)
4124 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
))) {
4125 if (lcom_length(attr
->lcommunity
) > 255) {
4127 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4128 | BGP_ATTR_FLAG_EXTLEN
);
4129 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4130 stream_putw(s
, lcom_length(attr
->lcommunity
));
4133 BGP_ATTR_FLAG_OPTIONAL
4134 | BGP_ATTR_FLAG_TRANS
);
4135 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4136 stream_putc(s
, lcom_length(attr
->lcommunity
));
4138 stream_put(s
, attr
->lcommunity
->val
,
4139 lcom_length(attr
->lcommunity
));
4142 /* Route Reflector. */
4143 if (peer
->sort
== BGP_PEER_IBGP
&& from
4144 && from
->sort
== BGP_PEER_IBGP
) {
4145 struct cluster_list
*cluster
= bgp_attr_get_cluster(attr
);
4147 /* Originator ID. */
4148 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4149 stream_putc(s
, BGP_ATTR_ORIGINATOR_ID
);
4152 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ORIGINATOR_ID
))
4153 stream_put_in_addr(s
, &attr
->originator_id
);
4155 stream_put_in_addr(s
, &from
->remote_id
);
4158 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4159 stream_putc(s
, BGP_ATTR_CLUSTER_LIST
);
4162 stream_putc(s
, cluster
->length
+ 4);
4163 /* If this peer configuration's parent BGP has
4165 if (bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
4166 stream_put_in_addr(s
, &bgp
->cluster_id
);
4168 stream_put_in_addr(s
, &bgp
->router_id
);
4169 stream_put(s
, cluster
->list
, cluster
->length
);
4172 /* If this peer configuration's parent BGP has
4174 if (bgp
->config
& BGP_CONFIG_CLUSTER_ID
)
4175 stream_put_in_addr(s
, &bgp
->cluster_id
);
4177 stream_put_in_addr(s
, &bgp
->router_id
);
4181 /* Extended Communities attribute. */
4182 if (CHECK_FLAG(peer
->af_flags
[afi
][safi
], PEER_FLAG_SEND_EXT_COMMUNITY
)
4183 && (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
))) {
4184 if (peer
->sort
== BGP_PEER_IBGP
4185 || peer
->sort
== BGP_PEER_CONFED
) {
4186 if (attr
->ecommunity
->size
* 8 > 255) {
4188 BGP_ATTR_FLAG_OPTIONAL
4189 | BGP_ATTR_FLAG_TRANS
4190 | BGP_ATTR_FLAG_EXTLEN
);
4191 stream_putc(s
, BGP_ATTR_EXT_COMMUNITIES
);
4192 stream_putw(s
, attr
->ecommunity
->size
* 8);
4195 BGP_ATTR_FLAG_OPTIONAL
4196 | BGP_ATTR_FLAG_TRANS
);
4197 stream_putc(s
, BGP_ATTR_EXT_COMMUNITIES
);
4198 stream_putc(s
, attr
->ecommunity
->size
* 8);
4200 stream_put(s
, attr
->ecommunity
->val
,
4201 attr
->ecommunity
->size
* 8);
4205 int ecom_tr_size
= 0;
4208 for (i
= 0; i
< attr
->ecommunity
->size
; i
++) {
4209 pnt
= attr
->ecommunity
->val
+ (i
* 8);
4212 if (CHECK_FLAG(tbit
,
4213 ECOMMUNITY_FLAG_NON_TRANSITIVE
))
4220 if (ecom_tr_size
* 8 > 255) {
4223 BGP_ATTR_FLAG_OPTIONAL
4224 | BGP_ATTR_FLAG_TRANS
4225 | BGP_ATTR_FLAG_EXTLEN
);
4227 BGP_ATTR_EXT_COMMUNITIES
);
4228 stream_putw(s
, ecom_tr_size
* 8);
4232 BGP_ATTR_FLAG_OPTIONAL
4233 | BGP_ATTR_FLAG_TRANS
);
4235 BGP_ATTR_EXT_COMMUNITIES
);
4236 stream_putc(s
, ecom_tr_size
* 8);
4239 for (i
= 0; i
< attr
->ecommunity
->size
; i
++) {
4240 pnt
= attr
->ecommunity
->val
+ (i
* 8);
4245 ECOMMUNITY_FLAG_NON_TRANSITIVE
))
4248 stream_put(s
, pnt
, 8);
4254 /* Label index attribute. */
4255 if (safi
== SAFI_LABELED_UNICAST
) {
4256 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
)) {
4257 uint32_t label_index
;
4259 label_index
= attr
->label_index
;
4261 if (label_index
!= BGP_INVALID_LABEL_INDEX
) {
4263 BGP_ATTR_FLAG_OPTIONAL
4264 | BGP_ATTR_FLAG_TRANS
);
4265 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4267 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX
);
4269 BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
4270 stream_putc(s
, 0); // reserved
4271 stream_putw(s
, 0); // flags
4272 stream_putl(s
, label_index
);
4277 /* SRv6 Service Information Attribute. */
4278 if ((afi
== AFI_IP
|| afi
== AFI_IP6
) && safi
== SAFI_MPLS_VPN
) {
4279 if (attr
->srv6_l3vpn
) {
4280 uint8_t subtlv_len
=
4281 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
4283 + BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO_LENGTH
;
4284 uint8_t tlv_len
= subtlv_len
+ BGP_ATTR_MIN_LEN
+ 1;
4285 uint8_t attr_len
= tlv_len
+ BGP_ATTR_MIN_LEN
;
4286 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
4287 | BGP_ATTR_FLAG_TRANS
);
4288 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4289 stream_putc(s
, attr_len
);
4290 stream_putc(s
, BGP_PREFIX_SID_SRV6_L3_SERVICE
);
4291 stream_putw(s
, tlv_len
);
4292 stream_putc(s
, 0); /* reserved */
4293 stream_putc(s
, BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_INFO
);
4294 stream_putw(s
, subtlv_len
);
4295 stream_putc(s
, 0); /* reserved */
4296 stream_put(s
, &attr
->srv6_l3vpn
->sid
,
4297 sizeof(attr
->srv6_l3vpn
->sid
)); /* sid */
4298 stream_putc(s
, 0); /* sid_flags */
4299 stream_putw(s
, 0xffff); /* endpoint */
4300 stream_putc(s
, 0); /* reserved */
4303 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE
);
4306 BGP_PREFIX_SID_SRV6_L3_SERVICE_SID_STRUCTURE_LENGTH
);
4307 stream_putc(s
, attr
->srv6_l3vpn
->loc_block_len
);
4308 stream_putc(s
, attr
->srv6_l3vpn
->loc_node_len
);
4309 stream_putc(s
, attr
->srv6_l3vpn
->func_len
);
4310 stream_putc(s
, attr
->srv6_l3vpn
->arg_len
);
4311 stream_putc(s
, attr
->srv6_l3vpn
->transposition_len
);
4312 stream_putc(s
, attr
->srv6_l3vpn
->transposition_offset
);
4313 } else if (attr
->srv6_vpn
) {
4314 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
4315 | BGP_ATTR_FLAG_TRANS
);
4316 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4317 stream_putc(s
, 22); /* tlv len */
4318 stream_putc(s
, BGP_PREFIX_SID_VPN_SID
);
4319 stream_putw(s
, 0x13); /* tlv len */
4320 stream_putc(s
, 0x00); /* reserved */
4321 stream_putc(s
, 0x01); /* sid_type */
4322 stream_putc(s
, 0x00); /* sif_flags */
4323 stream_put(s
, &attr
->srv6_vpn
->sid
,
4324 sizeof(attr
->srv6_vpn
->sid
)); /* sid */
4328 if (send_as4_path
) {
4329 /* If the peer is NOT As4 capable, AND */
4330 /* there are ASnums > 65535 in path THEN
4331 * give out AS4_PATH */
4333 /* Get rid of all AS_CONFED_SEQUENCE and AS_CONFED_SET
4335 * Hm, I wonder... confederation things *should* only be at
4336 * the beginning of an aspath, right? Then we should use
4337 * aspath_delete_confed_seq for this, because it is already
4339 * Folks, talk to me: what is reasonable here!?
4341 aspath
= aspath_delete_confed_seq(aspath
);
4344 BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_OPTIONAL
4345 | BGP_ATTR_FLAG_EXTLEN
);
4346 stream_putc(s
, BGP_ATTR_AS4_PATH
);
4347 aspath_sizep
= stream_get_endp(s
);
4349 stream_putw_at(s
, aspath_sizep
, aspath_put(s
, aspath
, 1));
4352 if (aspath
!= attr
->aspath
)
4353 aspath_free(aspath
);
4355 if (send_as4_aggregator
) {
4356 /* send AS4_AGGREGATOR, at this place */
4357 /* this section of code moved here in order to ensure the
4359 * *ascending* order of attributes
4361 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4362 stream_putc(s
, BGP_ATTR_AS4_AGGREGATOR
);
4364 stream_putl(s
, attr
->aggregator_as
);
4365 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4368 if (((afi
== AFI_IP
|| afi
== AFI_IP6
)
4369 && (safi
== SAFI_ENCAP
|| safi
== SAFI_MPLS_VPN
))
4370 || (afi
== AFI_L2VPN
&& safi
== SAFI_EVPN
)) {
4371 /* Tunnel Encap attribute */
4372 bgp_packet_mpattr_tea(bgp
, peer
, s
, attr
, BGP_ATTR_ENCAP
);
4374 #ifdef ENABLE_BGP_VNC_ATTR
4376 bgp_packet_mpattr_tea(bgp
, peer
, s
, attr
, BGP_ATTR_VNC
);
4381 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
)) {
4382 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4383 stream_putc(s
, BGP_ATTR_PMSI_TUNNEL
);
4384 stream_putc(s
, 9); // Length
4385 stream_putc(s
, 0); // Flags
4386 stream_putc(s
, bgp_attr_get_pmsi_tnl_type(attr
));
4387 stream_put(s
, &(attr
->label
),
4388 BGP_LABEL_BYTES
); // MPLS Label / VXLAN VNI
4389 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4390 // Unicast tunnel endpoint IP address
4393 /* Unknown transit attribute. */
4394 struct transit
*transit
= bgp_attr_get_transit(attr
);
4397 stream_put(s
, transit
->val
, transit
->length
);
4399 /* Return total size of attribute. */
4400 return stream_get_endp(s
) - cp
;
4403 size_t bgp_packet_mpunreach_start(struct stream
*s
, afi_t afi
, safi_t safi
)
4405 unsigned long attrlen_pnt
;
4407 iana_safi_t pkt_safi
;
4409 /* Set extended bit always to encode the attribute length as 2 bytes */
4410 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_EXTLEN
);
4411 stream_putc(s
, BGP_ATTR_MP_UNREACH_NLRI
);
4413 attrlen_pnt
= stream_get_endp(s
);
4414 stream_putw(s
, 0); /* Length of this attribute. */
4416 /* Convert AFI, SAFI to values for packet. */
4417 bgp_map_afi_safi_int2iana(afi
, safi
, &pkt_afi
, &pkt_safi
);
4419 stream_putw(s
, pkt_afi
);
4420 stream_putc(s
, pkt_safi
);
4425 void bgp_packet_mpunreach_prefix(struct stream
*s
, const struct prefix
*p
,
4426 afi_t afi
, safi_t safi
,
4427 const struct prefix_rd
*prd
,
4428 mpls_label_t
*label
, uint32_t num_labels
,
4429 int addpath_encode
, uint32_t addpath_tx_id
,
4432 uint8_t wlabel
[3] = {0x80, 0x00, 0x00};
4434 if (safi
== SAFI_LABELED_UNICAST
) {
4435 label
= (mpls_label_t
*)wlabel
;
4439 bgp_packet_mpattr_prefix(s
, afi
, safi
, p
, prd
, label
, num_labels
,
4440 addpath_encode
, addpath_tx_id
, attr
);
4443 void bgp_packet_mpunreach_end(struct stream
*s
, size_t attrlen_pnt
)
4445 bgp_packet_mpattr_end(s
, attrlen_pnt
);
4448 /* Initialization of attribute. */
4449 void bgp_attr_init(void)
4462 void bgp_attr_finish(void)
4467 ecommunity_finish();
4468 lcommunity_finish();
4475 /* Make attribute packet. */
4476 void bgp_dump_routes_attr(struct stream
*s
, struct attr
*attr
,
4477 const struct prefix
*prefix
)
4482 struct aspath
*aspath
;
4483 int addpath_encode
= 0;
4484 uint32_t addpath_tx_id
= 0;
4486 /* Remember current pointer. */
4487 cp
= stream_get_endp(s
);
4489 /* Place holder of length. */
4492 /* Origin attribute. */
4493 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4494 stream_putc(s
, BGP_ATTR_ORIGIN
);
4496 stream_putc(s
, attr
->origin
);
4498 aspath
= attr
->aspath
;
4500 stream_putc(s
, BGP_ATTR_FLAG_TRANS
| BGP_ATTR_FLAG_EXTLEN
);
4501 stream_putc(s
, BGP_ATTR_AS_PATH
);
4502 aspath_lenp
= stream_get_endp(s
);
4505 stream_putw_at(s
, aspath_lenp
, aspath_put(s
, aspath
, 1));
4507 /* Nexthop attribute. */
4508 /* If it's an IPv6 prefix, don't dump the IPv4 nexthop to save space */
4509 if (prefix
!= NULL
&& prefix
->family
!= AF_INET6
) {
4510 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4511 stream_putc(s
, BGP_ATTR_NEXT_HOP
);
4513 stream_put_ipv4(s
, attr
->nexthop
.s_addr
);
4516 /* MED attribute. */
4517 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_MULTI_EXIT_DISC
)) {
4518 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4519 stream_putc(s
, BGP_ATTR_MULTI_EXIT_DISC
);
4521 stream_putl(s
, attr
->med
);
4524 /* Local preference. */
4525 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LOCAL_PREF
)) {
4526 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4527 stream_putc(s
, BGP_ATTR_LOCAL_PREF
);
4529 stream_putl(s
, attr
->local_pref
);
4532 /* Atomic aggregate. */
4533 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_ATOMIC_AGGREGATE
)) {
4534 stream_putc(s
, BGP_ATTR_FLAG_TRANS
);
4535 stream_putc(s
, BGP_ATTR_ATOMIC_AGGREGATE
);
4540 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_AGGREGATOR
)) {
4541 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
);
4542 stream_putc(s
, BGP_ATTR_AGGREGATOR
);
4544 stream_putl(s
, attr
->aggregator_as
);
4545 stream_put_ipv4(s
, attr
->aggregator_addr
.s_addr
);
4548 /* Community attribute. */
4549 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_COMMUNITIES
)) {
4550 if (attr
->community
->size
* 4 > 255) {
4552 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4553 | BGP_ATTR_FLAG_EXTLEN
);
4554 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4555 stream_putw(s
, attr
->community
->size
* 4);
4558 BGP_ATTR_FLAG_OPTIONAL
4559 | BGP_ATTR_FLAG_TRANS
);
4560 stream_putc(s
, BGP_ATTR_COMMUNITIES
);
4561 stream_putc(s
, attr
->community
->size
* 4);
4563 stream_put(s
, attr
->community
->val
, attr
->community
->size
* 4);
4566 /* Large Community attribute. */
4567 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_LARGE_COMMUNITIES
)) {
4568 if (lcom_length(attr
->lcommunity
) > 255) {
4570 BGP_ATTR_FLAG_OPTIONAL
| BGP_ATTR_FLAG_TRANS
4571 | BGP_ATTR_FLAG_EXTLEN
);
4572 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4573 stream_putw(s
, lcom_length(attr
->lcommunity
));
4576 BGP_ATTR_FLAG_OPTIONAL
4577 | BGP_ATTR_FLAG_TRANS
);
4578 stream_putc(s
, BGP_ATTR_LARGE_COMMUNITIES
);
4579 stream_putc(s
, lcom_length(attr
->lcommunity
));
4582 stream_put(s
, attr
->lcommunity
->val
,
4583 lcom_length(attr
->lcommunity
));
4586 /* Add a MP_NLRI attribute to dump the IPv6 next hop */
4587 if (prefix
!= NULL
&& prefix
->family
== AF_INET6
4588 && (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL
4589 || attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)) {
4592 stream_putc(s
, BGP_ATTR_FLAG_OPTIONAL
);
4593 stream_putc(s
, BGP_ATTR_MP_REACH_NLRI
);
4594 sizep
= stream_get_endp(s
);
4597 stream_putc(s
, 0); /* Marker: Attribute length. */
4598 stream_putw(s
, AFI_IP6
); /* AFI */
4599 stream_putc(s
, SAFI_UNICAST
); /* SAFI */
4602 stream_putc(s
, attr
->mp_nexthop_len
);
4603 stream_put(s
, &attr
->mp_nexthop_global
, IPV6_MAX_BYTELEN
);
4604 if (attr
->mp_nexthop_len
== BGP_ATTR_NHLEN_IPV6_GLOBAL_AND_LL
)
4605 stream_put(s
, &attr
->mp_nexthop_local
,
4612 stream_put_prefix_addpath(s
, prefix
, addpath_encode
,
4615 /* Set MP attribute length. */
4616 stream_putc_at(s
, sizep
, (stream_get_endp(s
) - sizep
) - 1);
4620 if (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PREFIX_SID
)) {
4621 if (attr
->label_index
!= BGP_INVALID_LABEL_INDEX
) {
4623 BGP_ATTR_FLAG_OPTIONAL
4624 | BGP_ATTR_FLAG_TRANS
);
4625 stream_putc(s
, BGP_ATTR_PREFIX_SID
);
4627 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX
);
4628 stream_putc(s
, BGP_PREFIX_SID_LABEL_INDEX_LENGTH
);
4629 stream_putc(s
, 0); // reserved
4630 stream_putw(s
, 0); // flags
4631 stream_putl(s
, attr
->label_index
);
4635 /* Return total size of attribute. */
4636 len
= stream_get_endp(s
) - cp
- 2;
4637 stream_putw_at(s
, cp
, len
);