1 /* Ethernet-VPN Packet and vty Processing File
2 * Copyright (C) 2016 6WIND
3 * Copyright (C) 2017 Cumulus Networks, Inc.
5 * This file is part of FRR.
7 * FRRouting is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2, or (at your option) any
12 * FRRouting is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; see the file COPYING; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
34 #include "bgpd/bgp_attr_evpn.h"
35 #include "bgpd/bgpd.h"
36 #include "bgpd/bgp_table.h"
37 #include "bgpd/bgp_route.h"
38 #include "bgpd/bgp_attr.h"
39 #include "bgpd/bgp_mplsvpn.h"
40 #include "bgpd/bgp_label.h"
41 #include "bgpd/bgp_evpn.h"
42 #include "bgpd/bgp_evpn_private.h"
43 #include "bgpd/bgp_ecommunity.h"
44 #include "bgpd/bgp_encap_types.h"
45 #include "bgpd/bgp_debug.h"
46 #include "bgpd/bgp_errors.h"
47 #include "bgpd/bgp_aspath.h"
48 #include "bgpd/bgp_zebra.h"
49 #include "bgpd/bgp_nexthop.h"
52 * Definitions and external declarations.
54 extern struct zclient
*zclient
;
56 DEFINE_QOBJ_TYPE(bgpevpn
)
57 DEFINE_QOBJ_TYPE(evpnes
)
61 * Static function declarations
63 static void delete_evpn_route_entry(struct bgp
*bgp
,
64 afi_t afi
, safi_t safi
,
66 struct bgp_info
**ri
);
67 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
);
73 /* compare two IPV4 VTEP IPs */
74 static int evpn_vtep_ip_cmp(const void *p1
, const void *p2
)
76 const struct in_addr
*ip1
= p1
;
77 const struct in_addr
*ip2
= p2
;
83 return (ip1
->s_addr
== ip2
->s_addr
);
87 * Make hash key for ESI.
89 static unsigned int esi_hash_keymake(void *p
)
91 struct evpnes
*pes
= p
;
92 const void *pnt
= (void *)pes
->esi
.val
;
94 return jhash(pnt
, ESI_BYTES
, 0xa5a5a55a);
100 static int esi_cmp(const void *p1
, const void *p2
)
102 const struct evpnes
*pes1
= p1
;
103 const struct evpnes
*pes2
= p2
;
105 if (pes1
== NULL
&& pes2
== NULL
)
108 if (pes1
== NULL
|| pes2
== NULL
)
111 return (memcmp(pes1
->esi
.val
, pes2
->esi
.val
, ESI_BYTES
) == 0);
117 static unsigned int vni_hash_key_make(void *p
)
119 struct bgpevpn
*vpn
= p
;
120 return (jhash_1word(vpn
->vni
, 0));
124 * Comparison function for vni hash
126 static int vni_hash_cmp(const void *p1
, const void *p2
)
128 const struct bgpevpn
*vpn1
= p1
;
129 const struct bgpevpn
*vpn2
= p2
;
135 return (vpn1
->vni
== vpn2
->vni
);
139 * Make vrf import route target hash key.
141 static unsigned int vrf_import_rt_hash_key_make(void *p
)
143 struct vrf_irt_node
*irt
= p
;
144 char *pnt
= irt
->rt
.val
;
146 return jhash(pnt
, 8, 0x5abc1234);
150 * Comparison function for vrf import rt hash
152 static int vrf_import_rt_hash_cmp(const void *p1
, const void *p2
)
154 const struct vrf_irt_node
*irt1
= p1
;
155 const struct vrf_irt_node
*irt2
= p2
;
157 if (irt1
== NULL
&& irt2
== NULL
)
160 if (irt1
== NULL
|| irt2
== NULL
)
163 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
167 * Create a new vrf import_rt in default instance
169 static struct vrf_irt_node
*vrf_import_rt_new(struct ecommunity_val
*rt
)
171 struct bgp
*bgp_def
= NULL
;
172 struct vrf_irt_node
*irt
;
174 bgp_def
= bgp_get_default();
176 flog_err(BGP_ERR_NO_DFLT
,
177 "vrf import rt new - def instance not created yet");
181 irt
= XCALLOC(MTYPE_BGP_EVPN_VRF_IMPORT_RT
,
182 sizeof(struct vrf_irt_node
));
187 irt
->vrfs
= list_new();
190 if (!hash_get(bgp_def
->vrf_import_rt_hash
, irt
, hash_alloc_intern
)) {
191 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
199 * Free the vrf import rt node
201 static void vrf_import_rt_free(struct vrf_irt_node
*irt
)
203 struct bgp
*bgp_def
= NULL
;
205 bgp_def
= bgp_get_default();
207 flog_err(BGP_ERR_NO_DFLT
,
208 "vrf import rt free - def instance not created yet");
212 hash_release(bgp_def
->vrf_import_rt_hash
, irt
);
213 list_delete_and_null(&irt
->vrfs
);
214 XFREE(MTYPE_BGP_EVPN_VRF_IMPORT_RT
, irt
);
218 * Function to lookup Import RT node - used to map a RT to set of
219 * VNIs importing routes with that RT.
221 static struct vrf_irt_node
*lookup_vrf_import_rt(struct ecommunity_val
*rt
)
223 struct bgp
*bgp_def
= NULL
;
224 struct vrf_irt_node
*irt
;
225 struct vrf_irt_node tmp
;
227 bgp_def
= bgp_get_default();
231 "vrf import rt lookup - def instance not created yet");
235 memset(&tmp
, 0, sizeof(struct vrf_irt_node
));
236 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
237 irt
= hash_lookup(bgp_def
->vrf_import_rt_hash
, &tmp
);
242 * Is specified VRF present on the RT's list of "importing" VRFs?
244 static int is_vrf_present_in_irt_vrfs(struct list
*vrfs
, struct bgp
*bgp_vrf
)
246 struct listnode
*node
= NULL
, *nnode
= NULL
;
247 struct bgp
*tmp_bgp_vrf
= NULL
;
249 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, tmp_bgp_vrf
)) {
250 if (tmp_bgp_vrf
== bgp_vrf
)
257 * Make import route target hash key.
259 static unsigned int import_rt_hash_key_make(void *p
)
261 struct irt_node
*irt
= p
;
262 char *pnt
= irt
->rt
.val
;
264 return jhash(pnt
, 8, 0xdeadbeef);
268 * Comparison function for import rt hash
270 static int import_rt_hash_cmp(const void *p1
, const void *p2
)
272 const struct irt_node
*irt1
= p1
;
273 const struct irt_node
*irt2
= p2
;
275 if (irt1
== NULL
&& irt2
== NULL
)
278 if (irt1
== NULL
|| irt2
== NULL
)
281 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
285 * Create a new import_rt
287 static struct irt_node
*import_rt_new(struct bgp
*bgp
,
288 struct ecommunity_val
*rt
)
290 struct irt_node
*irt
;
295 irt
= XCALLOC(MTYPE_BGP_EVPN_IMPORT_RT
, sizeof(struct irt_node
));
300 irt
->vnis
= list_new();
303 if (!hash_get(bgp
->import_rt_hash
, irt
, hash_alloc_intern
)) {
304 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
312 * Free the import rt node
314 static void import_rt_free(struct bgp
*bgp
, struct irt_node
*irt
)
316 hash_release(bgp
->import_rt_hash
, irt
);
317 list_delete_and_null(&irt
->vnis
);
318 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
322 * Function to lookup Import RT node - used to map a RT to set of
323 * VNIs importing routes with that RT.
325 static struct irt_node
*lookup_import_rt(struct bgp
*bgp
,
326 struct ecommunity_val
*rt
)
328 struct irt_node
*irt
;
331 memset(&tmp
, 0, sizeof(struct irt_node
));
332 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
333 irt
= hash_lookup(bgp
->import_rt_hash
, &tmp
);
338 * Is specified VNI present on the RT's list of "importing" VNIs?
340 static int is_vni_present_in_irt_vnis(struct list
*vnis
, struct bgpevpn
*vpn
)
342 struct listnode
*node
, *nnode
;
343 struct bgpevpn
*tmp_vpn
;
345 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, tmp_vpn
)) {
354 * Compare Route Targets.
356 static int evpn_route_target_cmp(struct ecommunity
*ecom1
,
357 struct ecommunity
*ecom2
)
365 if (!ecom1
&& !ecom2
)
368 if (ecom1
->str
&& !ecom2
->str
)
371 if (!ecom1
->str
&& ecom2
->str
)
374 if (!ecom1
->str
&& !ecom2
->str
)
377 return strcmp(ecom1
->str
, ecom2
->str
);
380 static void evpn_xxport_delete_ecomm(void *val
)
382 struct ecommunity
*ecomm
= val
;
383 ecommunity_free(&ecomm
);
387 * Mask off global-admin field of specified extended community (RT),
388 * just retain the local-admin field.
390 static inline void mask_ecom_global_admin(struct ecommunity_val
*dst
,
391 struct ecommunity_val
*src
)
397 if (type
== ECOMMUNITY_ENCODE_AS
) {
398 dst
->val
[2] = dst
->val
[3] = 0;
399 } else if (type
== ECOMMUNITY_ENCODE_AS4
400 || type
== ECOMMUNITY_ENCODE_IP
) {
401 dst
->val
[2] = dst
->val
[3] = 0;
402 dst
->val
[4] = dst
->val
[5] = 0;
407 * Map one RT to specified VRF.
408 * bgp_vrf = BGP vrf instance
410 static void map_vrf_to_rt(struct bgp
*bgp_vrf
, struct ecommunity_val
*eval
)
412 struct vrf_irt_node
*irt
= NULL
;
413 struct ecommunity_val eval_tmp
;
415 /* If using "automatic" RT,
416 * we only care about the local-admin sub-field.
417 * This is to facilitate using L3VNI(VRF-VNI)
418 * as the RT for EBGP peering too.
420 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
421 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
422 mask_ecom_global_admin(&eval_tmp
, eval
);
424 irt
= lookup_vrf_import_rt(&eval_tmp
);
425 if (irt
&& is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
426 /* Already mapped. */
430 irt
= vrf_import_rt_new(&eval_tmp
);
432 /* Add VRF to the list for this RT. */
433 listnode_add(irt
->vrfs
, bgp_vrf
);
437 * Unmap specified VRF from specified RT. If there are no other
438 * VRFs for this RT, then the RT hash is deleted.
439 * bgp_vrf: BGP VRF specific instance
441 static void unmap_vrf_from_rt(struct bgp
*bgp_vrf
, struct vrf_irt_node
*irt
)
443 /* Delete VRF from list for this RT. */
444 listnode_delete(irt
->vrfs
, bgp_vrf
);
445 if (!listnode_head(irt
->vrfs
)) {
446 vrf_import_rt_free(irt
);
451 * Map one RT to specified VNI.
453 static void map_vni_to_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
454 struct ecommunity_val
*eval
)
456 struct irt_node
*irt
;
457 struct ecommunity_val eval_tmp
;
459 /* If using "automatic" RT, we only care about the local-admin
461 * This is to facilitate using VNI as the RT for EBGP peering too.
463 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
464 if (!is_import_rt_configured(vpn
))
465 mask_ecom_global_admin(&eval_tmp
, eval
);
467 irt
= lookup_import_rt(bgp
, &eval_tmp
);
469 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
470 /* Already mapped. */
474 irt
= import_rt_new(bgp
, &eval_tmp
);
478 /* Add VNI to the hash list for this RT. */
479 listnode_add(irt
->vnis
, vpn
);
483 * Unmap specified VNI from specified RT. If there are no other
484 * VNIs for this RT, then the RT hash is deleted.
486 static void unmap_vni_from_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
487 struct irt_node
*irt
)
489 /* Delete VNI from hash list for this RT. */
490 listnode_delete(irt
->vnis
, vpn
);
491 if (!listnode_head(irt
->vnis
)) {
492 import_rt_free(bgp
, irt
);
497 * Create RT extended community automatically from passed information:
498 * of the form AS:VNI.
499 * NOTE: We use only the lower 16 bits of the AS. This is sufficient as
500 * the need is to get a RT value that will be unique across different
501 * VNIs but the same across routers (in the same AS) for a particular
504 static void form_auto_rt(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
506 struct ecommunity_val eval
;
507 struct ecommunity
*ecomadd
;
509 if (bgp
->advertise_autort_rfc8365
)
510 vni
|= EVPN_AUTORT_VXLAN
;
511 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
513 ecomadd
= ecommunity_new();
514 ecommunity_add_val(ecomadd
, &eval
);
515 listnode_add_sort(rtl
, ecomadd
);
519 * Derive RD and RT for a VNI automatically. Invoked at the time of
522 static void derive_rd_rt_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
524 bgp_evpn_derive_auto_rd(bgp
, vpn
);
525 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
526 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
530 * Convert nexthop (remote VTEP IP) into an IPv6 address.
532 static void evpn_convert_nexthop_to_ipv6(struct attr
*attr
)
534 if (BGP_ATTR_NEXTHOP_AFI_IP6(attr
))
536 ipv4_to_ipv4_mapped_ipv6(&attr
->mp_nexthop_global
, attr
->nexthop
);
537 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
541 * Add (update) or delete MACIP from zebra.
543 static int bgp_zebra_send_remote_macip(struct bgp
*bgp
, struct bgpevpn
*vpn
,
544 struct prefix_evpn
*p
,
545 struct in_addr remote_vtep_ip
, int add
,
546 uint8_t flags
, uint32_t seq
)
550 char buf1
[ETHER_ADDR_STRLEN
];
551 char buf2
[INET6_ADDRSTRLEN
];
552 char buf3
[INET6_ADDRSTRLEN
];
555 if (!zclient
|| zclient
->sock
< 0)
558 /* Don't try to register if Zebra doesn't know of this instance. */
559 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
565 zclient_create_header(
566 s
, add
? ZEBRA_REMOTE_MACIP_ADD
: ZEBRA_REMOTE_MACIP_DEL
,
568 stream_putl(s
, vpn
->vni
);
569 stream_put(s
, &p
->prefix
.macip_addr
.mac
.octet
, ETH_ALEN
); /* Mac Addr */
570 /* IP address length and IP address, if any. */
571 if (is_evpn_prefix_ipaddr_none(p
))
574 ipa_len
= is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BYTELEN
576 stream_putl(s
, ipa_len
);
577 stream_put(s
, &p
->prefix
.macip_addr
.ip
.ip
.addr
, ipa_len
);
579 stream_put_in_addr(s
, &remote_vtep_ip
);
581 /* TX flags - MAC sticky status and/or gateway mac */
582 /* Also TX the sequence number of the best route. */
584 stream_putc(s
, flags
);
588 stream_putw_at(s
, 0, stream_get_endp(s
));
590 if (bgp_debug_zebra(NULL
))
592 "Tx %s MACIP, VNI %u MAC %s IP %s flags 0x%x seq %u remote VTEP %s",
593 add
? "ADD" : "DEL", vpn
->vni
,
594 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
596 ipaddr2str(&p
->prefix
.macip_addr
.ip
,
597 buf3
, sizeof(buf3
)), flags
, seq
,
598 inet_ntop(AF_INET
, &remote_vtep_ip
, buf2
,
601 return zclient_send_message(zclient
);
605 * Add (update) or delete remote VTEP from zebra.
607 static int bgp_zebra_send_remote_vtep(struct bgp
*bgp
, struct bgpevpn
*vpn
,
608 struct prefix_evpn
*p
, int add
)
613 if (!zclient
|| zclient
->sock
< 0)
616 /* Don't try to register if Zebra doesn't know of this instance. */
617 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
623 zclient_create_header(
624 s
, add
? ZEBRA_REMOTE_VTEP_ADD
: ZEBRA_REMOTE_VTEP_DEL
,
626 stream_putl(s
, vpn
->vni
);
627 if (is_evpn_prefix_ipaddr_v4(p
))
628 stream_put_in_addr(s
, &p
->prefix
.imet_addr
.ip
.ipaddr_v4
);
629 else if (is_evpn_prefix_ipaddr_v6(p
)) {
631 BGP_ERR_VTEP_INVALID
,
632 "Bad remote IP when trying to %s remote VTEP for VNI %u",
633 add
? "ADD" : "DEL", vpn
->vni
);
637 stream_putw_at(s
, 0, stream_get_endp(s
));
639 if (bgp_debug_zebra(NULL
))
640 zlog_debug("Tx %s Remote VTEP, VNI %u remote VTEP %s",
641 add
? "ADD" : "DEL", vpn
->vni
,
642 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
644 return zclient_send_message(zclient
);
648 * Build extended community for EVPN ES (type-4) route
650 static void build_evpn_type4_route_extcomm(struct evpnes
*es
,
653 struct ecommunity ecom_encap
;
654 struct ecommunity ecom_es_rt
;
655 struct ecommunity_val eval
;
656 struct ecommunity_val eval_es_rt
;
657 bgp_encap_types tnl_type
;
661 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
662 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
663 encode_encap_extcomm(tnl_type
, &eval
);
665 ecom_encap
.val
= (uint8_t *)eval
.val
;
666 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
669 memset(&mac
, 0, sizeof(struct ethaddr
));
670 memset(&ecom_es_rt
, 0, sizeof(ecom_es_rt
));
671 es_get_system_mac(&es
->esi
, &mac
);
672 encode_es_rt_extcomm(&eval_es_rt
, &mac
);
674 ecom_es_rt
.val
= (uint8_t *)eval_es_rt
.val
;
676 ecommunity_merge(attr
->ecommunity
, &ecom_es_rt
);
678 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
682 * Build extended communities for EVPN prefix route.
684 static void build_evpn_type5_route_extcomm(struct bgp
*bgp_vrf
,
687 struct ecommunity ecom_encap
;
688 struct ecommunity ecom_rmac
;
689 struct ecommunity_val eval
;
690 struct ecommunity_val eval_rmac
;
691 bgp_encap_types tnl_type
;
692 struct listnode
*node
, *nnode
;
693 struct ecommunity
*ecom
;
694 struct list
*vrf_export_rtl
= NULL
;
697 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
698 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
699 encode_encap_extcomm(tnl_type
, &eval
);
701 ecom_encap
.val
= (uint8_t *)eval
.val
;
704 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
706 /* Add the export RTs for L3VNI/VRF */
707 vrf_export_rtl
= bgp_vrf
->vrf_export_rtl
;
708 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
, ecom
))
710 ecommunity_merge(attr
->ecommunity
, ecom
);
712 /* add the router mac extended community */
713 if (!is_zero_mac(&attr
->rmac
)) {
714 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
715 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
717 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
719 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
722 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
726 * Build extended communities for EVPN route.
727 * This function is applicable for type-2 and type-3 routes. The layer-2 RT
728 * and ENCAP extended communities are applicable for all routes.
729 * The default gateway extended community and MAC mobility (sticky) extended
730 * community are added as needed based on passed settings - only for type-2
731 * routes. Likewise, the layer-3 RT and Router MAC extended communities are
732 * added, if present, based on passed settings - only for non-link-local
735 static void build_evpn_route_extcomm(struct bgpevpn
*vpn
, struct attr
*attr
,
738 struct ecommunity ecom_encap
;
739 struct ecommunity ecom_sticky
;
740 struct ecommunity ecom_default_gw
;
741 struct ecommunity ecom_rmac
;
742 struct ecommunity ecom_na
;
743 struct ecommunity_val eval
;
744 struct ecommunity_val eval_sticky
;
745 struct ecommunity_val eval_default_gw
;
746 struct ecommunity_val eval_rmac
;
747 struct ecommunity_val eval_na
;
749 bgp_encap_types tnl_type
;
750 struct listnode
*node
, *nnode
;
751 struct ecommunity
*ecom
;
753 struct list
*vrf_export_rtl
= NULL
;
756 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
757 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
758 encode_encap_extcomm(tnl_type
, &eval
);
760 ecom_encap
.val
= (uint8_t *)eval
.val
;
763 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
765 /* Add the export RTs for L2VNI */
766 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
))
767 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
, ecom
);
769 /* Add the export RTs for L3VNI if told to - caller determines
770 * when this should be done.
773 vrf_export_rtl
= bgpevpn_get_vrf_export_rtl(vpn
);
774 if (vrf_export_rtl
&& !list_isempty(vrf_export_rtl
)) {
775 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
,
777 attr
->ecommunity
= ecommunity_merge(
778 attr
->ecommunity
, ecom
);
782 /* Add MAC mobility (sticky) if needed. */
785 memset(&ecom_sticky
, 0, sizeof(ecom_sticky
));
786 encode_mac_mobility_extcomm(1, seqnum
, &eval_sticky
);
787 ecom_sticky
.size
= 1;
788 ecom_sticky
.val
= (uint8_t *)eval_sticky
.val
;
790 ecommunity_merge(attr
->ecommunity
, &ecom_sticky
);
793 /* Add RMAC, if told to. */
795 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
796 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
798 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
800 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
803 /* Add default gateway, if needed. */
804 if (attr
->default_gw
) {
805 memset(&ecom_default_gw
, 0, sizeof(ecom_default_gw
));
806 encode_default_gw_extcomm(&eval_default_gw
);
807 ecom_default_gw
.size
= 1;
808 ecom_default_gw
.val
= (uint8_t *)eval_default_gw
.val
;
810 ecommunity_merge(attr
->ecommunity
, &ecom_default_gw
);
813 if (attr
->router_flag
) {
814 memset(&ecom_na
, 0, sizeof(ecom_na
));
815 encode_na_flag_extcomm(&eval_na
, attr
->router_flag
);
817 ecom_na
.val
= (uint8_t *)eval_na
.val
;
818 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
,
822 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
826 * Add MAC mobility extended community to attribute.
828 static void add_mac_mobility_to_attr(uint32_t seq_num
, struct attr
*attr
)
830 struct ecommunity ecom_tmp
;
831 struct ecommunity_val eval
;
832 uint8_t *ecom_val_ptr
;
839 encode_mac_mobility_extcomm(0, seq_num
, &eval
);
841 /* Find current MM ecommunity */
844 if (attr
->ecommunity
) {
845 for (i
= 0; i
< attr
->ecommunity
->size
; i
++) {
846 pnt
= attr
->ecommunity
->val
+ (i
* 8);
850 if (type
== ECOMMUNITY_ENCODE_EVPN
852 == ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY
) {
853 ecom_val_ptr
= (uint8_t *)(attr
->ecommunity
->val
860 /* Update the existing MM ecommunity */
862 memcpy(ecom_val_ptr
, eval
.val
, sizeof(char) * ECOMMUNITY_SIZE
);
864 /* Add MM to existing */
866 memset(&ecom_tmp
, 0, sizeof(ecom_tmp
));
868 ecom_tmp
.val
= (uint8_t *)eval
.val
;
870 if (attr
->ecommunity
)
872 ecommunity_merge(attr
->ecommunity
, &ecom_tmp
);
874 attr
->ecommunity
= ecommunity_dup(&ecom_tmp
);
878 /* Install EVPN route into zebra. */
879 static int evpn_zebra_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
880 struct prefix_evpn
*p
,
881 struct in_addr remote_vtep_ip
, uint8_t flags
,
886 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
887 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
890 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 1);
895 /* Uninstall EVPN route from zebra. */
896 static int evpn_zebra_uninstall(struct bgp
*bgp
, struct bgpevpn
*vpn
,
897 struct prefix_evpn
*p
,
898 struct in_addr remote_vtep_ip
)
902 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
903 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
906 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 0);
912 * Due to MAC mobility, the prior "local" best route has been supplanted
913 * by a "remote" best route. The prior route has to be deleted and withdrawn
916 static void evpn_delete_old_local_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
918 struct bgp_info
*old_local
)
920 struct bgp_node
*global_rn
;
922 afi_t afi
= AFI_L2VPN
;
923 safi_t safi
= SAFI_EVPN
;
925 /* Locate route node in the global EVPN routing table. Note that
926 * this table is a 2-level tree (RD-level + Prefix-level) similar to
929 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
930 (struct prefix
*)&rn
->p
, &vpn
->prd
);
932 /* Delete route entry in the global EVPN table. */
933 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &ri
);
935 /* Schedule for processing - withdraws to peers happen from
939 bgp_process(bgp
, global_rn
, afi
, safi
);
940 bgp_unlock_node(global_rn
);
943 /* Delete route entry in the VNI route table, caller to remove. */
944 bgp_info_delete(rn
, old_local
);
947 static struct in_addr
*es_vtep_new(struct in_addr vtep
)
951 ip
= XCALLOC(MTYPE_BGP_EVPN_ES_VTEP
, sizeof(struct in_addr
));
955 ip
->s_addr
= vtep
.s_addr
;
959 static void es_vtep_free(struct in_addr
*ip
)
961 XFREE(MTYPE_BGP_EVPN_ES_VTEP
, ip
);
964 /* check if VTEP is already part of the list */
965 static int is_vtep_present_in_list(struct list
*list
,
968 struct listnode
*node
= NULL
;
971 for (ALL_LIST_ELEMENTS_RO(list
, node
, tmp
)) {
972 if (tmp
->s_addr
== vtep
.s_addr
)
979 * Best path for ES route was changed,
980 * update the list of VTEPs for this ES
982 static int evpn_es_install_vtep(struct bgp
*bgp
,
984 struct prefix_evpn
*p
,
985 struct in_addr rvtep
)
987 struct in_addr
*vtep_ip
;
989 if (is_vtep_present_in_list(es
->vtep_list
, rvtep
))
993 vtep_ip
= es_vtep_new(rvtep
);
995 listnode_add_sort(es
->vtep_list
, vtep_ip
);
1000 * Best path for ES route was changed,
1001 * update the list of VTEPs for this ES
1003 static int evpn_es_uninstall_vtep(struct bgp
*bgp
,
1005 struct prefix_evpn
*p
,
1006 struct in_addr rvtep
)
1008 struct listnode
*node
, *nnode
, *node_to_del
= NULL
;
1009 struct in_addr
*tmp
;
1011 for (ALL_LIST_ELEMENTS(es
->vtep_list
, node
, nnode
, tmp
)) {
1012 if (tmp
->s_addr
== rvtep
.s_addr
) {
1019 list_delete_node(es
->vtep_list
, node_to_del
);
1025 * Calculate the best path for a ES(type-4) route.
1027 static int evpn_es_route_select_install(struct bgp
*bgp
,
1029 struct bgp_node
*rn
)
1032 afi_t afi
= AFI_L2VPN
;
1033 safi_t safi
= SAFI_EVPN
;
1034 struct bgp_info
*old_select
; /* old best */
1035 struct bgp_info
*new_select
; /* new best */
1036 struct bgp_info_pair old_and_new
;
1038 /* Compute the best path. */
1039 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
],
1040 &old_and_new
, afi
, safi
);
1041 old_select
= old_and_new
.old
;
1042 new_select
= old_and_new
.new;
1045 * If the best path hasn't changed - see if something needs to be
1048 if (old_select
&& old_select
== new_select
1049 && old_select
->type
== ZEBRA_ROUTE_BGP
1050 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
1051 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
1052 && !CHECK_FLAG(old_select
->flags
, BGP_INFO_ATTR_CHANGED
)
1053 && !bgp
->addpath_tx_used
[afi
][safi
]) {
1054 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
1055 ret
= evpn_es_install_vtep(bgp
, es
,
1056 (struct prefix_evpn
*)&rn
->p
,
1057 old_select
->attr
->nexthop
);
1059 UNSET_FLAG(old_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
1060 bgp_zebra_clear_route_change_flags(rn
);
1064 /* If the user did a "clear" this flag will be set */
1065 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
1068 * bestpath has changed; update relevant fields and install or uninstall
1069 * into the zebra RIB.
1071 if (old_select
|| new_select
)
1072 bgp_bump_version(rn
);
1075 bgp_info_unset_flag(rn
, old_select
, BGP_INFO_SELECTED
);
1077 bgp_info_set_flag(rn
, new_select
, BGP_INFO_SELECTED
);
1078 bgp_info_unset_flag(rn
, new_select
, BGP_INFO_ATTR_CHANGED
);
1079 UNSET_FLAG(new_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
1082 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
1083 && new_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1084 ret
= evpn_es_install_vtep(bgp
, es
,
1085 (struct prefix_evpn
*)&rn
->p
,
1086 new_select
->attr
->nexthop
);
1088 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
1089 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
)
1090 ret
= evpn_es_uninstall_vtep(
1091 bgp
, es
, (struct prefix_evpn
*)&rn
->p
,
1092 old_select
->attr
->nexthop
);
1095 /* Clear any route change flags. */
1096 bgp_zebra_clear_route_change_flags(rn
);
1098 /* Reap old select bgp_info, if it has been removed */
1099 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_INFO_REMOVED
))
1100 bgp_info_reap(rn
, old_select
);
1106 * Calculate the best path for an EVPN route. Install/update best path in zebra,
1109 static int evpn_route_select_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1110 struct bgp_node
*rn
)
1112 struct bgp_info
*old_select
, *new_select
;
1113 struct bgp_info_pair old_and_new
;
1114 struct prefix_evpn
*evp
;
1115 afi_t afi
= AFI_L2VPN
;
1116 safi_t safi
= SAFI_EVPN
;
1120 /* Compute the best path. */
1121 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
], &old_and_new
,
1123 old_select
= old_and_new
.old
;
1124 new_select
= old_and_new
.new;
1126 evp
= (struct prefix_evpn
*)&rn
->p
;
1127 /* If the best path hasn't changed - see if there is still something to
1131 if (old_select
&& old_select
== new_select
1132 && old_select
->type
== ZEBRA_ROUTE_BGP
1133 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
1134 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
1135 && !CHECK_FLAG(old_select
->flags
, BGP_INFO_ATTR_CHANGED
)
1136 && !bgp
->addpath_tx_used
[afi
][safi
]) {
1137 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
1138 if (old_select
->attr
->sticky
)
1139 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1140 if (old_select
->attr
->default_gw
)
1141 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1142 if (is_evpn_prefix_ipaddr_v6(evp
) &&
1143 old_select
->attr
->router_flag
)
1144 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
1146 ret
= evpn_zebra_install(
1147 bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1148 old_select
->attr
->nexthop
, flags
,
1149 mac_mobility_seqnum(old_select
->attr
));
1151 UNSET_FLAG(old_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
1152 bgp_zebra_clear_route_change_flags(rn
);
1156 /* If the user did a "clear" this flag will be set */
1157 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
1159 /* bestpath has changed; update relevant fields and install or uninstall
1160 * into the zebra RIB.
1162 if (old_select
|| new_select
)
1163 bgp_bump_version(rn
);
1166 bgp_info_unset_flag(rn
, old_select
, BGP_INFO_SELECTED
);
1168 bgp_info_set_flag(rn
, new_select
, BGP_INFO_SELECTED
);
1169 bgp_info_unset_flag(rn
, new_select
, BGP_INFO_ATTR_CHANGED
);
1170 UNSET_FLAG(new_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
1173 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
1174 && new_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1176 if (new_select
->attr
->sticky
)
1177 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1178 if (new_select
->attr
->default_gw
)
1179 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1180 if (is_evpn_prefix_ipaddr_v6(evp
) &&
1181 new_select
->attr
->router_flag
)
1182 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
1184 ret
= evpn_zebra_install(bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1185 new_select
->attr
->nexthop
, flags
,
1186 mac_mobility_seqnum(new_select
->attr
));
1187 /* If an old best existed and it was a "local" route, the only
1189 * it would be supplanted is due to MAC mobility procedures. So,
1191 * need to do an implicit delete and withdraw that route from
1194 if (old_select
&& old_select
->peer
== bgp
->peer_self
1195 && old_select
->type
== ZEBRA_ROUTE_BGP
1196 && old_select
->sub_type
== BGP_ROUTE_STATIC
)
1197 evpn_delete_old_local_route(bgp
, vpn
, rn
, old_select
);
1199 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
1200 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
)
1201 ret
= evpn_zebra_uninstall(bgp
, vpn
,
1202 (struct prefix_evpn
*)&rn
->p
,
1203 old_select
->attr
->nexthop
);
1206 /* Clear any route change flags. */
1207 bgp_zebra_clear_route_change_flags(rn
);
1209 /* Reap old select bgp_info, if it has been removed */
1210 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_INFO_REMOVED
))
1211 bgp_info_reap(rn
, old_select
);
1217 * Return true if the local ri for this rn is of type gateway mac
1219 static int evpn_route_is_def_gw(struct bgp
*bgp
, struct bgp_node
*rn
)
1221 struct bgp_info
*tmp_ri
= NULL
;
1222 struct bgp_info
*local_ri
= NULL
;
1225 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1226 if (tmp_ri
->peer
== bgp
->peer_self
1227 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1228 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1235 return local_ri
->attr
->default_gw
;
1240 * Return true if the local ri for this rn has sticky set
1242 static int evpn_route_is_sticky(struct bgp
*bgp
, struct bgp_node
*rn
)
1244 struct bgp_info
*tmp_ri
;
1245 struct bgp_info
*local_ri
;
1248 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1249 if (tmp_ri
->peer
== bgp
->peer_self
1250 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1251 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1258 return local_ri
->attr
->sticky
;
1262 * create or update EVPN type4 route entry.
1263 * This could be in the ES table or the global table.
1264 * TODO: handle remote ES (type4) routes as well
1266 static int update_evpn_type4_route_entry(struct bgp
*bgp
,
1268 afi_t afi
, safi_t safi
,
1269 struct bgp_node
*rn
,
1272 struct bgp_info
**ri
,
1275 char buf
[ESI_STR_LEN
];
1276 char buf1
[INET6_ADDRSTRLEN
];
1277 struct bgp_info
*tmp_ri
= NULL
;
1278 struct bgp_info
*local_ri
= NULL
; /* local route entry if any */
1279 struct bgp_info
*remote_ri
= NULL
; /* remote route entry if any */
1280 struct attr
*attr_new
= NULL
;
1281 struct prefix_evpn
*evp
= NULL
;
1285 evp
= (struct prefix_evpn
*)&rn
->p
;
1287 /* locate the local and remote entries if any */
1288 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1289 if (tmp_ri
->peer
== bgp
->peer_self
&&
1290 tmp_ri
->type
== ZEBRA_ROUTE_BGP
&&
1291 tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1293 if (tmp_ri
->type
== ZEBRA_ROUTE_BGP
&&
1294 tmp_ri
->sub_type
== BGP_ROUTE_IMPORTED
&&
1295 CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
))
1299 /* we don't expect to see a remote_ri at this point.
1300 * An ES route has esi + vtep_ip as the key,
1301 * We shouldn't see the same route from any other vtep.
1306 "%u ERROR: local es route for ESI: %s Vtep %s also learnt from remote",
1308 esi_to_str(&evp
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)),
1309 ipaddr2str(&es
->originator_ip
, buf1
, sizeof(buf1
)));
1313 if (!local_ri
&& !add
)
1316 /* create or update the entry */
1319 /* Add or update attribute to hash */
1320 attr_new
= bgp_attr_intern(attr
);
1322 /* Create new route with its attribute. */
1323 tmp_ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
,
1324 0, bgp
->peer_self
, attr_new
, rn
);
1325 SET_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
);
1327 /* add the newly created path to the route-node */
1328 bgp_info_add(rn
, tmp_ri
);
1331 if (attrhash_cmp(tmp_ri
->attr
, attr
)
1332 && !CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1335 /* The attribute has changed.
1336 * Add (or update) attribute to hash. */
1337 attr_new
= bgp_attr_intern(attr
);
1338 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1340 /* Restore route, if needed. */
1341 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1342 bgp_info_restore(rn
, tmp_ri
);
1344 /* Unintern existing, set to new. */
1345 bgp_attr_unintern(&tmp_ri
->attr
);
1346 tmp_ri
->attr
= attr_new
;
1347 tmp_ri
->uptime
= bgp_clock();
1351 /* Return back the route entry. */
1356 /* update evpn es (type-4) route */
1357 static int update_evpn_type4_route(struct bgp
*bgp
,
1359 struct prefix_evpn
*p
)
1362 int route_changed
= 0;
1363 char buf
[ESI_STR_LEN
];
1364 char buf1
[INET6_ADDRSTRLEN
];
1365 afi_t afi
= AFI_L2VPN
;
1366 safi_t safi
= SAFI_EVPN
;
1368 struct attr
*attr_new
= NULL
;
1369 struct bgp_node
*rn
= NULL
;
1370 struct bgp_info
*ri
= NULL
;
1372 memset(&attr
, 0, sizeof(struct attr
));
1374 /* Build path-attribute for this route. */
1375 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1376 attr
.nexthop
= es
->originator_ip
.ipaddr_v4
;
1377 attr
.mp_nexthop_global_in
= es
->originator_ip
.ipaddr_v4
;
1378 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1380 /* Set up extended community. */
1381 build_evpn_type4_route_extcomm(es
, &attr
);
1383 /* First, create (or fetch) route node within the ESI. */
1384 /* NOTE: There is no RD here. */
1385 rn
= bgp_node_get(es
->route_table
, (struct prefix
*)p
);
1387 /* Create or update route entry. */
1388 ret
= update_evpn_type4_route_entry(bgp
, es
, afi
, safi
, rn
,
1394 "%u ERROR: Failed to updated ES route ESI: %s VTEP %s",
1396 esi_to_str(&p
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)),
1397 ipaddr2str(&es
->originator_ip
, buf1
, sizeof(buf1
)));
1401 attr_new
= ri
->attr
;
1403 /* Perform route selection;
1404 * this is just to set the flags correctly
1405 * as local route in the ES always wins.
1407 evpn_es_route_select_install(bgp
, es
, rn
);
1408 bgp_unlock_node(rn
);
1410 /* If this is a new route or some attribute has changed, export the
1411 * route to the global table. The route will be advertised to peers
1412 * from there. Note that this table is a 2-level tree (RD-level +
1413 * Prefix-level) similar to L3VPN routes.
1415 if (route_changed
) {
1416 struct bgp_info
*global_ri
;
1418 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1419 (struct prefix
*)p
, &es
->prd
);
1420 update_evpn_type4_route_entry(bgp
, es
, afi
, safi
,
1425 /* Schedule for processing and unlock node. */
1426 bgp_process(bgp
, rn
, afi
, safi
);
1427 bgp_unlock_node(rn
);
1430 /* Unintern temporary. */
1431 aspath_unintern(&attr
.aspath
);
1435 static int update_evpn_type5_route_entry(struct bgp
*bgp_def
,
1436 struct bgp
*bgp_vrf
, afi_t afi
,
1437 safi_t safi
, struct bgp_node
*rn
,
1438 struct attr
*attr
, int *route_changed
)
1440 struct attr
*attr_new
= NULL
;
1441 struct bgp_info
*ri
= NULL
;
1442 mpls_label_t label
= MPLS_INVALID_LABEL
;
1443 struct bgp_info
*local_ri
= NULL
;
1444 struct bgp_info
*tmp_ri
= NULL
;
1447 /* locate the local route entry if any */
1448 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1449 if (tmp_ri
->peer
== bgp_def
->peer_self
1450 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1451 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1456 * create a new route entry if one doesnt exist.
1457 * Otherwise see if route attr has changed
1461 /* route has changed as this is the first entry */
1464 /* Add (or update) attribute to hash. */
1465 attr_new
= bgp_attr_intern(attr
);
1467 /* create the route info from attribute */
1468 ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1469 bgp_def
->peer_self
, attr_new
, rn
);
1470 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
1472 /* Type-5 routes advertise the L3-VNI */
1473 bgp_info_extra_get(ri
);
1474 vni2label(bgp_vrf
->l3vni
, &label
);
1475 memcpy(&ri
->extra
->label
, &label
, sizeof(label
));
1476 ri
->extra
->num_labels
= 1;
1478 /* add the route entry to route node*/
1479 bgp_info_add(rn
, ri
);
1483 if (!attrhash_cmp(tmp_ri
->attr
, attr
)) {
1485 /* attribute changed */
1488 /* The attribute has changed. */
1489 /* Add (or update) attribute to hash. */
1490 attr_new
= bgp_attr_intern(attr
);
1491 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1493 /* Restore route, if needed. */
1494 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1495 bgp_info_restore(rn
, tmp_ri
);
1497 /* Unintern existing, set to new. */
1498 bgp_attr_unintern(&tmp_ri
->attr
);
1499 tmp_ri
->attr
= attr_new
;
1500 tmp_ri
->uptime
= bgp_clock();
1506 /* update evpn type-5 route entry */
1507 static int update_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
,
1508 struct attr
*src_attr
)
1510 afi_t afi
= AFI_L2VPN
;
1511 safi_t safi
= SAFI_EVPN
;
1513 struct bgp_node
*rn
= NULL
;
1514 struct bgp
*bgp_def
= NULL
;
1515 int route_changed
= 0;
1517 bgp_def
= bgp_get_default();
1521 /* Build path attribute for this route - use the source attr, if
1522 * present, else treat as locally originated.
1525 bgp_attr_dup(&attr
, src_attr
);
1527 memset(&attr
, 0, sizeof(struct attr
));
1528 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1530 /* Set nexthop to ourselves and fill in the Router MAC. */
1531 attr
.nexthop
= bgp_vrf
->originator_ip
;
1532 attr
.mp_nexthop_global_in
= bgp_vrf
->originator_ip
;
1533 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1534 memcpy(&attr
.rmac
, &bgp_vrf
->rmac
, sizeof(struct ethaddr
));
1536 /* Setup RT and encap extended community */
1537 build_evpn_type5_route_extcomm(bgp_vrf
, &attr
);
1539 /* get the route node in global table */
1540 rn
= bgp_afi_node_get(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1541 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1544 /* create or update the route entry within the route node */
1545 update_evpn_type5_route_entry(bgp_def
, bgp_vrf
, afi
, safi
, rn
, &attr
,
1548 /* schedule for processing and unlock node */
1549 if (route_changed
) {
1550 bgp_process(bgp_def
, rn
, afi
, safi
);
1551 bgp_unlock_node(rn
);
1554 /* uninten temporary */
1556 aspath_unintern(&attr
.aspath
);
1561 * Create or update EVPN route entry. This could be in the VNI route table
1562 * or the global route table.
1564 static int update_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1565 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
1566 struct attr
*attr
, int add
,
1567 struct bgp_info
**ri
, uint8_t flags
,
1570 struct bgp_info
*tmp_ri
;
1571 struct bgp_info
*local_ri
;
1572 struct attr
*attr_new
;
1573 mpls_label_t label
[BGP_MAX_LABELS
];
1574 uint32_t num_labels
= 1;
1575 int route_change
= 1;
1577 struct prefix_evpn
*evp
;
1580 evp
= (struct prefix_evpn
*)&rn
->p
;
1581 memset(&label
, 0, sizeof(label
));
1583 /* See if this is an update of an existing route, or a new add. */
1585 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1586 if (tmp_ri
->peer
== bgp
->peer_self
1587 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1588 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1592 /* If route doesn't exist already, create a new one, if told to.
1593 * Otherwise act based on whether the attributes of the route have
1596 if (!local_ri
&& !add
)
1599 /* For non-GW MACs, update MAC mobility seq number, if needed. */
1600 if (seq
&& !CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
))
1601 add_mac_mobility_to_attr(seq
, attr
);
1604 /* Add (or update) attribute to hash. */
1605 attr_new
= bgp_attr_intern(attr
);
1607 /* Extract MAC mobility sequence number, if any. */
1608 attr_new
->mm_seqnum
=
1609 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1610 attr_new
->sticky
= sticky
;
1612 /* Create new route with its attribute. */
1613 tmp_ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1614 bgp
->peer_self
, attr_new
, rn
);
1615 SET_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
);
1616 bgp_info_extra_get(tmp_ri
);
1618 /* The VNI goes into the 'label' field of the route */
1619 vni2label(vpn
->vni
, &label
[0]);
1621 /* Type-2 routes may carry a second VNI - the L3-VNI.
1622 * Only attach second label if we are advertising two labels for
1625 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1626 && CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
)) {
1629 l3vni
= bgpevpn_get_l3vni(vpn
);
1631 vni2label(l3vni
, &label
[1]);
1636 memcpy(&tmp_ri
->extra
->label
, label
, sizeof(label
));
1637 tmp_ri
->extra
->num_labels
= num_labels
;
1638 bgp_info_add(rn
, tmp_ri
);
1641 if (attrhash_cmp(tmp_ri
->attr
, attr
)
1642 && !CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1646 * The attributes have changed, type-2 routes needs to
1647 * be advertised with right labels.
1649 vni2label(vpn
->vni
, &label
[0]);
1650 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1651 && CHECK_FLAG(vpn
->flags
,
1652 VNI_FLAG_USE_TWO_LABELS
)) {
1655 l3vni
= bgpevpn_get_l3vni(vpn
);
1657 vni2label(l3vni
, &label
[1]);
1661 memcpy(&tmp_ri
->extra
->label
, label
, sizeof(label
));
1662 tmp_ri
->extra
->num_labels
= num_labels
;
1664 /* The attribute has changed. */
1665 /* Add (or update) attribute to hash. */
1666 attr_new
= bgp_attr_intern(attr
);
1667 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1669 /* Extract MAC mobility sequence number, if any. */
1670 attr_new
->mm_seqnum
=
1671 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1672 attr_new
->sticky
= sticky
;
1674 /* Restore route, if needed. */
1675 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1676 bgp_info_restore(rn
, tmp_ri
);
1678 /* Unintern existing, set to new. */
1679 bgp_attr_unintern(&tmp_ri
->attr
);
1680 tmp_ri
->attr
= attr_new
;
1681 tmp_ri
->uptime
= bgp_clock();
1685 /* Return back the route entry. */
1687 return route_change
;
1691 * Create or update EVPN route (of type based on prefix) for specified VNI
1692 * and schedule for processing.
1694 static int update_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1695 struct prefix_evpn
*p
, uint8_t flags
,
1698 struct bgp_node
*rn
;
1700 struct attr
*attr_new
;
1701 int add_l3_ecomm
= 0;
1702 struct bgp_info
*ri
;
1703 afi_t afi
= AFI_L2VPN
;
1704 safi_t safi
= SAFI_EVPN
;
1707 memset(&attr
, 0, sizeof(struct attr
));
1709 /* Build path-attribute for this route. */
1710 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1711 attr
.nexthop
= vpn
->originator_ip
;
1712 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1713 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1714 attr
.sticky
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
) ? 1 : 0;
1715 attr
.default_gw
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
) ? 1 : 0;
1716 attr
.router_flag
= CHECK_FLAG(flags
,
1717 ZEBRA_MACIP_TYPE_ROUTER_FLAG
) ? 1 : 0;
1719 /* PMSI is only needed for type-3 routes */
1720 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
)
1721 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
);
1723 /* router mac is only needed for type-2 routes here. */
1724 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1725 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1726 vni2label(vpn
->vni
, &(attr
.label
));
1728 /* Include L3 VNI related RTs and RMAC for type-2 routes, if they're
1729 * IPv4 or IPv6 global addresses and we're advertising L3VNI with
1732 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
&&
1733 (is_evpn_prefix_ipaddr_v4(p
) ||
1734 !IN6_IS_ADDR_LINKLOCAL(&p
->prefix
.macip_addr
.ip
.ipaddr_v6
)) &&
1735 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
) &&
1736 bgpevpn_get_l3vni(vpn
))
1739 /* Set up extended community. */
1740 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
1742 /* First, create (or fetch) route node within the VNI. */
1743 /* NOTE: There is no RD here. */
1744 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
1746 /* Create or update route entry. */
1747 route_change
= update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &attr
,
1748 1, &ri
, flags
, seq
);
1750 attr_new
= ri
->attr
;
1752 /* Perform route selection; this is just to set the flags correctly
1753 * as local route in the VNI always wins.
1755 evpn_route_select_install(bgp
, vpn
, rn
);
1756 bgp_unlock_node(rn
);
1758 /* If this is a new route or some attribute has changed, export the
1759 * route to the global table. The route will be advertised to peers
1760 * from there. Note that this table is a 2-level tree (RD-level +
1761 * Prefix-level) similar to L3VPN routes.
1764 struct bgp_info
*global_ri
;
1766 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1767 (struct prefix
*)p
, &vpn
->prd
);
1768 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, attr_new
, 1,
1769 &global_ri
, flags
, seq
);
1771 /* Schedule for processing and unlock node. */
1772 bgp_process(bgp
, rn
, afi
, safi
);
1773 bgp_unlock_node(rn
);
1776 /* Unintern temporary. */
1777 aspath_unintern(&attr
.aspath
);
1783 * Delete EVPN route entry.
1784 * The entry can be in ESI/VNI table or the global table.
1786 static void delete_evpn_route_entry(struct bgp
*bgp
,
1787 afi_t afi
, safi_t safi
,
1788 struct bgp_node
*rn
,
1789 struct bgp_info
**ri
)
1791 struct bgp_info
*tmp_ri
;
1795 /* Now, find matching route. */
1796 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
)
1797 if (tmp_ri
->peer
== bgp
->peer_self
1798 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1799 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1804 /* Mark route for delete. */
1806 bgp_info_delete(rn
, tmp_ri
);
1811 /* Delete EVPN ES (type-4) route */
1812 static int delete_evpn_type4_route(struct bgp
*bgp
,
1814 struct prefix_evpn
*p
)
1816 afi_t afi
= AFI_L2VPN
;
1817 safi_t safi
= SAFI_EVPN
;
1818 struct bgp_info
*ri
;
1819 struct bgp_node
*rn
= NULL
; /* rn in esi table */
1820 struct bgp_node
*global_rn
= NULL
; /* rn in global table */
1822 /* First, locate the route node within the ESI.
1823 * If it doesn't exist, ther is nothing to do.
1824 * Note: there is no RD here.
1826 rn
= bgp_node_lookup(es
->route_table
, (struct prefix
*)p
);
1830 /* Next, locate route node in the global EVPN routing table.
1831 * Note that this table is a 2-level tree (RD-level + Prefix-level)
1833 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1834 (struct prefix
*)p
, &es
->prd
);
1837 /* Delete route entry in the global EVPN table. */
1838 delete_evpn_route_entry(bgp
, afi
, safi
,
1841 /* Schedule for processing - withdraws to peers happen from
1845 bgp_process(bgp
, global_rn
, afi
, safi
);
1846 bgp_unlock_node(global_rn
);
1850 * Delete route entry in the ESI route table.
1851 * This can just be removed.
1853 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &ri
);
1855 bgp_info_reap(rn
, ri
);
1856 bgp_unlock_node(rn
);
1860 /* Delete EVPN type5 route */
1861 static int delete_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
)
1863 afi_t afi
= AFI_L2VPN
;
1864 safi_t safi
= SAFI_EVPN
;
1865 struct bgp_node
*rn
= NULL
;
1866 struct bgp_info
*ri
= NULL
;
1867 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
1869 bgp_def
= bgp_get_default();
1873 /* locate the global route entry for this type-5 prefix */
1874 rn
= bgp_afi_node_lookup(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1875 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1879 delete_evpn_route_entry(bgp_def
, afi
, safi
, rn
, &ri
);
1881 bgp_process(bgp_def
, rn
, afi
, safi
);
1882 bgp_unlock_node(rn
);
1887 * Delete EVPN route (of type based on prefix) for specified VNI and
1888 * schedule for processing.
1890 static int delete_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1891 struct prefix_evpn
*p
)
1893 struct bgp_node
*rn
, *global_rn
;
1894 struct bgp_info
*ri
;
1895 afi_t afi
= AFI_L2VPN
;
1896 safi_t safi
= SAFI_EVPN
;
1898 /* First, locate the route node within the VNI. If it doesn't exist,
1900 * is nothing further to do.
1902 /* NOTE: There is no RD here. */
1903 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
1907 /* Next, locate route node in the global EVPN routing table. Note that
1908 * this table is a 2-level tree (RD-level + Prefix-level) similar to
1911 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1912 (struct prefix
*)p
, &vpn
->prd
);
1914 /* Delete route entry in the global EVPN table. */
1915 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &ri
);
1917 /* Schedule for processing - withdraws to peers happen from
1921 bgp_process(bgp
, global_rn
, afi
, safi
);
1922 bgp_unlock_node(global_rn
);
1925 /* Delete route entry in the VNI route table. This can just be removed.
1927 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &ri
);
1929 bgp_info_reap(rn
, ri
);
1930 bgp_unlock_node(rn
);
1936 * Update all type-2 (MACIP) local routes for this VNI - these should also
1937 * be scheduled for advertise to peers.
1939 static int update_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1943 struct bgp_node
*rn
;
1944 struct bgp_info
*ri
, *tmp_ri
;
1946 struct attr
*attr_new
;
1948 int add_l3_ecomm
= 0;
1953 /* Walk this VNI's route table and update local type-2 routes. For any
1954 * routes updated, update corresponding entry in the global table too.
1956 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1957 rn
= bgp_route_next(rn
)) {
1958 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1959 struct bgp_node
*rd_rn
;
1960 struct bgp_info
*global_ri
;
1962 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1965 /* Identify local route. */
1966 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1967 if (tmp_ri
->peer
== bgp
->peer_self
1968 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1969 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1977 * Build attribute per local route as the MAC mobility and
1978 * some other values could differ for different routes. The
1979 * attributes will be shared in the hash table.
1981 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1982 attr
.nexthop
= vpn
->originator_ip
;
1983 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1984 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1985 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1987 if (evpn_route_is_sticky(bgp
, rn
))
1989 else if (evpn_route_is_def_gw(bgp
, rn
)) {
1990 attr
.default_gw
= 1;
1991 if (is_evpn_prefix_ipaddr_v6(evp
))
1992 attr
.router_flag
= 1;
1995 /* Add L3 VNI RTs and RMAC for non IPv6 link-local if
1996 * using L3 VNI for type-2 routes also.
1998 if ((is_evpn_prefix_ipaddr_v4(evp
) ||
1999 !IN6_IS_ADDR_LINKLOCAL(
2000 &evp
->prefix
.macip_addr
.ip
.ipaddr_v6
)) &&
2001 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
) &&
2002 bgpevpn_get_l3vni(vpn
))
2005 /* Set up extended community. */
2006 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
2008 seq
= mac_mobility_seqnum(tmp_ri
->attr
);
2010 /* Update the route entry. */
2011 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
2012 &attr
, 0, &ri
, 0, seq
);
2014 /* Perform route selection; this is just to set the flags
2015 * correctly as local route in the VNI always wins.
2017 evpn_route_select_install(bgp
, vpn
, rn
);
2019 attr_new
= ri
->attr
;
2021 /* Update route in global routing table. */
2022 rd_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
2023 (struct prefix
*)evp
, &vpn
->prd
);
2025 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rd_rn
, attr_new
, 0,
2027 mac_mobility_seqnum(attr_new
));
2029 /* Schedule for processing and unlock node. */
2030 bgp_process(bgp
, rd_rn
, afi
, safi
);
2031 bgp_unlock_node(rd_rn
);
2033 /* Unintern temporary. */
2034 aspath_unintern(&attr
.aspath
);
2042 * Delete all type-2 (MACIP) local routes for this VNI - only from the
2043 * global routing table. These are also scheduled for withdraw from peers.
2045 static int delete_global_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2049 struct bgp_node
*rdrn
, *rn
;
2050 struct bgp_table
*table
;
2051 struct bgp_info
*ri
;
2056 rdrn
= bgp_node_lookup(bgp
->rib
[afi
][safi
], (struct prefix
*)&vpn
->prd
);
2057 if (rdrn
&& rdrn
->info
) {
2058 table
= (struct bgp_table
*)rdrn
->info
;
2059 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2060 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2062 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2065 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &ri
);
2067 bgp_process(bgp
, rn
, afi
, safi
);
2071 /* Unlock RD node. */
2073 bgp_unlock_node(rdrn
);
2079 * Delete all type-2 (MACIP) local routes for this VNI - from the global
2080 * table as well as the per-VNI route table.
2082 static int delete_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2086 struct bgp_node
*rn
;
2087 struct bgp_info
*ri
;
2092 /* First, walk the global route table for this VNI's type-2 local
2094 * EVPN routes are a 2-level table, first get the RD table.
2096 delete_global_type2_routes(bgp
, vpn
);
2098 /* Next, walk this VNI's route table and delete local type-2 routes. */
2099 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2100 rn
= bgp_route_next(rn
)) {
2101 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2103 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2106 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &ri
);
2108 /* Route entry in local table gets deleted immediately. */
2110 bgp_info_reap(rn
, ri
);
2117 * Delete all routes in per ES route-table
2119 static int delete_all_es_routes(struct bgp
*bgp
, struct evpnes
*es
)
2121 struct bgp_node
*rn
;
2122 struct bgp_info
*ri
, *nextri
;
2124 /* Walk this ES's route table and delete all routes. */
2125 for (rn
= bgp_table_top(es
->route_table
); rn
;
2126 rn
= bgp_route_next(rn
)) {
2127 for (ri
= rn
->info
; (ri
!= NULL
) && (nextri
= ri
->next
, 1);
2129 bgp_info_delete(rn
, ri
);
2130 bgp_info_reap(rn
, ri
);
2138 * Delete all routes in the per-VNI route table.
2140 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2142 struct bgp_node
*rn
;
2143 struct bgp_info
*ri
, *nextri
;
2145 /* Walk this VNI's route table and delete all routes. */
2146 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2147 rn
= bgp_route_next(rn
)) {
2148 for (ri
= rn
->info
; (ri
!= NULL
) && (nextri
= ri
->next
, 1);
2150 bgp_info_delete(rn
, ri
);
2151 bgp_info_reap(rn
, ri
);
2159 * Update (and advertise) local routes for a VNI. Invoked upon the VNI
2160 * export RT getting modified or change to tunnel IP. Note that these
2161 * situations need the route in the per-VNI table as well as the global
2162 * table to be updated (as attributes change).
2164 static int update_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2167 struct prefix_evpn p
;
2169 /* Update and advertise the type-3 route (only one) followed by the
2170 * locally learnt type-2 routes (MACIP) - for this VNI.
2172 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2173 ret
= update_evpn_route(bgp
, vpn
, &p
, 0, 0);
2177 return update_all_type2_routes(bgp
, vpn
);
2180 /* Delete (and withdraw) local routes for specified ES from global and ES table.
2181 * Also remove all other routes from the per ES table.
2182 * Invoked when ES is deleted.
2184 static int delete_routes_for_es(struct bgp
*bgp
, struct evpnes
*es
)
2187 char buf
[ESI_STR_LEN
];
2188 struct prefix_evpn p
;
2190 /* Delete and withdraw locally learnt ES route */
2191 build_evpn_type4_prefix(&p
, &es
->esi
, es
->originator_ip
.ipaddr_v4
);
2192 ret
= delete_evpn_type4_route(bgp
, es
, &p
);
2194 flog_err(BGP_ERR_EVPN_ROUTE_DELETE
,
2195 "%u failed to delete type-4 route for ESI %s",
2196 bgp
->vrf_id
, esi_to_str(&es
->esi
, buf
, sizeof(buf
)));
2199 /* Delete all routes from per ES table */
2200 return delete_all_es_routes(bgp
, es
);
2204 * Delete (and withdraw) local routes for specified VNI from the global
2205 * table and per-VNI table. After this, remove all other routes from
2206 * the per-VNI table. Invoked upon the VNI being deleted or EVPN
2207 * (advertise-all-vni) being disabled.
2209 static int delete_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2212 struct prefix_evpn p
;
2214 /* Delete and withdraw locally learnt type-2 routes (MACIP)
2215 * followed by type-3 routes (only one) - for this VNI.
2217 ret
= delete_all_type2_routes(bgp
, vpn
);
2221 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2222 ret
= delete_evpn_route(bgp
, vpn
, &p
);
2226 /* Delete all routes from the per-VNI table. */
2227 return delete_all_vni_routes(bgp
, vpn
);
2231 * There is a tunnel endpoint IP address change for this VNI, delete
2232 * prior type-3 route (if needed) and update.
2233 * Note: Route re-advertisement happens elsewhere after other processing
2236 static int handle_tunnel_ip_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2237 struct in_addr originator_ip
)
2239 struct prefix_evpn p
;
2241 /* If VNI is not live, we only need to update the originator ip */
2242 if (!is_vni_live(vpn
)) {
2243 vpn
->originator_ip
= originator_ip
;
2247 /* Update the tunnel-ip hash */
2248 bgp_tip_del(bgp
, &vpn
->originator_ip
);
2249 bgp_tip_add(bgp
, &originator_ip
);
2251 /* filter routes as martian nexthop db has changed */
2252 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
2254 /* Need to withdraw type-3 route as the originator IP is part
2257 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2258 delete_evpn_route(bgp
, vpn
, &p
);
2260 /* Update the tunnel IP and re-advertise all routes for this VNI. */
2261 vpn
->originator_ip
= originator_ip
;
2265 /* Install EVPN route entry in ES */
2266 static int install_evpn_route_entry_in_es(struct bgp
*bgp
,
2268 struct prefix_evpn
*p
,
2269 struct bgp_info
*parent_ri
)
2272 struct bgp_node
*rn
= NULL
;
2273 struct bgp_info
*ri
= NULL
;
2274 struct attr
*attr_new
= NULL
;
2276 /* Create (or fetch) route within the VNI.
2277 * NOTE: There is no RD here.
2279 rn
= bgp_node_get(es
->route_table
, (struct prefix
*)p
);
2281 /* Check if route entry is already present. */
2282 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2284 (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2288 /* Add (or update) attribute to hash. */
2289 attr_new
= bgp_attr_intern(parent_ri
->attr
);
2291 /* Create new route with its attribute. */
2292 ri
= info_make(parent_ri
->type
, BGP_ROUTE_IMPORTED
, 0,
2293 parent_ri
->peer
, attr_new
, rn
);
2294 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
2295 bgp_info_extra_get(ri
);
2296 ri
->extra
->parent
= parent_ri
;
2297 bgp_info_add(rn
, ri
);
2299 if (attrhash_cmp(ri
->attr
, parent_ri
->attr
)
2300 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
2301 bgp_unlock_node(rn
);
2304 /* The attribute has changed. */
2305 /* Add (or update) attribute to hash. */
2306 attr_new
= bgp_attr_intern(parent_ri
->attr
);
2308 /* Restore route, if needed. */
2309 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
2310 bgp_info_restore(rn
, ri
);
2312 /* Mark if nexthop has changed. */
2313 if (!IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
))
2314 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
2316 /* Unintern existing, set to new. */
2317 bgp_attr_unintern(&ri
->attr
);
2318 ri
->attr
= attr_new
;
2319 ri
->uptime
= bgp_clock();
2322 /* Perform route selection and update zebra, if required. */
2323 ret
= evpn_es_route_select_install(bgp
, es
, rn
);
2328 * Install route entry into the VRF routing table and invoke route selection.
2330 static int install_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
2331 struct prefix_evpn
*evp
,
2332 struct bgp_info
*parent_ri
)
2334 struct bgp_node
*rn
;
2335 struct bgp_info
*ri
;
2337 struct attr
*attr_new
;
2340 struct prefix
*pp
= &p
;
2343 char buf
[PREFIX_STRLEN
];
2344 char buf1
[PREFIX_STRLEN
];
2346 memset(pp
, 0, sizeof(struct prefix
));
2347 ip_prefix_from_evpn_prefix(evp
, pp
);
2349 if (bgp_debug_zebra(NULL
)) {
2351 "installing evpn prefix %s as ip prefix %s in vrf %s",
2352 prefix2str(evp
, buf
, sizeof(buf
)),
2353 prefix2str(pp
, buf1
, sizeof(buf
)),
2354 vrf_id_to_name(bgp_vrf
->vrf_id
));
2357 /* Create (or fetch) route within the VRF. */
2358 /* NOTE: There is no RD here. */
2359 if (is_evpn_prefix_ipaddr_v4(evp
)) {
2361 safi
= SAFI_UNICAST
;
2362 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
2363 } else if (is_evpn_prefix_ipaddr_v6(evp
)) {
2365 safi
= SAFI_UNICAST
;
2366 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
2370 /* EVPN routes currently only support a IPv4 next hop which corresponds
2371 * to the remote VTEP. When importing into a VRF, if it is IPv6 host
2372 * or prefix route, we have to convert the next hop to an IPv4-mapped
2373 * address for the rest of the code to flow through. In the case of IPv4,
2374 * make sure to set the flag for next hop attribute.
2376 bgp_attr_dup(&attr
, parent_ri
->attr
);
2378 evpn_convert_nexthop_to_ipv6(&attr
);
2380 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
2382 /* Check if route entry is already present. */
2383 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2385 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2389 /* Add (or update) attribute to hash. */
2390 attr_new
= bgp_attr_intern(&attr
);
2392 /* Create new route with its attribute. */
2393 ri
= info_make(parent_ri
->type
, BGP_ROUTE_IMPORTED
, 0,
2394 parent_ri
->peer
, attr_new
, rn
);
2395 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
2396 bgp_info_extra_get(ri
);
2397 ri
->extra
->parent
= bgp_info_lock(parent_ri
);
2398 bgp_lock_node((struct bgp_node
*)parent_ri
->net
);
2399 if (parent_ri
->extra
) {
2400 memcpy(&ri
->extra
->label
, &parent_ri
->extra
->label
,
2401 sizeof(ri
->extra
->label
));
2402 ri
->extra
->num_labels
= parent_ri
->extra
->num_labels
;
2404 bgp_info_add(rn
, ri
);
2406 if (attrhash_cmp(ri
->attr
, &attr
)
2407 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
2408 bgp_unlock_node(rn
);
2411 /* The attribute has changed. */
2412 /* Add (or update) attribute to hash. */
2413 attr_new
= bgp_attr_intern(&attr
);
2415 /* Restore route, if needed. */
2416 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
2417 bgp_info_restore(rn
, ri
);
2419 /* Mark if nexthop has changed. */
2420 if ((afi
== AFI_IP
&&
2421 !IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
)) ||
2423 !IPV6_ADDR_SAME(&ri
->attr
->mp_nexthop_global
,
2424 &attr_new
->mp_nexthop_global
)))
2425 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
2427 /* Unintern existing, set to new. */
2428 bgp_attr_unintern(&ri
->attr
);
2429 ri
->attr
= attr_new
;
2430 ri
->uptime
= bgp_clock();
2433 /* Perform route selection and update zebra, if required. */
2434 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2440 * Install route entry into the VNI routing table and invoke route selection.
2442 static int install_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2443 struct prefix_evpn
*p
,
2444 struct bgp_info
*parent_ri
)
2446 struct bgp_node
*rn
;
2447 struct bgp_info
*ri
;
2448 struct attr
*attr_new
;
2451 /* Create (or fetch) route within the VNI. */
2452 /* NOTE: There is no RD here. */
2453 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
2455 /* Check if route entry is already present. */
2456 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2458 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2462 /* Add (or update) attribute to hash. */
2463 attr_new
= bgp_attr_intern(parent_ri
->attr
);
2465 /* Create new route with its attribute. */
2466 ri
= info_make(parent_ri
->type
, BGP_ROUTE_IMPORTED
, 0,
2467 parent_ri
->peer
, attr_new
, rn
);
2468 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
2469 bgp_info_extra_get(ri
);
2470 ri
->extra
->parent
= bgp_info_lock(parent_ri
);
2471 bgp_lock_node((struct bgp_node
*)parent_ri
->net
);
2472 if (parent_ri
->extra
) {
2473 memcpy(&ri
->extra
->label
, &parent_ri
->extra
->label
,
2474 sizeof(ri
->extra
->label
));
2475 ri
->extra
->num_labels
= parent_ri
->extra
->num_labels
;
2477 bgp_info_add(rn
, ri
);
2479 if (attrhash_cmp(ri
->attr
, parent_ri
->attr
)
2480 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
2481 bgp_unlock_node(rn
);
2484 /* The attribute has changed. */
2485 /* Add (or update) attribute to hash. */
2486 attr_new
= bgp_attr_intern(parent_ri
->attr
);
2488 /* Restore route, if needed. */
2489 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
2490 bgp_info_restore(rn
, ri
);
2492 /* Mark if nexthop has changed. */
2493 if (!IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
))
2494 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
2496 /* Unintern existing, set to new. */
2497 bgp_attr_unintern(&ri
->attr
);
2498 ri
->attr
= attr_new
;
2499 ri
->uptime
= bgp_clock();
2502 /* Perform route selection and update zebra, if required. */
2503 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2508 /* Uninstall EVPN route entry from ES route table */
2509 static int uninstall_evpn_route_entry_in_es(struct bgp
*bgp
,
2511 struct prefix_evpn
*p
,
2512 struct bgp_info
*parent_ri
)
2515 struct bgp_node
*rn
;
2516 struct bgp_info
*ri
;
2518 if (!es
->route_table
)
2521 /* Locate route within the ESI.
2522 * NOTE: There is no RD here.
2524 rn
= bgp_node_lookup(es
->route_table
, (struct prefix
*)p
);
2528 /* Find matching route entry. */
2529 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2531 (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2537 /* Mark entry for deletion */
2538 bgp_info_delete(rn
, ri
);
2540 /* Perform route selection and update zebra, if required. */
2541 ret
= evpn_es_route_select_install(bgp
, es
, rn
);
2543 /* Unlock route node. */
2544 bgp_unlock_node(rn
);
2550 * Uninstall route entry from the VRF routing table and send message
2551 * to zebra, if appropriate.
2553 static int uninstall_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
2554 struct prefix_evpn
*evp
,
2555 struct bgp_info
*parent_ri
)
2557 struct bgp_node
*rn
;
2558 struct bgp_info
*ri
;
2561 struct prefix
*pp
= &p
;
2564 char buf
[PREFIX_STRLEN
];
2565 char buf1
[PREFIX_STRLEN
];
2567 memset(pp
, 0, sizeof(struct prefix
));
2568 ip_prefix_from_evpn_prefix(evp
, pp
);
2570 if (bgp_debug_zebra(NULL
)) {
2572 "uninstalling evpn prefix %s as ip prefix %s in vrf %s",
2573 prefix2str(evp
, buf
, sizeof(buf
)),
2574 prefix2str(pp
, buf1
, sizeof(buf
)),
2575 vrf_id_to_name(bgp_vrf
->vrf_id
));
2578 /* Locate route within the VRF. */
2579 /* NOTE: There is no RD here. */
2580 if (is_evpn_prefix_ipaddr_v4(evp
)) {
2582 safi
= SAFI_UNICAST
;
2583 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2586 safi
= SAFI_UNICAST
;
2587 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2593 /* Find matching route entry. */
2594 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2596 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2602 /* Mark entry for deletion */
2603 bgp_info_delete(rn
, ri
);
2605 /* Perform route selection and update zebra, if required. */
2606 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2608 /* Unlock route node. */
2609 bgp_unlock_node(rn
);
2615 * Uninstall route entry from the VNI routing table and send message
2616 * to zebra, if appropriate.
2618 static int uninstall_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2619 struct prefix_evpn
*p
,
2620 struct bgp_info
*parent_ri
)
2622 struct bgp_node
*rn
;
2623 struct bgp_info
*ri
;
2626 /* Locate route within the VNI. */
2627 /* NOTE: There is no RD here. */
2628 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
2632 /* Find matching route entry. */
2633 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2635 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2641 /* Mark entry for deletion */
2642 bgp_info_delete(rn
, ri
);
2644 /* Perform route selection and update zebra, if required. */
2645 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2647 /* Unlock route node. */
2648 bgp_unlock_node(rn
);
2654 * Given a prefix, see if it belongs to ES.
2656 static int is_prefix_matching_for_es(struct prefix_evpn
*p
,
2659 /* if not an ES route return false */
2660 if (p
->prefix
.route_type
!= BGP_EVPN_ES_ROUTE
)
2663 if (memcmp(&p
->prefix
.es_addr
.esi
, &es
->esi
, sizeof(esi_t
)) == 0)
2670 * Given a route entry and a VRF, see if this route entry should be
2671 * imported into the VRF i.e., RTs match.
2673 static int is_route_matching_for_vrf(struct bgp
*bgp_vrf
, struct bgp_info
*ri
)
2675 struct attr
*attr
= ri
->attr
;
2676 struct ecommunity
*ecom
;
2680 /* Route should have valid RT to be even considered. */
2681 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2684 ecom
= attr
->ecommunity
;
2685 if (!ecom
|| !ecom
->size
)
2688 /* For each extended community RT, see if it matches this VNI. If any RT
2689 * matches, we're done.
2691 for (i
= 0; i
< ecom
->size
; i
++) {
2693 uint8_t type
, sub_type
;
2694 struct ecommunity_val
*eval
;
2695 struct ecommunity_val eval_tmp
;
2696 struct vrf_irt_node
*irt
;
2698 /* Only deal with RTs */
2699 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2700 eval
= (struct ecommunity_val
*)(ecom
->val
2701 + (i
* ECOMMUNITY_SIZE
));
2704 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2707 /* See if this RT matches specified VNIs import RTs */
2708 irt
= lookup_vrf_import_rt(eval
);
2710 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2713 /* Also check for non-exact match. In this, we mask out the AS
2715 * only check on the local-admin sub-field. This is to
2717 * VNI as the RT for EBGP peering too.
2720 if (type
== ECOMMUNITY_ENCODE_AS
2721 || type
== ECOMMUNITY_ENCODE_AS4
2722 || type
== ECOMMUNITY_ENCODE_IP
) {
2723 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2724 mask_ecom_global_admin(&eval_tmp
, eval
);
2725 irt
= lookup_vrf_import_rt(&eval_tmp
);
2728 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2736 * Given a route entry and a VNI, see if this route entry should be
2737 * imported into the VNI i.e., RTs match.
2739 static int is_route_matching_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2740 struct bgp_info
*ri
)
2742 struct attr
*attr
= ri
->attr
;
2743 struct ecommunity
*ecom
;
2747 /* Route should have valid RT to be even considered. */
2748 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2751 ecom
= attr
->ecommunity
;
2752 if (!ecom
|| !ecom
->size
)
2755 /* For each extended community RT, see if it matches this VNI. If any RT
2756 * matches, we're done.
2758 for (i
= 0; i
< ecom
->size
; i
++) {
2760 uint8_t type
, sub_type
;
2761 struct ecommunity_val
*eval
;
2762 struct ecommunity_val eval_tmp
;
2763 struct irt_node
*irt
;
2765 /* Only deal with RTs */
2766 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2767 eval
= (struct ecommunity_val
*)(ecom
->val
2768 + (i
* ECOMMUNITY_SIZE
));
2771 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2774 /* See if this RT matches specified VNIs import RTs */
2775 irt
= lookup_import_rt(bgp
, eval
);
2777 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2780 /* Also check for non-exact match. In this, we mask out the AS
2782 * only check on the local-admin sub-field. This is to
2784 * VNI as the RT for EBGP peering too.
2787 if (type
== ECOMMUNITY_ENCODE_AS
2788 || type
== ECOMMUNITY_ENCODE_AS4
2789 || type
== ECOMMUNITY_ENCODE_IP
) {
2790 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2791 mask_ecom_global_admin(&eval_tmp
, eval
);
2792 irt
= lookup_import_rt(bgp
, &eval_tmp
);
2795 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2802 static int install_uninstall_routes_for_es(struct bgp
*bgp
,
2809 char buf
[PREFIX_STRLEN
];
2810 char buf1
[ESI_STR_LEN
];
2811 struct bgp_node
*rd_rn
, *rn
;
2812 struct bgp_table
*table
;
2813 struct bgp_info
*ri
;
2819 * Walk entire global routing table and evaluate routes which could be
2820 * imported into this VRF. Note that we need to loop through all global
2821 * routes to determine which route matches the import rt on vrf
2823 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
2824 rd_rn
= bgp_route_next(rd_rn
)) {
2825 table
= (struct bgp_table
*)(rd_rn
->info
);
2829 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2830 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2832 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2834 * Consider "valid" remote routes applicable for
2837 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2838 && ri
->type
== ZEBRA_ROUTE_BGP
2839 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2842 if (!is_prefix_matching_for_es(evp
, es
))
2846 ret
= install_evpn_route_entry_in_es(
2849 ret
= uninstall_evpn_route_entry_in_es(
2855 "Failed to %s EVPN %s route in ESI %s",
2858 prefix2str(evp
, buf
,
2860 esi_to_str(&es
->esi
, buf1
,
2871 * Install or uninstall mac-ip routes are appropriate for this
2874 static int install_uninstall_routes_for_vrf(struct bgp
*bgp_vrf
, int install
)
2878 struct bgp_node
*rd_rn
, *rn
;
2879 struct bgp_table
*table
;
2880 struct bgp_info
*ri
;
2882 char buf
[PREFIX_STRLEN
];
2883 struct bgp
*bgp_def
= NULL
;
2887 bgp_def
= bgp_get_default();
2891 /* Walk entire global routing table and evaluate routes which could be
2892 * imported into this VRF. Note that we need to loop through all global
2893 * routes to determine which route matches the import rt on vrf
2895 for (rd_rn
= bgp_table_top(bgp_def
->rib
[afi
][safi
]); rd_rn
;
2896 rd_rn
= bgp_route_next(rd_rn
)) {
2897 table
= (struct bgp_table
*)(rd_rn
->info
);
2901 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2902 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2904 /* if not mac-ip route skip this route */
2905 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2906 || evp
->prefix
.route_type
2907 == BGP_EVPN_IP_PREFIX_ROUTE
))
2910 /* if not a mac+ip route skip this route */
2911 if (!(is_evpn_prefix_ipaddr_v4(evp
)
2912 || is_evpn_prefix_ipaddr_v6(evp
)))
2915 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2916 /* Consider "valid" remote routes applicable for
2919 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2920 && ri
->type
== ZEBRA_ROUTE_BGP
2921 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2924 if (is_route_matching_for_vrf(bgp_vrf
, ri
)) {
2926 ret
= install_evpn_route_entry_in_vrf(
2929 ret
= uninstall_evpn_route_entry_in_vrf(
2935 "Failed to %s EVPN %s route in VRF %s",
2938 prefix2str(evp
, buf
,
2953 * Install or uninstall routes of specified type that are appropriate for this
2956 static int install_uninstall_routes_for_vni(struct bgp
*bgp
,
2957 struct bgpevpn
*vpn
,
2958 bgp_evpn_route_type rtype
,
2963 struct bgp_node
*rd_rn
, *rn
;
2964 struct bgp_table
*table
;
2965 struct bgp_info
*ri
;
2971 /* Walk entire global routing table and evaluate routes which could be
2972 * imported into this VPN. Note that we cannot just look at the routes
2974 * the VNI's RD - remote routes applicable for this VNI could have any
2977 /* EVPN routes are a 2-level table. */
2978 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
2979 rd_rn
= bgp_route_next(rd_rn
)) {
2980 table
= (struct bgp_table
*)(rd_rn
->info
);
2984 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2985 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2987 if (evp
->prefix
.route_type
!= rtype
)
2990 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2991 /* Consider "valid" remote routes applicable for
2993 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2994 && ri
->type
== ZEBRA_ROUTE_BGP
2995 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2998 if (is_route_matching_for_vni(bgp
, vpn
, ri
)) {
3000 ret
= install_evpn_route_entry(
3003 ret
= uninstall_evpn_route_entry(
3009 "%u: Failed to %s EVPN %s route in VNI %u",
3013 rtype
== BGP_EVPN_MAC_IP_ROUTE
3027 /* Install any existing remote ES routes applicable for this ES into its routing
3028 * table. This is invoked when ES comes up.
3030 static int install_routes_for_es(struct bgp
*bgp
, struct evpnes
*es
)
3032 return install_uninstall_routes_for_es(bgp
, es
, 1);
3036 /* Install any existing remote routes applicable for this VRF into VRF RIB. This
3037 * is invoked upon l3vni-add or l3vni import rt change
3039 static int install_routes_for_vrf(struct bgp
*bgp_vrf
)
3041 install_uninstall_routes_for_vrf(bgp_vrf
, 1);
3046 * Install any existing remote routes applicable for this VNI into its
3047 * routing table. This is invoked when a VNI becomes "live" or its Import
3050 static int install_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3054 /* Install type-3 routes followed by type-2 routes - the ones applicable
3057 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
3062 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
3066 /* uninstall routes from l3vni vrf. */
3067 static int uninstall_routes_for_vrf(struct bgp
*bgp_vrf
)
3069 install_uninstall_routes_for_vrf(bgp_vrf
, 0);
3074 * Uninstall any existing remote routes for this VNI. One scenario in which
3075 * this is invoked is upon an import RT change.
3077 static int uninstall_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3081 /* Uninstall type-2 routes followed by type-3 routes - the ones
3085 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
3090 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
3094 /* Install or unistall route in ES */
3095 static int install_uninstall_route_in_es(struct bgp
*bgp
, struct evpnes
*es
,
3096 afi_t afi
, safi_t safi
,
3097 struct prefix_evpn
*evp
,
3098 struct bgp_info
*ri
,
3102 char buf
[ESI_STR_LEN
];
3105 ret
= install_evpn_route_entry_in_es(bgp
, es
, evp
, ri
);
3107 ret
= uninstall_evpn_route_entry_in_es(bgp
, es
, evp
, ri
);
3112 "%u: Failed to %s EVPN %s route in ESI %s", bgp
->vrf_id
,
3113 install
? "install" : "uninstall", "ES",
3114 esi_to_str(&evp
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)));
3121 * Install or uninstall route in matching VRFs (list).
3123 static int install_uninstall_route_in_vrfs(struct bgp
*bgp_def
, afi_t afi
,
3124 safi_t safi
, struct prefix_evpn
*evp
,
3125 struct bgp_info
*ri
,
3126 struct list
*vrfs
, int install
)
3128 char buf
[PREFIX2STR_BUFFER
];
3129 struct bgp
*bgp_vrf
;
3130 struct listnode
*node
, *nnode
;
3132 /* Only type-2/type-5 routes go into a VRF */
3133 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3134 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
3137 /* if it is type-2 route and not a mac+ip route skip this route */
3138 if ((evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
3139 && !(is_evpn_prefix_ipaddr_v4(evp
)
3140 || is_evpn_prefix_ipaddr_v6(evp
)))
3143 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, bgp_vrf
)) {
3147 ret
= install_evpn_route_entry_in_vrf(bgp_vrf
, evp
, ri
);
3149 ret
= uninstall_evpn_route_entry_in_vrf(bgp_vrf
, evp
,
3153 flog_err(BGP_ERR_EVPN_FAIL
,
3154 "%u: Failed to %s prefix %s in VRF %s",
3156 install
? "install" : "uninstall",
3157 prefix2str(evp
, buf
, sizeof(buf
)),
3158 vrf_id_to_name(bgp_vrf
->vrf_id
));
3167 * Install or uninstall route in matching VNIs (list).
3169 static int install_uninstall_route_in_vnis(struct bgp
*bgp
, afi_t afi
,
3170 safi_t safi
, struct prefix_evpn
*evp
,
3171 struct bgp_info
*ri
,
3172 struct list
*vnis
, int install
)
3174 struct bgpevpn
*vpn
;
3175 struct listnode
*node
, *nnode
;
3177 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, vpn
)) {
3180 if (!is_vni_live(vpn
))
3184 ret
= install_evpn_route_entry(bgp
, vpn
, evp
, ri
);
3186 ret
= uninstall_evpn_route_entry(bgp
, vpn
, evp
, ri
);
3191 "%u: Failed to %s EVPN %s route in VNI %u",
3192 bgp
->vrf_id
, install
? "install" : "uninstall",
3193 evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3205 * Install or uninstall route for appropriate VNIs/ESIs.
3207 static int install_uninstall_evpn_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
3208 struct prefix
*p
, struct bgp_info
*ri
,
3211 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
3212 struct attr
*attr
= ri
->attr
;
3213 struct ecommunity
*ecom
;
3218 /* Only type-2, type-3, type-4 and type-5 are supported currently */
3219 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3220 || evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
3221 || evp
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
3222 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
3225 /* If we don't have Route Target, nothing much to do. */
3226 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
3229 ecom
= attr
->ecommunity
;
3230 if (!ecom
|| !ecom
->size
)
3233 /* An EVPN route belongs to a VNI or a VRF or an ESI based on the RTs
3234 * attached to the route */
3235 for (i
= 0; i
< ecom
->size
; i
++) {
3237 uint8_t type
, sub_type
;
3238 struct ecommunity_val
*eval
;
3239 struct ecommunity_val eval_tmp
;
3240 struct irt_node
*irt
; /* import rt for l2vni */
3241 struct vrf_irt_node
*vrf_irt
; /* import rt for l3vni */
3244 /* Only deal with RTs */
3245 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
3246 eval
= (struct ecommunity_val
*)(ecom
->val
3247 + (i
* ECOMMUNITY_SIZE
));
3250 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
3254 * macip routes (type-2) are imported into VNI and VRF tables.
3255 * IMET route is imported into VNI table.
3256 * prefix routes are imported into VRF table.
3258 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
||
3259 evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
||
3260 evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
3262 irt
= lookup_import_rt(bgp
, eval
);
3264 install_uninstall_route_in_vnis(bgp
, afi
, safi
,
3269 vrf_irt
= lookup_vrf_import_rt(eval
);
3271 install_uninstall_route_in_vrfs(bgp
, afi
, safi
,
3276 /* Also check for non-exact match.
3277 * In this, we mask out the AS and
3278 * only check on the local-admin sub-field.
3279 * This is to facilitate using
3280 * VNI as the RT for EBGP peering too.
3284 if (type
== ECOMMUNITY_ENCODE_AS
3285 || type
== ECOMMUNITY_ENCODE_AS4
3286 || type
== ECOMMUNITY_ENCODE_IP
) {
3287 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
3288 mask_ecom_global_admin(&eval_tmp
, eval
);
3289 irt
= lookup_import_rt(bgp
, &eval_tmp
);
3290 vrf_irt
= lookup_vrf_import_rt(&eval_tmp
);
3294 install_uninstall_route_in_vnis(bgp
, afi
, safi
,
3299 install_uninstall_route_in_vrfs(bgp
, afi
, safi
,
3305 /* es route is imported into the es table */
3306 if (evp
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
) {
3308 /* we will match based on the entire esi to avoid
3309 * imoort of an es route for esi2 into esi1
3311 es
= bgp_evpn_lookup_es(bgp
, &evp
->prefix
.es_addr
.esi
);
3312 if (es
&& is_es_local(es
))
3313 install_uninstall_route_in_es(bgp
, es
,
3323 * delete and withdraw all ipv4 and ipv6 routes in the vrf table as type-5
3326 static void delete_withdraw_vrf_routes(struct bgp
*bgp_vrf
)
3328 /* delete all ipv4 routes and withdraw from peers */
3329 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
3330 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
3332 /* delete all ipv6 routes and withdraw from peers */
3333 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
3334 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
3338 * update and advertise all ipv4 and ipv6 routes in thr vrf table as type-5
3341 static void update_advertise_vrf_routes(struct bgp
*bgp_vrf
)
3343 /* update all ipv4 routes */
3344 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
3345 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
3347 /* update all ipv6 routes */
3348 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
3349 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
3353 * update and advertise local routes for a VRF as type-5 routes.
3354 * This is invoked upon RD change for a VRF. Note taht the processing is only
3355 * done in the global route table using the routes which already exist in the
3358 static void update_router_id_vrf(struct bgp
*bgp_vrf
)
3360 /* skip if the RD is configured */
3361 if (is_vrf_rd_configured(bgp_vrf
))
3364 /* derive the RD for the VRF based on new router-id */
3365 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
3367 /* update advertise ipv4|ipv6 routes as type-5 routes */
3368 update_advertise_vrf_routes(bgp_vrf
);
3372 * Delete and withdraw all type-5 routes for the RD corresponding to VRF.
3373 * This is invoked upon VRF RD change. The processing is done only from global
3376 static void withdraw_router_id_vrf(struct bgp
*bgp_vrf
)
3378 /* skip if the RD is configured */
3379 if (is_vrf_rd_configured(bgp_vrf
))
3382 /* delete/withdraw ipv4|ipv6 routes as type-5 routes */
3383 delete_withdraw_vrf_routes(bgp_vrf
);
3387 * Update and advertise local routes for a VNI. Invoked upon router-id
3388 * change. Note that the processing is done only on the global route table
3389 * using routes that already exist in the per-VNI table.
3391 static int update_advertise_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3393 struct prefix_evpn p
;
3394 struct bgp_node
*rn
, *global_rn
;
3395 struct bgp_info
*ri
, *global_ri
;
3397 afi_t afi
= AFI_L2VPN
;
3398 safi_t safi
= SAFI_EVPN
;
3400 /* Locate type-3 route for VNI in the per-VNI table and use its
3401 * attributes to create and advertise the type-3 route for this VNI
3402 * in the global table.
3404 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3405 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)&p
);
3406 if (!rn
) /* unexpected */
3408 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
3409 if (ri
->peer
== bgp
->peer_self
&& ri
->type
== ZEBRA_ROUTE_BGP
3410 && ri
->sub_type
== BGP_ROUTE_STATIC
)
3412 if (!ri
) /* unexpected */
3416 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
3417 (struct prefix
*)&p
, &vpn
->prd
);
3418 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1, &ri
,
3419 0, mac_mobility_seqnum(attr
));
3421 /* Schedule for processing and unlock node. */
3422 bgp_process(bgp
, global_rn
, afi
, safi
);
3423 bgp_unlock_node(global_rn
);
3425 /* Now, walk this VNI's route table and use the route and its attribute
3426 * to create and schedule route in global table.
3428 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
3429 rn
= bgp_route_next(rn
)) {
3430 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
3432 /* Identify MAC-IP local routes. */
3433 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
3436 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
3437 if (ri
->peer
== bgp
->peer_self
3438 && ri
->type
== ZEBRA_ROUTE_BGP
3439 && ri
->sub_type
== BGP_ROUTE_STATIC
)
3444 /* Create route in global routing table using this route entry's
3448 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
3449 (struct prefix
*)evp
, &vpn
->prd
);
3451 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1,
3453 mac_mobility_seqnum(attr
));
3455 /* Schedule for processing and unlock node. */
3456 bgp_process(bgp
, global_rn
, afi
, safi
);
3457 bgp_unlock_node(global_rn
);
3464 * Delete (and withdraw) local routes for a VNI - only from the global
3465 * table. Invoked upon router-id change.
3467 static int delete_withdraw_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3470 struct prefix_evpn p
;
3471 struct bgp_node
*global_rn
;
3472 struct bgp_info
*ri
;
3473 afi_t afi
= AFI_L2VPN
;
3474 safi_t safi
= SAFI_EVPN
;
3476 /* Delete and withdraw locally learnt type-2 routes (MACIP)
3477 * for this VNI - from the global table.
3479 ret
= delete_global_type2_routes(bgp
, vpn
);
3483 /* Remove type-3 route for this VNI from global table. */
3484 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3485 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
3486 (struct prefix
*)&p
, &vpn
->prd
);
3488 /* Delete route entry in the global EVPN table. */
3489 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &ri
);
3491 /* Schedule for processing - withdraws to peers happen from
3495 bgp_process(bgp
, global_rn
, afi
, safi
);
3496 bgp_unlock_node(global_rn
);
3503 * Handle router-id change. Update and advertise local routes corresponding
3504 * to this VNI from peers. Note that this is invoked after updating the
3505 * router-id. The routes in the per-VNI table are used to create routes in
3506 * the global table and schedule them.
3508 static void update_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
3510 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3512 /* Skip VNIs with configured RD. */
3513 if (is_rd_configured(vpn
))
3516 bgp_evpn_derive_auto_rd(bgp
, vpn
);
3517 update_advertise_vni_routes(bgp
, vpn
);
3521 * Handle router-id change. Delete and withdraw local routes corresponding
3522 * to this VNI from peers. Note that this is invoked prior to updating
3523 * the router-id and is done only on the global route table, the routes
3524 * are needed in the per-VNI table to re-advertise with new router id.
3526 static void withdraw_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
3528 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3530 /* Skip VNIs with configured RD. */
3531 if (is_rd_configured(vpn
))
3534 delete_withdraw_vni_routes(bgp
, vpn
);
3538 * Process received EVPN type-2 route (advertise or withdraw).
3540 static int process_type2_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3541 struct attr
*attr
, uint8_t *pfx
, int psize
,
3542 uint32_t addpath_id
)
3544 struct prefix_rd prd
;
3545 struct prefix_evpn p
;
3546 struct bgp_route_evpn evpn
;
3548 uint8_t macaddr_len
;
3549 mpls_label_t label
[BGP_MAX_LABELS
]; /* holds the VNI(s) as in packet */
3550 uint32_t num_labels
= 0;
3554 /* Type-2 route should be either 33, 37 or 49 bytes or an
3555 * additional 3 bytes if there is a second label (VNI):
3556 * RD (8), ESI (10), Eth Tag (4), MAC Addr Len (1),
3557 * MAC Addr (6), IP len (1), IP (0, 4 or 16),
3558 * MPLS Lbl1 (3), MPLS Lbl2 (0 or 3)
3560 if (psize
!= 33 && psize
!= 37 && psize
!= 49 && psize
!= 36
3561 && psize
!= 40 && psize
!= 52) {
3562 flog_err(BGP_ERR_EVPN_ROUTE_INVALID
,
3563 "%u:%s - Rx EVPN Type-2 NLRI with invalid length %d",
3564 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3568 memset(&evpn
, 0, sizeof(evpn
));
3570 /* Make prefix_rd */
3571 prd
.family
= AF_UNSPEC
;
3573 memcpy(&prd
.val
, pfx
, 8);
3576 /* Make EVPN prefix. */
3577 memset(&p
, 0, sizeof(struct prefix_evpn
));
3579 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3580 p
.prefix
.route_type
= BGP_EVPN_MAC_IP_ROUTE
;
3582 /* Copy Ethernet Seg Identifier */
3583 memcpy(&evpn
.eth_s_id
.val
, pfx
, ESI_LEN
);
3586 /* Copy Ethernet Tag */
3587 memcpy(ð_tag
, pfx
, 4);
3588 p
.prefix
.macip_addr
.eth_tag
= ntohl(eth_tag
);
3591 /* Get the MAC Addr len */
3592 macaddr_len
= *pfx
++;
3594 /* Get the MAC Addr */
3595 if (macaddr_len
== (ETH_ALEN
* 8)) {
3596 memcpy(&p
.prefix
.macip_addr
.mac
.octet
, pfx
, ETH_ALEN
);
3600 BGP_ERR_EVPN_ROUTE_INVALID
,
3601 "%u:%s - Rx EVPN Type-2 NLRI with unsupported MAC address length %d",
3602 peer
->bgp
->vrf_id
, peer
->host
, macaddr_len
);
3608 ipaddr_len
= *pfx
++;
3609 if (ipaddr_len
!= 0 && ipaddr_len
!= IPV4_MAX_BITLEN
3610 && ipaddr_len
!= IPV6_MAX_BITLEN
) {
3612 BGP_ERR_EVPN_ROUTE_INVALID
,
3613 "%u:%s - Rx EVPN Type-2 NLRI with unsupported IP address length %d",
3614 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3619 ipaddr_len
/= 8; /* Convert to bytes. */
3620 p
.prefix
.macip_addr
.ip
.ipa_type
= (ipaddr_len
== IPV4_MAX_BYTELEN
)
3623 memcpy(&p
.prefix
.macip_addr
.ip
.ip
.addr
, pfx
, ipaddr_len
);
3627 /* Get the VNI(s). Stored as bytes here. */
3629 memset(label
, 0, sizeof(label
));
3630 memcpy(&label
[0], pfx
, BGP_LABEL_BYTES
);
3631 pfx
+= BGP_LABEL_BYTES
;
3632 psize
-= (33 + ipaddr_len
);
3633 /* Do we have a second VNI? */
3636 memcpy(&label
[1], pfx
, BGP_LABEL_BYTES
);
3638 * If in future, we are required to access additional fields,
3639 * we MUST increment pfx by BGP_LABEL_BYTES in before reading
3644 /* Process the route. */
3646 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3647 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3648 &prd
, &label
[0], num_labels
, 0, &evpn
);
3650 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3651 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3652 &prd
, &label
[0], num_labels
, &evpn
);
3657 * Process received EVPN type-3 route (advertise or withdraw).
3659 static int process_type3_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3660 struct attr
*attr
, uint8_t *pfx
, int psize
,
3661 uint32_t addpath_id
)
3663 struct prefix_rd prd
;
3664 struct prefix_evpn p
;
3669 /* Type-3 route should be either 17 or 29 bytes: RD (8), Eth Tag (4),
3670 * IP len (1) and IP (4 or 16).
3672 if (psize
!= 17 && psize
!= 29) {
3673 flog_err(BGP_ERR_EVPN_ROUTE_INVALID
,
3674 "%u:%s - Rx EVPN Type-3 NLRI with invalid length %d",
3675 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3679 /* If PMSI is present, log if it is anything other than IR.
3680 * Note: We just simply ignore the values as it is not clear if
3681 * doing anything else is better.
3684 (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
))) {
3685 if (attr
->pmsi_tnl_type
!= PMSI_TNLTYPE_INGR_REPL
) {
3686 zlog_warn("%u:%s - Rx EVPN Type-3 NLRI with unsupported PTA %d",
3687 peer
->bgp
->vrf_id
, peer
->host
,
3688 attr
->pmsi_tnl_type
);
3692 /* Make prefix_rd */
3693 prd
.family
= AF_UNSPEC
;
3695 memcpy(&prd
.val
, pfx
, 8);
3698 /* Make EVPN prefix. */
3699 memset(&p
, 0, sizeof(struct prefix_evpn
));
3701 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3702 p
.prefix
.route_type
= BGP_EVPN_IMET_ROUTE
;
3704 /* Copy Ethernet Tag */
3705 memcpy(ð_tag
, pfx
, 4);
3706 p
.prefix
.imet_addr
.eth_tag
= ntohl(eth_tag
);
3710 ipaddr_len
= *pfx
++;
3711 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
3712 p
.prefix
.imet_addr
.ip
.ipa_type
= IPADDR_V4
;
3713 memcpy(&p
.prefix
.imet_addr
.ip
.ip
.addr
, pfx
, IPV4_MAX_BYTELEN
);
3716 BGP_ERR_EVPN_ROUTE_INVALID
,
3717 "%u:%s - Rx EVPN Type-3 NLRI with unsupported IP address length %d",
3718 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3722 /* Process the route. */
3724 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3725 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3726 &prd
, NULL
, 0, 0, NULL
);
3728 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3729 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3730 &prd
, NULL
, 0, NULL
);
3735 * Process received EVPN type-4 route (advertise or withdraw).
3737 static int process_type4_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3738 struct attr
*attr
, uint8_t *pfx
, int psize
,
3739 uint32_t addpath_id
)
3744 struct in_addr vtep_ip
;
3745 struct prefix_rd prd
;
3746 struct prefix_evpn p
;
3748 /* Type-4 route should be either 23 or 35 bytes
3749 * RD (8), ESI (10), ip-len (1), ip (4 or 16)
3751 if (psize
!= 23 && psize
!= 35) {
3752 flog_err(BGP_ERR_EVPN_ROUTE_INVALID
,
3753 "%u:%s - Rx EVPN Type-4 NLRI with invalid length %d",
3754 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3758 /* Make prefix_rd */
3759 prd
.family
= AF_UNSPEC
;
3761 memcpy(&prd
.val
, pfx
, 8);
3765 memcpy(&esi
, pfx
, ESI_BYTES
);
3770 ipaddr_len
= *pfx
++;
3771 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
3772 memcpy(&vtep_ip
, pfx
, IPV4_MAX_BYTELEN
);
3775 BGP_ERR_EVPN_ROUTE_INVALID
,
3776 "%u:%s - Rx EVPN Type-4 NLRI with unsupported IP address length %d",
3777 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3781 build_evpn_type4_prefix(&p
, &esi
, vtep_ip
);
3782 /* Process the route. */
3784 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3785 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3786 &prd
, NULL
, 0, 0, NULL
);
3788 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3789 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3790 &prd
, NULL
, 0, NULL
);
3797 * Process received EVPN type-5 route (advertise or withdraw).
3799 static int process_type5_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3800 struct attr
*attr
, uint8_t *pfx
, int psize
,
3801 uint32_t addpath_id
, int withdraw
)
3803 struct prefix_rd prd
;
3804 struct prefix_evpn p
;
3805 struct bgp_route_evpn evpn
;
3808 mpls_label_t label
; /* holds the VNI as in the packet */
3811 /* Type-5 route should be 34 or 58 bytes:
3812 * RD (8), ESI (10), Eth Tag (4), IP len (1), IP (4 or 16),
3813 * GW (4 or 16) and VNI (3).
3814 * Note that the IP and GW should both be IPv4 or both IPv6.
3816 if (psize
!= 34 && psize
!= 58) {
3817 flog_err(BGP_ERR_EVPN_ROUTE_INVALID
,
3818 "%u:%s - Rx EVPN Type-5 NLRI with invalid length %d",
3819 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3823 /* Make prefix_rd */
3824 prd
.family
= AF_UNSPEC
;
3826 memcpy(&prd
.val
, pfx
, 8);
3829 /* Make EVPN prefix. */
3830 memset(&p
, 0, sizeof(struct prefix_evpn
));
3832 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3833 p
.prefix
.route_type
= BGP_EVPN_IP_PREFIX_ROUTE
;
3835 /* Additional information outside of prefix - ESI and GW IP */
3836 memset(&evpn
, 0, sizeof(evpn
));
3839 memcpy(&evpn
.eth_s_id
.val
, pfx
, 10);
3842 /* Fetch Ethernet Tag. */
3843 memcpy(ð_tag
, pfx
, 4);
3844 p
.prefix
.prefix_addr
.eth_tag
= ntohl(eth_tag
);
3847 /* Fetch IP prefix length. */
3849 if (ippfx_len
> IPV6_MAX_BITLEN
) {
3851 BGP_ERR_EVPN_ROUTE_INVALID
,
3852 "%u:%s - Rx EVPN Type-5 NLRI with invalid IP Prefix length %d",
3853 peer
->bgp
->vrf_id
, peer
->host
, ippfx_len
);
3856 p
.prefix
.prefix_addr
.ip_prefix_length
= ippfx_len
;
3858 /* Determine IPv4 or IPv6 prefix */
3859 /* Since the address and GW are from the same family, this just becomes
3860 * a simple check on the total size.
3863 SET_IPADDR_V4(&p
.prefix
.prefix_addr
.ip
);
3864 memcpy(&p
.prefix
.prefix_addr
.ip
.ipaddr_v4
, pfx
, 4);
3866 memcpy(&evpn
.gw_ip
.ipv4
, pfx
, 4);
3869 SET_IPADDR_V6(&p
.prefix
.prefix_addr
.ip
);
3870 memcpy(&p
.prefix
.prefix_addr
.ip
.ipaddr_v6
, pfx
, 16);
3872 memcpy(&evpn
.gw_ip
.ipv6
, pfx
, 16);
3876 /* Get the VNI (in MPLS label field). Stored as bytes here. */
3877 memset(&label
, 0, sizeof(label
));
3878 memcpy(&label
, pfx
, BGP_LABEL_BYTES
);
3881 * If in future, we are required to access additional fields,
3882 * we MUST increment pfx by BGP_LABEL_BYTES in before reading the next
3886 /* Process the route. */
3888 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3889 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3890 &prd
, &label
, 1, 0, &evpn
);
3892 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3893 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3894 &prd
, &label
, 1, &evpn
);
3899 static void evpn_mpattr_encode_type5(struct stream
*s
, struct prefix
*p
,
3900 struct prefix_rd
*prd
, mpls_label_t
*label
,
3901 uint32_t num_labels
, struct attr
*attr
)
3905 struct evpn_addr
*p_evpn_p
;
3907 memset(&temp
, 0, 16);
3908 if (p
->family
!= AF_EVPN
)
3910 p_evpn_p
= &(p
->u
.prefix_evpn
);
3912 /* len denites the total len of IP and GW-IP in the route
3913 IP and GW-IP have to be both ipv4 or ipv6
3915 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3916 len
= 8; /* IP and GWIP are both ipv4 */
3918 len
= 32; /* IP and GWIP are both ipv6 */
3919 /* Prefix contains RD, ESI, EthTag, IP length, IP, GWIP and VNI */
3920 stream_putc(s
, 8 + 10 + 4 + 1 + len
+ 3);
3921 stream_put(s
, prd
->val
, 8);
3923 stream_put(s
, &(attr
->evpn_overlay
.eth_s_id
), 10);
3925 stream_put(s
, &temp
, 10);
3926 stream_putl(s
, p_evpn_p
->prefix_addr
.eth_tag
);
3927 stream_putc(s
, p_evpn_p
->prefix_addr
.ip_prefix_length
);
3928 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3929 stream_put_ipv4(s
, p_evpn_p
->prefix_addr
.ip
.ipaddr_v4
.s_addr
);
3931 stream_put(s
, &p_evpn_p
->prefix_addr
.ip
.ipaddr_v6
, 16);
3933 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3935 attr
->evpn_overlay
.gw_ip
.ipv4
.s_addr
);
3937 stream_put(s
, &(attr
->evpn_overlay
.gw_ip
.ipv6
), 16);
3939 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3940 stream_put_ipv4(s
, 0);
3942 stream_put(s
, &temp
, 16);
3946 stream_put(s
, label
, 3);
3952 * Cleanup specific VNI upon EVPN (advertise-all-vni) being disabled.
3954 static void cleanup_vni_on_disable(struct hash_backet
*backet
, struct bgp
*bgp
)
3956 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3958 /* Remove EVPN routes and schedule for processing. */
3959 delete_routes_for_vni(bgp
, vpn
);
3961 /* Clear "live" flag and see if hash needs to be freed. */
3962 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
3963 if (!is_vni_configured(vpn
))
3964 bgp_evpn_free(bgp
, vpn
);
3968 * Free a VNI entry; iterator function called during cleanup.
3970 static void free_vni_entry(struct hash_backet
*backet
, struct bgp
*bgp
)
3972 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3974 delete_all_vni_routes(bgp
, vpn
);
3975 bgp_evpn_free(bgp
, vpn
);
3979 * Derive AUTO import RT for BGP VRF - L3VNI
3981 static void evpn_auto_rt_import_add_for_vrf(struct bgp
*bgp_vrf
)
3983 struct bgp
*bgp_def
= NULL
;
3985 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
3986 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3989 bgp_def
= bgp_get_default();
3992 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3996 * Delete AUTO import RT from BGP VRF - L3VNI
3998 static void evpn_auto_rt_import_delete_for_vrf(struct bgp
*bgp_vrf
)
4000 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
4004 * Derive AUTO export RT for BGP VRF - L3VNI
4006 static void evpn_auto_rt_export_add_for_vrf(struct bgp
*bgp_vrf
)
4008 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4009 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
4013 * Delete AUTO export RT from BGP VRF - L3VNI
4015 static void evpn_auto_rt_export_delete_for_vrf(struct bgp
*bgp_vrf
)
4017 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
4020 static void bgp_evpn_handle_export_rt_change_for_vrf(struct bgp
*bgp_vrf
)
4022 struct bgp
*bgp_def
= NULL
;
4023 struct listnode
*node
= NULL
;
4024 struct bgpevpn
*vpn
= NULL
;
4026 bgp_def
= bgp_get_default();
4030 /* update all type-5 routes */
4031 update_advertise_vrf_routes(bgp_vrf
);
4033 /* update all type-2 routes */
4034 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
4035 update_routes_for_vni(bgp_def
, vpn
);
4039 * Handle autort change for a given VNI.
4041 static void update_autort_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
4043 struct bgpevpn
*vpn
= backet
->data
;
4045 if (!is_import_rt_configured(vpn
)) {
4046 if (is_vni_live(vpn
))
4047 bgp_evpn_uninstall_routes(bgp
, vpn
);
4048 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
4049 list_delete_all_node(vpn
->import_rtl
);
4050 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
4051 if (is_vni_live(vpn
))
4052 bgp_evpn_install_routes(bgp
, vpn
);
4054 if (!is_export_rt_configured(vpn
)) {
4055 list_delete_all_node(vpn
->export_rtl
);
4056 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
4057 if (is_vni_live(vpn
))
4058 bgp_evpn_handle_export_rt_change(bgp
, vpn
);
4066 /* withdraw type-5 route corresponding to ip prefix */
4067 void bgp_evpn_withdraw_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
4068 afi_t afi
, safi_t safi
)
4071 struct prefix_evpn evp
;
4072 char buf
[PREFIX_STRLEN
];
4074 build_type5_prefix_from_ip_prefix(&evp
, p
);
4075 ret
= delete_evpn_type5_route(bgp_vrf
, &evp
);
4078 BGP_ERR_EVPN_ROUTE_DELETE
,
4079 "%u failed to delete type-5 route for prefix %s in vrf %s",
4080 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)),
4081 vrf_id_to_name(bgp_vrf
->vrf_id
));
4085 /* withdraw all type-5 routes for an address family */
4086 void bgp_evpn_withdraw_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
, safi_t safi
)
4088 struct bgp_table
*table
= NULL
;
4089 struct bgp_node
*rn
= NULL
;
4090 struct bgp_info
*ri
;
4092 table
= bgp_vrf
->rib
[afi
][safi
];
4093 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4094 /* Only care about "selected" routes - non-imported. */
4095 /* TODO: Support for AddPath for EVPN. */
4096 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
4097 if (CHECK_FLAG(ri
->flags
, BGP_INFO_SELECTED
)
4098 && (!ri
->extra
|| !ri
->extra
->parent
)) {
4099 bgp_evpn_withdraw_type5_route(bgp_vrf
, &rn
->p
,
4108 * Advertise IP prefix as type-5 route. The afi/safi and src_attr passed
4109 * to this function correspond to those of the source IP prefix (best
4110 * path in the case of the attr. In the case of a local prefix (when we
4111 * are advertising local subnets), the src_attr will be NULL.
4113 void bgp_evpn_advertise_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
4114 struct attr
*src_attr
, afi_t afi
,
4118 struct prefix_evpn evp
;
4119 char buf
[PREFIX_STRLEN
];
4121 build_type5_prefix_from_ip_prefix(&evp
, p
);
4122 ret
= update_evpn_type5_route(bgp_vrf
, &evp
, src_attr
);
4124 flog_err(BGP_ERR_EVPN_ROUTE_CREATE
,
4125 "%u: Failed to create type-5 route for prefix %s",
4126 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)));
4129 /* Inject all prefixes of a particular address-family (currently, IPv4 or
4130 * IPv6 unicast) into EVPN as type-5 routes. This is invoked when the
4131 * advertisement is enabled.
4133 void bgp_evpn_advertise_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
,
4136 struct bgp_table
*table
= NULL
;
4137 struct bgp_node
*rn
= NULL
;
4138 struct bgp_info
*ri
;
4140 table
= bgp_vrf
->rib
[afi
][safi
];
4141 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4142 /* Need to identify the "selected" route entry to use its
4143 * attribute. Also, we only consider "non-imported" routes.
4144 * TODO: Support for AddPath for EVPN.
4146 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
4147 if (CHECK_FLAG(ri
->flags
, BGP_INFO_SELECTED
)
4148 && (!ri
->extra
|| !ri
->extra
->parent
)) {
4150 /* apply the route-map */
4151 if (bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
) {
4154 ret
= route_map_apply(
4155 bgp_vrf
->adv_cmd_rmap
[afi
][safi
]
4157 &rn
->p
, RMAP_BGP
, ri
);
4158 if (ret
== RMAP_DENYMATCH
)
4161 bgp_evpn_advertise_type5_route(
4162 bgp_vrf
, &rn
->p
, ri
->attr
, afi
, safi
);
4169 void evpn_rt_delete_auto(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
4171 struct listnode
*node
, *nnode
, *node_to_del
;
4172 struct ecommunity
*ecom
, *ecom_auto
;
4173 struct ecommunity_val eval
;
4175 if (bgp
->advertise_autort_rfc8365
)
4176 vni
|= EVPN_AUTORT_VXLAN
;
4177 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
4179 ecom_auto
= ecommunity_new();
4180 ecommunity_add_val(ecom_auto
, &eval
);
4183 for (ALL_LIST_ELEMENTS(rtl
, node
, nnode
, ecom
)) {
4184 if (ecommunity_match(ecom
, ecom_auto
)) {
4185 ecommunity_free(&ecom
);
4191 list_delete_node(rtl
, node_to_del
);
4193 ecommunity_free(&ecom_auto
);
4196 void bgp_evpn_configure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
4197 struct ecommunity
*ecomadd
)
4199 /* uninstall routes from vrf */
4200 uninstall_routes_for_vrf(bgp_vrf
);
4202 /* Cleanup the RT to VRF mapping */
4203 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4205 /* Remove auto generated RT */
4206 evpn_auto_rt_import_delete_for_vrf(bgp_vrf
);
4208 /* Add the newly configured RT to RT list */
4209 listnode_add_sort(bgp_vrf
->vrf_import_rtl
, ecomadd
);
4210 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4212 /* map VRF to its RTs */
4213 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4215 /* install routes matching the new VRF */
4216 install_routes_for_vrf(bgp_vrf
);
4219 void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
4220 struct ecommunity
*ecomdel
)
4222 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
4223 struct ecommunity
*ecom
= NULL
;
4225 /* uninstall routes from vrf */
4226 uninstall_routes_for_vrf(bgp_vrf
);
4228 /* Cleanup the RT to VRF mapping */
4229 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4231 /* remove the RT from the RT list */
4232 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4233 if (ecommunity_match(ecom
, ecomdel
)) {
4234 ecommunity_free(&ecom
);
4241 list_delete_node(bgp_vrf
->vrf_import_rtl
, node_to_del
);
4243 assert(bgp_vrf
->vrf_import_rtl
);
4244 /* fallback to auto import rt, if this was the last RT */
4245 if (bgp_vrf
->vrf_import_rtl
&& list_isempty(bgp_vrf
->vrf_import_rtl
)) {
4246 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4247 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
4250 /* map VRFs to its RTs */
4251 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4253 /* install routes matching this new RT */
4254 install_routes_for_vrf(bgp_vrf
);
4257 void bgp_evpn_configure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
4258 struct ecommunity
*ecomadd
)
4260 /* remove auto-generated RT */
4261 evpn_auto_rt_export_delete_for_vrf(bgp_vrf
);
4263 /* Add the new RT to the RT list */
4264 listnode_add_sort(bgp_vrf
->vrf_export_rtl
, ecomadd
);
4265 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4267 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
4270 void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
4271 struct ecommunity
*ecomdel
)
4273 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
4274 struct ecommunity
*ecom
= NULL
;
4276 /* Remove the RT from the RT list */
4277 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_export_rtl
, node
, nnode
, ecom
)) {
4278 if (ecommunity_match(ecom
, ecomdel
)) {
4279 ecommunity_free(&ecom
);
4286 list_delete_node(bgp_vrf
->vrf_export_rtl
, node_to_del
);
4289 * Temporary assert to make SA happy.
4290 * The ALL_LIST_ELEMENTS macro above has a NULL check
4291 * which means that SA is going to complain about
4292 * the list_isempty call, which doesn't NULL check.
4293 * So until we get this situation cleaned up, here
4296 assert(bgp_vrf
->vrf_export_rtl
);
4298 /* fall back to auto-generated RT if this was the last RT */
4299 if (list_isempty(bgp_vrf
->vrf_export_rtl
)) {
4300 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4301 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
4304 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
4308 * Handle change to BGP router id. This is invoked twice by the change
4309 * handler, first before the router id has been changed and then after
4310 * the router id has been changed. The first invocation will result in
4311 * local routes for all VNIs/VRF being deleted and withdrawn and the next
4312 * will result in the routes being re-advertised.
4314 void bgp_evpn_handle_router_id_update(struct bgp
*bgp
, int withdraw
)
4318 /* delete and withdraw all the type-5 routes
4319 stored in the global table for this vrf
4321 withdraw_router_id_vrf(bgp
);
4323 /* delete all the VNI routes (type-2/type-3) routes for all the
4326 hash_iterate(bgp
->vnihash
,
4327 (void (*)(struct hash_backet
*,
4328 void *))withdraw_router_id_vni
,
4332 /* advertise all routes in the vrf as type-5 routes with the new
4335 update_router_id_vrf(bgp
);
4337 /* advertise all the VNI routes (type-2/type-3) routes with the
4340 hash_iterate(bgp
->vnihash
,
4341 (void (*)(struct hash_backet
*,
4342 void *))update_router_id_vni
,
4348 * Handle change to auto-RT algorithm - update and advertise local routes.
4350 void bgp_evpn_handle_autort_change(struct bgp
*bgp
)
4352 hash_iterate(bgp
->vnihash
,
4353 (void (*)(struct hash_backet
*,
4354 void*))update_autort_vni
,
4359 * Handle change to export RT - update and advertise local routes.
4361 int bgp_evpn_handle_export_rt_change(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4363 return update_routes_for_vni(bgp
, vpn
);
4366 void bgp_evpn_handle_vrf_rd_change(struct bgp
*bgp_vrf
, int withdraw
)
4369 delete_withdraw_vrf_routes(bgp_vrf
);
4371 update_advertise_vrf_routes(bgp_vrf
);
4375 * Handle change to RD. This is invoked twice by the change handler,
4376 * first before the RD has been changed and then after the RD has
4377 * been changed. The first invocation will result in local routes
4378 * of this VNI being deleted and withdrawn and the next will result
4379 * in the routes being re-advertised.
4381 void bgp_evpn_handle_rd_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
4385 delete_withdraw_vni_routes(bgp
, vpn
);
4387 update_advertise_vni_routes(bgp
, vpn
);
4391 * Install routes for this VNI. Invoked upon change to Import RT.
4393 int bgp_evpn_install_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4395 return install_routes_for_vni(bgp
, vpn
);
4399 * Uninstall all routes installed for this VNI. Invoked upon change
4402 int bgp_evpn_uninstall_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4404 return uninstall_routes_for_vni(bgp
, vpn
);
4408 * TODO: Hardcoded for a maximum of 2 VNIs right now
4410 char *bgp_evpn_label2str(mpls_label_t
*label
, uint32_t num_labels
, char *buf
,
4415 vni1
= label2vni(label
);
4416 if (num_labels
== 2) {
4417 vni2
= label2vni(label
+ 1);
4418 snprintf(buf
, len
, "%u/%u", vni1
, vni2
);
4420 snprintf(buf
, len
, "%u", vni1
);
4425 * Function to convert evpn route to json format.
4426 * NOTE: We don't use prefix2str as the output here is a bit different.
4428 void bgp_evpn_route2json(struct prefix_evpn
*p
, json_object
*json
)
4430 char buf1
[ETHER_ADDR_STRLEN
];
4431 char buf2
[PREFIX2STR_BUFFER
];
4436 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
4437 json_object_int_add(json
, "routeType", p
->prefix
.route_type
);
4438 json_object_int_add(json
, "ethTag",
4439 p
->prefix
.imet_addr
.eth_tag
);
4440 json_object_int_add(json
, "ipLen",
4441 is_evpn_prefix_ipaddr_v4(p
)
4444 json_object_string_add(json
, "ip",
4445 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
4446 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
4447 if (is_evpn_prefix_ipaddr_none(p
)) {
4448 json_object_int_add(json
, "routeType",
4449 p
->prefix
.route_type
);
4450 json_object_int_add(json
, "ethTag",
4451 p
->prefix
.macip_addr
.eth_tag
);
4452 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
4453 json_object_string_add(json
, "mac",
4454 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
4460 family
= is_evpn_prefix_ipaddr_v4(p
) ? AF_INET
4463 json_object_int_add(json
, "routeType",
4464 p
->prefix
.route_type
);
4465 json_object_int_add(json
, "ethTag",
4466 p
->prefix
.macip_addr
.eth_tag
);
4467 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
4468 json_object_string_add(json
, "mac",
4469 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
4472 json_object_int_add(json
, "ipLen",
4473 is_evpn_prefix_ipaddr_v4(p
)
4476 json_object_string_add(
4479 &p
->prefix
.macip_addr
.ip
.ip
.addr
,
4481 PREFIX2STR_BUFFER
));
4484 /* Currently, this is to cater to other AF_ETHERNET code. */
4489 * Function to convert evpn route to string.
4490 * NOTE: We don't use prefix2str as the output here is a bit different.
4492 char *bgp_evpn_route2str(struct prefix_evpn
*p
, char *buf
, int len
)
4494 char buf1
[ETHER_ADDR_STRLEN
];
4495 char buf2
[PREFIX2STR_BUFFER
];
4496 char buf3
[ESI_STR_LEN
];
4498 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
4499 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]", p
->prefix
.route_type
,
4500 p
->prefix
.imet_addr
.eth_tag
,
4501 is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BITLEN
4503 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
4504 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
4505 if (is_evpn_prefix_ipaddr_none(p
))
4506 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]",
4507 p
->prefix
.route_type
,
4508 p
->prefix
.macip_addr
.eth_tag
,
4510 prefix_mac2str(&p
->prefix
.macip_addr
.mac
, buf1
,
4515 family
= is_evpn_prefix_ipaddr_v4(p
) ? AF_INET
4517 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]:[%d]:[%s]",
4518 p
->prefix
.route_type
,
4519 p
->prefix
.macip_addr
.eth_tag
,
4521 prefix_mac2str(&p
->prefix
.macip_addr
.mac
, buf1
,
4523 family
== AF_INET
? IPV4_MAX_BITLEN
4526 &p
->prefix
.macip_addr
.ip
.ip
.addr
,
4528 PREFIX2STR_BUFFER
));
4530 } else if (p
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
4531 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]",
4532 p
->prefix
.route_type
,
4533 p
->prefix
.prefix_addr
.eth_tag
,
4534 p
->prefix
.prefix_addr
.ip_prefix_length
,
4535 is_evpn_prefix_ipaddr_v4(p
)
4536 ? inet_ntoa(p
->prefix
.prefix_addr
.ip
.ipaddr_v4
)
4537 : inet6_ntoa(p
->prefix
.prefix_addr
.ip
.ipaddr_v6
));
4538 } else if (p
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
) {
4539 snprintf(buf
, len
, "[%d]:[%s]:[%d]:[%s]",
4540 p
->prefix
.route_type
,
4541 esi_to_str(&p
->prefix
.es_addr
.esi
, buf3
, sizeof(buf3
)),
4542 is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BITLEN
4544 inet_ntoa(p
->prefix
.es_addr
.ip
.ipaddr_v4
));
4546 /* For EVPN route types not supported yet. */
4547 snprintf(buf
, len
, "(unsupported route type %d)",
4548 p
->prefix
.route_type
);
4555 * Encode EVPN prefix in Update (MP_REACH)
4557 void bgp_evpn_encode_prefix(struct stream
*s
, struct prefix
*p
,
4558 struct prefix_rd
*prd
, mpls_label_t
*label
,
4559 uint32_t num_labels
, struct attr
*attr
,
4560 int addpath_encode
, uint32_t addpath_tx_id
)
4562 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
4563 int len
, ipa_len
= 0;
4566 stream_putl(s
, addpath_tx_id
);
4569 stream_putc(s
, evp
->prefix
.route_type
);
4571 switch (evp
->prefix
.route_type
) {
4572 case BGP_EVPN_MAC_IP_ROUTE
:
4573 if (is_evpn_prefix_ipaddr_v4(evp
))
4574 ipa_len
= IPV4_MAX_BYTELEN
;
4575 else if (is_evpn_prefix_ipaddr_v6(evp
))
4576 ipa_len
= IPV6_MAX_BYTELEN
;
4577 /* RD, ESI, EthTag, MAC+len, IP len, [IP], 1 VNI */
4578 len
= 8 + 10 + 4 + 1 + 6 + 1 + ipa_len
+ 3;
4579 if (ipa_len
&& num_labels
> 1) /* There are 2 VNIs */
4581 stream_putc(s
, len
);
4582 stream_put(s
, prd
->val
, 8); /* RD */
4584 stream_put(s
, &attr
->evpn_overlay
.eth_s_id
, ESI_LEN
);
4586 stream_put(s
, 0, 10);
4587 stream_putl(s
, evp
->prefix
.macip_addr
.eth_tag
); /* Ethernet Tag ID */
4588 stream_putc(s
, 8 * ETH_ALEN
); /* Mac Addr Len - bits */
4589 stream_put(s
, evp
->prefix
.macip_addr
.mac
.octet
, 6); /* Mac Addr */
4590 stream_putc(s
, 8 * ipa_len
); /* IP address Length */
4591 if (ipa_len
) /* IP */
4592 stream_put(s
, &evp
->prefix
.macip_addr
.ip
.ip
.addr
,
4594 /* 1st label is the L2 VNI */
4595 stream_put(s
, label
, BGP_LABEL_BYTES
);
4596 /* Include 2nd label (L3 VNI) if advertising MAC+IP */
4597 if (ipa_len
&& num_labels
> 1)
4598 stream_put(s
, label
+ 1, BGP_LABEL_BYTES
);
4601 case BGP_EVPN_IMET_ROUTE
:
4602 stream_putc(s
, 17); // TODO: length - assumes IPv4 address
4603 stream_put(s
, prd
->val
, 8); /* RD */
4604 stream_putl(s
, evp
->prefix
.imet_addr
.eth_tag
); /* Ethernet Tag ID */
4605 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
4606 /* Originating Router's IP Addr */
4607 stream_put_in_addr(s
, &evp
->prefix
.imet_addr
.ip
.ipaddr_v4
);
4610 case BGP_EVPN_ES_ROUTE
:
4611 stream_putc(s
, 23); /* TODO: length: assumes ipv4 VTEP */
4612 stream_put(s
, prd
->val
, 8); /* RD */
4613 stream_put(s
, evp
->prefix
.es_addr
.esi
.val
, 10); /* ESI */
4614 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
4616 stream_put_in_addr(s
, &evp
->prefix
.es_addr
.ip
.ipaddr_v4
);
4619 case BGP_EVPN_IP_PREFIX_ROUTE
:
4620 /* TODO: AddPath support. */
4621 evpn_mpattr_encode_type5(s
, p
, prd
, label
, num_labels
, attr
);
4629 int bgp_nlri_parse_evpn(struct peer
*peer
, struct attr
*attr
,
4630 struct bgp_nlri
*packet
, int withdraw
)
4636 uint32_t addpath_id
;
4637 int addpath_encoded
;
4642 /* Start processing the NLRI - there may be multiple in the MP_REACH */
4644 lim
= pnt
+ packet
->length
;
4646 safi
= packet
->safi
;
4650 (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
)
4651 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
4652 PEER_CAP_ADDPATH_AF_TX_RCV
));
4654 for (; pnt
< lim
; pnt
+= psize
) {
4655 /* Clear prefix structure. */
4656 memset(&p
, 0, sizeof(struct prefix
));
4658 /* Deal with path-id if AddPath is supported. */
4659 if (addpath_encoded
) {
4660 /* When packet overflow occurs return immediately. */
4661 if (pnt
+ BGP_ADDPATH_ID_LEN
> lim
)
4664 addpath_id
= ntohl(*((uint32_t *)pnt
));
4665 pnt
+= BGP_ADDPATH_ID_LEN
;
4668 /* All EVPN NLRI types start with type and length. */
4675 /* When packet overflow occur return immediately. */
4676 if (pnt
+ psize
> lim
)
4680 case BGP_EVPN_MAC_IP_ROUTE
:
4681 if (process_type2_route(peer
, afi
, safi
,
4682 withdraw
? NULL
: attr
, pnt
,
4683 psize
, addpath_id
)) {
4686 "%u:%s - Error in processing EVPN type-2 NLRI size %d",
4687 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4692 case BGP_EVPN_IMET_ROUTE
:
4693 if (process_type3_route(peer
, afi
, safi
,
4694 withdraw
? NULL
: attr
, pnt
,
4695 psize
, addpath_id
)) {
4697 BGP_ERR_PKT_PROCESS
,
4698 "%u:%s - Error in processing EVPN type-3 NLRI size %d",
4699 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4704 case BGP_EVPN_ES_ROUTE
:
4705 if (process_type4_route(peer
, afi
, safi
,
4706 withdraw
? NULL
: attr
, pnt
,
4707 psize
, addpath_id
)) {
4709 BGP_ERR_PKT_PROCESS
,
4710 "%u:%s - Error in processing EVPN type-4 NLRI size %d",
4711 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4716 case BGP_EVPN_IP_PREFIX_ROUTE
:
4717 if (process_type5_route(peer
, afi
, safi
, attr
, pnt
,
4718 psize
, addpath_id
, withdraw
)) {
4720 BGP_ERR_PKT_PROCESS
,
4721 "%u:%s - Error in processing EVPN type-5 NLRI size %d",
4722 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4732 /* Packet length consistency check. */
4740 * Map the RTs (configured or automatically derived) of a VRF to the VRF.
4741 * The mapping will be used during route processing.
4742 * bgp_def: default bgp instance
4743 * bgp_vrf: specific bgp vrf instance on which RT is configured
4745 void bgp_evpn_map_vrf_to_its_rts(struct bgp
*bgp_vrf
)
4748 struct ecommunity_val
*eval
= NULL
;
4749 struct listnode
*node
= NULL
, *nnode
= NULL
;
4750 struct ecommunity
*ecom
= NULL
;
4752 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4753 for (i
= 0; i
< ecom
->size
; i
++) {
4754 eval
= (struct ecommunity_val
*)(ecom
->val
4756 * ECOMMUNITY_SIZE
));
4757 map_vrf_to_rt(bgp_vrf
, eval
);
4763 * Unmap the RTs (configured or automatically derived) of a VRF from the VRF.
4765 void bgp_evpn_unmap_vrf_from_its_rts(struct bgp
*bgp_vrf
)
4768 struct ecommunity_val
*eval
;
4769 struct listnode
*node
, *nnode
;
4770 struct ecommunity
*ecom
;
4772 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4773 for (i
= 0; i
< ecom
->size
; i
++) {
4774 struct vrf_irt_node
*irt
;
4775 struct ecommunity_val eval_tmp
;
4777 eval
= (struct ecommunity_val
*)(ecom
->val
4779 * ECOMMUNITY_SIZE
));
4780 /* If using "automatic" RT, we only care about the
4781 * local-admin sub-field.
4782 * This is to facilitate using VNI as the RT for EBGP
4785 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
4786 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
,
4787 BGP_VRF_IMPORT_RT_CFGD
))
4788 mask_ecom_global_admin(&eval_tmp
, eval
);
4790 irt
= lookup_vrf_import_rt(&eval_tmp
);
4792 unmap_vrf_from_rt(bgp_vrf
, irt
);
4799 * Map the RTs (configured or automatically derived) of a VNI to the VNI.
4800 * The mapping will be used during route processing.
4802 void bgp_evpn_map_vni_to_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4805 struct ecommunity_val
*eval
;
4806 struct listnode
*node
, *nnode
;
4807 struct ecommunity
*ecom
;
4809 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
4810 for (i
= 0; i
< ecom
->size
; i
++) {
4811 eval
= (struct ecommunity_val
*)(ecom
->val
4813 * ECOMMUNITY_SIZE
));
4814 map_vni_to_rt(bgp
, vpn
, eval
);
4820 * Unmap the RTs (configured or automatically derived) of a VNI from the VNI.
4822 void bgp_evpn_unmap_vni_from_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4825 struct ecommunity_val
*eval
;
4826 struct listnode
*node
, *nnode
;
4827 struct ecommunity
*ecom
;
4829 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
4830 for (i
= 0; i
< ecom
->size
; i
++) {
4831 struct irt_node
*irt
;
4832 struct ecommunity_val eval_tmp
;
4834 eval
= (struct ecommunity_val
*)(ecom
->val
4836 * ECOMMUNITY_SIZE
));
4837 /* If using "automatic" RT, we only care about the
4838 * local-admin sub-field.
4839 * This is to facilitate using VNI as the RT for EBGP
4842 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
4843 if (!is_import_rt_configured(vpn
))
4844 mask_ecom_global_admin(&eval_tmp
, eval
);
4846 irt
= lookup_import_rt(bgp
, &eval_tmp
);
4848 unmap_vni_from_rt(bgp
, vpn
, irt
);
4854 * Derive Import RT automatically for VNI and map VNI to RT.
4855 * The mapping will be used during route processing.
4857 void bgp_evpn_derive_auto_rt_import(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4859 form_auto_rt(bgp
, vpn
->vni
, vpn
->import_rtl
);
4860 UNSET_FLAG(vpn
->flags
, VNI_FLAG_IMPRT_CFGD
);
4863 bgp_evpn_map_vni_to_its_rts(bgp
, vpn
);
4867 * Derive Export RT automatically for VNI.
4869 void bgp_evpn_derive_auto_rt_export(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4871 form_auto_rt(bgp
, vpn
->vni
, vpn
->export_rtl
);
4872 UNSET_FLAG(vpn
->flags
, VNI_FLAG_EXPRT_CFGD
);
4876 * Derive RD automatically for VNI using passed information - it
4877 * is of the form RouterId:unique-id-for-vni.
4879 void bgp_evpn_derive_auto_rd_for_vrf(struct bgp
*bgp
)
4881 form_auto_rd(bgp
->router_id
, bgp
->vrf_rd_id
, &bgp
->vrf_prd
);
4885 * Derive RD automatically for VNI using passed information - it
4886 * is of the form RouterId:unique-id-for-vni.
4888 void bgp_evpn_derive_auto_rd(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4892 vpn
->prd
.family
= AF_UNSPEC
;
4893 vpn
->prd
.prefixlen
= 64;
4894 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), vpn
->rd_id
);
4895 (void)str2prefix_rd(buf
, &vpn
->prd
);
4896 UNSET_FLAG(vpn
->flags
, VNI_FLAG_RD_CFGD
);
4902 bool bgp_evpn_lookup_l3vni_l2vni_table(vni_t vni
)
4904 struct list
*inst
= bm
->bgp
;
4905 struct listnode
*node
;
4906 struct bgp
*bgp_vrf
;
4908 for (ALL_LIST_ELEMENTS_RO(inst
, node
, bgp_vrf
)) {
4909 if (bgp_vrf
->l3vni
== vni
)
4919 struct bgpevpn
*bgp_evpn_lookup_vni(struct bgp
*bgp
, vni_t vni
)
4921 struct bgpevpn
*vpn
;
4924 memset(&tmp
, 0, sizeof(struct bgpevpn
));
4926 vpn
= hash_lookup(bgp
->vnihash
, &tmp
);
4931 * Create a new vpn - invoked upon configuration or zebra notification.
4933 struct bgpevpn
*bgp_evpn_new(struct bgp
*bgp
, vni_t vni
,
4934 struct in_addr originator_ip
,
4935 vrf_id_t tenant_vrf_id
)
4937 struct bgpevpn
*vpn
;
4942 vpn
= XCALLOC(MTYPE_BGP_EVPN
, sizeof(struct bgpevpn
));
4946 /* Set values - RD and RT set to defaults. */
4948 vpn
->originator_ip
= originator_ip
;
4949 vpn
->tenant_vrf_id
= tenant_vrf_id
;
4951 /* Initialize route-target import and export lists */
4952 vpn
->import_rtl
= list_new();
4953 vpn
->import_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
4954 vpn
->import_rtl
->del
= evpn_xxport_delete_ecomm
;
4955 vpn
->export_rtl
= list_new();
4956 vpn
->export_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
4957 vpn
->export_rtl
->del
= evpn_xxport_delete_ecomm
;
4958 bf_assign_index(bm
->rd_idspace
, vpn
->rd_id
);
4959 derive_rd_rt_for_vni(bgp
, vpn
);
4961 /* Initialize EVPN route table. */
4962 vpn
->route_table
= bgp_table_init(bgp
, AFI_L2VPN
, SAFI_EVPN
);
4965 if (!hash_get(bgp
->vnihash
, vpn
, hash_alloc_intern
)) {
4966 XFREE(MTYPE_BGP_EVPN
, vpn
);
4970 /* add to l2vni list on corresponding vrf */
4971 bgpevpn_link_to_l3vni(vpn
);
4973 QOBJ_REG(vpn
, bgpevpn
);
4978 * Free a given VPN - called in multiple scenarios such as zebra
4979 * notification, configuration being deleted, advertise-all-vni disabled etc.
4980 * This just frees appropriate memory, caller should have taken other
4983 void bgp_evpn_free(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4985 bgpevpn_unlink_from_l3vni(vpn
);
4986 bgp_table_unlock(vpn
->route_table
);
4987 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
4988 list_delete_and_null(&vpn
->import_rtl
);
4989 list_delete_and_null(&vpn
->export_rtl
);
4990 bf_release_index(bm
->rd_idspace
, vpn
->rd_id
);
4991 hash_release(bgp
->vnihash
, vpn
);
4993 XFREE(MTYPE_BGP_EVPN
, vpn
);
4999 struct evpnes
*bgp_evpn_lookup_es(struct bgp
*bgp
, esi_t
*esi
)
5004 memset(&tmp
, 0, sizeof(struct evpnes
));
5005 memcpy(&tmp
.esi
, esi
, sizeof(esi_t
));
5006 es
= hash_lookup(bgp
->esihash
, &tmp
);
5011 * Create a new local es - invoked upon zebra notification.
5013 struct evpnes
*bgp_evpn_es_new(struct bgp
*bgp
,
5015 struct ipaddr
*originator_ip
)
5023 es
= XCALLOC(MTYPE_BGP_EVPN_ES
, sizeof(struct evpnes
));
5027 /* set the ESI and originator_ip */
5028 memcpy(&es
->esi
, esi
, sizeof(esi_t
));
5029 memcpy(&es
->originator_ip
, originator_ip
, sizeof(struct ipaddr
));
5031 /* Initialise the VTEP list */
5032 es
->vtep_list
= list_new();
5033 es
->vtep_list
->cmp
= (int (*)(void *, void *))evpn_vtep_ip_cmp
;
5035 /* auto derive RD for this es */
5036 bf_assign_index(bm
->rd_idspace
, es
->rd_id
);
5037 es
->prd
.family
= AF_UNSPEC
;
5038 es
->prd
.prefixlen
= 64;
5039 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), es
->rd_id
);
5040 (void)str2prefix_rd(buf
, &es
->prd
);
5042 /* Initialize the ES route table */
5043 es
->route_table
= bgp_table_init(bgp
, AFI_L2VPN
, SAFI_EVPN
);
5046 if (!hash_get(bgp
->esihash
, es
, hash_alloc_intern
)) {
5047 XFREE(MTYPE_BGP_EVPN_ES
, es
);
5051 QOBJ_REG(es
, evpnes
);
5057 * This just frees appropriate memory, caller should have taken other
5060 void bgp_evpn_es_free(struct bgp
*bgp
, struct evpnes
*es
)
5062 list_delete_and_null(&es
->vtep_list
);
5063 bgp_table_unlock(es
->route_table
);
5064 bf_release_index(bm
->rd_idspace
, es
->rd_id
);
5065 hash_release(bgp
->esihash
, es
);
5067 XFREE(MTYPE_BGP_EVPN_ES
, es
);
5071 * Import evpn route from global table to VNI/VRF/ESI.
5073 int bgp_evpn_import_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5074 struct prefix
*p
, struct bgp_info
*ri
)
5076 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, ri
, 1);
5080 * Unimport evpn route from VNI/VRF/ESI.
5082 int bgp_evpn_unimport_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5083 struct prefix
*p
, struct bgp_info
*ri
)
5085 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, ri
, 0);
5088 /* filter routes which have martian next hops */
5089 int bgp_filter_evpn_routes_upon_martian_nh_change(struct bgp
*bgp
)
5093 struct bgp_node
*rd_rn
, *rn
;
5094 struct bgp_table
*table
;
5095 struct bgp_info
*ri
;
5100 /* Walk entire global routing table and evaluate routes which could be
5101 * imported into this VPN. Note that we cannot just look at the routes
5102 * for the VNI's RD -
5103 * remote routes applicable for this VNI could have any RD.
5105 /* EVPN routes are a 2-level table. */
5106 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
5107 rd_rn
= bgp_route_next(rd_rn
)) {
5108 table
= (struct bgp_table
*)(rd_rn
->info
);
5112 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
5114 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
5116 /* Consider "valid" remote routes applicable for
5118 if (!(ri
->type
== ZEBRA_ROUTE_BGP
5119 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
5122 if (bgp_nexthop_self(bgp
, ri
->attr
->nexthop
)) {
5124 char attr_str
[BUFSIZ
];
5125 char pbuf
[PREFIX_STRLEN
];
5127 bgp_dump_attr(ri
->attr
, attr_str
,
5130 if (bgp_debug_update(ri
->peer
, &rn
->p
,
5133 "%u: prefix %s with attr %s - DENIED due to martian or self nexthop",
5140 bgp_evpn_unimport_route(bgp
, afi
, safi
,
5143 bgp_rib_remove(rn
, ri
, ri
->peer
, afi
,
5154 * Handle del of a local MACIP.
5156 int bgp_evpn_local_macip_del(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
5159 struct bgpevpn
*vpn
;
5160 struct prefix_evpn p
;
5162 /* Lookup VNI hash - should exist. */
5163 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5164 if (!vpn
|| !is_vni_live(vpn
)) {
5165 zlog_warn("%u: VNI hash entry for VNI %u %s at MACIP DEL",
5166 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
5170 /* Remove EVPN type-2 route and schedule for processing. */
5171 build_evpn_type2_prefix(&p
, mac
, ip
);
5172 delete_evpn_route(bgp
, vpn
, &p
);
5178 * Handle add of a local MACIP.
5180 int bgp_evpn_local_macip_add(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
5181 struct ipaddr
*ip
, uint8_t flags
, uint32_t seq
)
5183 struct bgpevpn
*vpn
;
5184 struct prefix_evpn p
;
5186 /* Lookup VNI hash - should exist. */
5187 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5188 if (!vpn
|| !is_vni_live(vpn
)) {
5189 zlog_warn("%u: VNI hash entry for VNI %u %s at MACIP ADD",
5190 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
5194 /* Create EVPN type-2 route and schedule for processing. */
5195 build_evpn_type2_prefix(&p
, mac
, ip
);
5196 if (update_evpn_route(bgp
, vpn
, &p
, flags
, seq
)) {
5197 char buf
[ETHER_ADDR_STRLEN
];
5198 char buf2
[INET6_ADDRSTRLEN
];
5201 BGP_ERR_EVPN_ROUTE_CREATE
,
5202 "%u:Failed to create Type-2 route, VNI %u %s MAC %s IP %s (flags: 0x%x)",
5203 bgp
->vrf_id
, vpn
->vni
,
5204 CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
)
5207 prefix_mac2str(mac
, buf
, sizeof(buf
)),
5208 ipaddr2str(ip
, buf2
, sizeof(buf2
)), flags
);
5215 static void link_l2vni_hash_to_l3vni(struct hash_backet
*backet
,
5216 struct bgp
*bgp_vrf
)
5218 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
5219 struct bgp
*bgp_def
= NULL
;
5221 bgp_def
= bgp_get_default();
5224 if (vpn
->tenant_vrf_id
== bgp_vrf
->vrf_id
)
5225 bgpevpn_link_to_l3vni(vpn
);
5228 int bgp_evpn_local_l3vni_add(vni_t l3vni
, vrf_id_t vrf_id
, struct ethaddr
*rmac
,
5229 struct in_addr originator_ip
, int filter
)
5231 struct bgp
*bgp_vrf
= NULL
; /* bgp VRF instance */
5232 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
5233 struct listnode
*node
= NULL
;
5234 struct bgpevpn
*vpn
= NULL
;
5237 /* get the default instance - required to get the AS number for VRF
5240 bgp_def
= bgp_get_default();
5244 "Cannot process L3VNI %u ADD - default BGP instance not yet created",
5250 /* if the BGP vrf instance doesnt exist - create one */
5251 bgp_vrf
= bgp_lookup_by_name(vrf_id_to_name(vrf_id
));
5256 ret
= bgp_get(&bgp_vrf
, &as
, vrf_id_to_name(vrf_id
),
5257 BGP_INSTANCE_TYPE_VRF
);
5259 case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
:
5260 flog_err(BGP_ERR_MULTI_INSTANCE
,
5261 "'bgp multiple-instance' not present\n");
5263 case BGP_ERR_AS_MISMATCH
:
5264 flog_err(BGP_ERR_EVPN_AS_MISMATCH
,
5265 "BGP is already running; AS is %u\n", as
);
5267 case BGP_ERR_INSTANCE_MISMATCH
:
5268 flog_err(BGP_ERR_EVPN_INSTANCE_MISMATCH
,
5269 "BGP instance name and AS number mismatch\n");
5273 /* mark as auto created */
5274 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
);
5277 /* associate with l3vni */
5278 bgp_vrf
->l3vni
= l3vni
;
5280 /* set the router mac - to be used in mac-ip routes for this vrf */
5281 memcpy(&bgp_vrf
->rmac
, rmac
, sizeof(struct ethaddr
));
5283 /* set the originator ip */
5284 bgp_vrf
->originator_ip
= originator_ip
;
5286 /* set the right filter - are we using l3vni only for prefix routes? */
5288 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
);
5290 /* auto derive RD/RT */
5291 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
5292 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
5293 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
))
5294 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
5295 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
5297 /* link all corresponding l2vnis */
5298 hash_iterate(bgp_def
->vnihash
,
5299 (void (*)(struct hash_backet
*,
5300 void *))link_l2vni_hash_to_l3vni
,
5303 /* Only update all corresponding type-2 routes if we are advertising two
5304 * labels along with type-2 routes
5307 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
5308 update_routes_for_vni(bgp_def
, vpn
);
5310 /* advertise type-5 routes if needed */
5311 update_advertise_vrf_routes(bgp_vrf
);
5313 /* install all remote routes belonging to this l3vni into correspondng
5315 install_routes_for_vrf(bgp_vrf
);
5320 int bgp_evpn_local_l3vni_del(vni_t l3vni
, vrf_id_t vrf_id
)
5322 struct bgp
*bgp_vrf
= NULL
; /* bgp vrf instance */
5323 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
5324 struct listnode
*node
= NULL
;
5325 struct listnode
*next
= NULL
;
5326 struct bgpevpn
*vpn
= NULL
;
5328 bgp_vrf
= bgp_lookup_by_vrf_id(vrf_id
);
5332 "Cannot process L3VNI %u Del - Could not find BGP instance",
5337 bgp_def
= bgp_get_default();
5341 "Cannot process L3VNI %u Del - Could not find default BGP instance",
5346 /* Remove remote routes from BGT VRF even if BGP_VRF_AUTO is configured,
5347 * bgp_delete would not remove/decrement bgp_info of the ip_prefix
5348 * routes. This will uninstalling the routes from zebra and decremnt the
5351 uninstall_routes_for_vrf(bgp_vrf
);
5353 /* delete/withdraw all type-5 routes */
5354 delete_withdraw_vrf_routes(bgp_vrf
);
5356 /* remove the l3vni from vrf instance */
5359 /* remove the Rmac from the BGP vrf */
5360 memset(&bgp_vrf
->rmac
, 0, sizeof(struct ethaddr
));
5363 if (!list_isempty(bgp_vrf
->vrf_import_rtl
)) {
5364 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
5365 list_delete_all_node(bgp_vrf
->vrf_import_rtl
);
5367 if (!list_isempty(bgp_vrf
->vrf_export_rtl
)) {
5368 list_delete_all_node(bgp_vrf
->vrf_export_rtl
);
5371 /* update all corresponding local mac-ip routes */
5372 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
)) {
5373 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
)) {
5374 UNSET_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
);
5375 update_routes_for_vni(bgp_def
, vpn
);
5379 /* If any L2VNIs point to this instance, unlink them. */
5380 for (ALL_LIST_ELEMENTS(bgp_vrf
->l2vnis
, node
, next
, vpn
))
5381 bgpevpn_unlink_from_l3vni(vpn
);
5383 /* Delete the instance if it was autocreated */
5384 if (CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
))
5385 bgp_delete(bgp_vrf
);
5391 * Handle del of a local VNI.
5393 int bgp_evpn_local_vni_del(struct bgp
*bgp
, vni_t vni
)
5395 struct bgpevpn
*vpn
;
5397 /* Locate VNI hash */
5398 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5400 if (bgp_debug_zebra(NULL
))
5402 "%u: VNI hash entry for VNI %u not found at DEL",
5407 /* Remove all local EVPN routes and schedule for processing (to
5408 * withdraw from peers).
5410 delete_routes_for_vni(bgp
, vpn
);
5413 * tunnel is no longer active, del tunnel ip address from tip_hash
5415 bgp_tip_del(bgp
, &vpn
->originator_ip
);
5417 /* Clear "live" flag and see if hash needs to be freed. */
5418 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
5419 if (!is_vni_configured(vpn
))
5420 bgp_evpn_free(bgp
, vpn
);
5426 * Handle add (or update) of a local VNI. The VNI changes we care
5427 * about are for the local-tunnel-ip and the (tenant) VRF.
5429 int bgp_evpn_local_vni_add(struct bgp
*bgp
, vni_t vni
,
5430 struct in_addr originator_ip
, vrf_id_t tenant_vrf_id
)
5432 struct bgpevpn
*vpn
;
5433 struct prefix_evpn p
;
5435 /* Lookup VNI. If present and no change, exit. */
5436 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5439 if (is_vni_live(vpn
)
5440 && IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
)
5441 && vpn
->tenant_vrf_id
== tenant_vrf_id
)
5442 /* Probably some other param has changed that we don't
5446 /* Update tenant_vrf_id if it has changed. */
5447 if (vpn
->tenant_vrf_id
!= tenant_vrf_id
) {
5448 bgpevpn_unlink_from_l3vni(vpn
);
5449 vpn
->tenant_vrf_id
= tenant_vrf_id
;
5450 bgpevpn_link_to_l3vni(vpn
);
5453 /* If tunnel endpoint IP has changed, update (and delete prior
5454 * type-3 route, if needed.)
5456 if (!IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
))
5457 handle_tunnel_ip_change(bgp
, vpn
, originator_ip
);
5459 /* Update all routes with new endpoint IP and/or export RT
5462 if (is_vni_live(vpn
))
5463 update_routes_for_vni(bgp
, vpn
);
5466 /* Create or update as appropriate. */
5468 vpn
= bgp_evpn_new(bgp
, vni
, originator_ip
, tenant_vrf_id
);
5472 "%u: Failed to allocate VNI entry for VNI %u - at Add",
5478 /* if the VNI is live already, there is nothing more to do */
5479 if (is_vni_live(vpn
))
5482 /* Mark as "live" */
5483 SET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
5485 /* tunnel is now active, add tunnel-ip to db */
5486 bgp_tip_add(bgp
, &originator_ip
);
5488 /* filter routes as nexthop database has changed */
5489 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
5491 /* Create EVPN type-3 route and schedule for processing. */
5492 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
5493 if (update_evpn_route(bgp
, vpn
, &p
, 0, 0)) {
5494 flog_err(BGP_ERR_EVPN_ROUTE_CREATE
,
5495 "%u: Type3 route creation failure for VNI %u",
5500 /* If we have learnt and retained remote routes (VTEPs, MACs) for this
5504 install_routes_for_vni(bgp
, vpn
);
5506 /* If we are advertising gateway mac-ip
5507 It needs to be conveyed again to zebra */
5508 bgp_zebra_advertise_gw_macip(bgp
, vpn
->advertise_gw_macip
, vpn
->vni
);
5514 * bgp_evpn_local_es_del
5516 int bgp_evpn_local_es_del(struct bgp
*bgp
,
5518 struct ipaddr
*originator_ip
)
5520 char buf
[ESI_STR_LEN
];
5521 struct evpnes
*es
= NULL
;
5523 if (!bgp
->esihash
) {
5524 flog_err(BGP_ERR_ES_CREATE
, "%u: ESI hash not yet created",
5529 /* Lookup ESI hash - should exist. */
5530 es
= bgp_evpn_lookup_es(bgp
, esi
);
5532 zlog_warn("%u: ESI hash entry for ESI %s at Local ES DEL",
5534 esi_to_str(esi
, buf
, sizeof(buf
)));
5538 /* Delete all local EVPN ES routes from ESI table
5539 * and schedule for processing (to withdraw from peers))
5541 delete_routes_for_es(bgp
, es
);
5543 /* free the hash entry */
5544 bgp_evpn_es_free(bgp
, es
);
5550 * bgp_evpn_local_es_add
5552 int bgp_evpn_local_es_add(struct bgp
*bgp
,
5554 struct ipaddr
*originator_ip
)
5556 char buf
[ESI_STR_LEN
];
5557 struct evpnes
*es
= NULL
;
5558 struct prefix_evpn p
;
5560 if (!bgp
->esihash
) {
5561 flog_err(BGP_ERR_ES_CREATE
, "%u: ESI hash not yet created",
5566 /* create the new es */
5567 es
= bgp_evpn_lookup_es(bgp
, esi
);
5569 es
= bgp_evpn_es_new(bgp
, esi
, originator_ip
);
5573 "%u: Failed to allocate ES entry for ESI %s - at Local ES Add",
5574 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5578 UNSET_FLAG(es
->flags
, EVPNES_REMOTE
);
5579 SET_FLAG(es
->flags
, EVPNES_LOCAL
);
5581 build_evpn_type4_prefix(&p
, esi
, originator_ip
->ipaddr_v4
);
5582 if (update_evpn_type4_route(bgp
, es
, &p
)) {
5583 flog_err(BGP_ERR_EVPN_ROUTE_CREATE
,
5584 "%u: Type4 route creation failure for ESI %s",
5585 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5589 /* import all remote ES routes in th ES table */
5590 install_routes_for_es(bgp
, es
);
5596 * Cleanup EVPN information on disable - Need to delete and withdraw
5597 * EVPN routes from peers.
5599 void bgp_evpn_cleanup_on_disable(struct bgp
*bgp
)
5601 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_backet
*,
5602 void *))cleanup_vni_on_disable
,
5607 * Cleanup EVPN information - invoked at the time of bgpd exit or when the
5608 * BGP instance (default) is being freed.
5610 void bgp_evpn_cleanup(struct bgp
*bgp
)
5612 hash_iterate(bgp
->vnihash
,
5613 (void (*)(struct hash_backet
*, void *))free_vni_entry
,
5616 hash_free(bgp
->import_rt_hash
);
5617 bgp
->import_rt_hash
= NULL
;
5619 hash_free(bgp
->vrf_import_rt_hash
);
5620 bgp
->vrf_import_rt_hash
= NULL
;
5622 hash_free(bgp
->vnihash
);
5623 bgp
->vnihash
= NULL
;
5625 hash_free(bgp
->esihash
);
5626 bgp
->esihash
= NULL
;
5628 list_delete_and_null(&bgp
->vrf_import_rtl
);
5629 list_delete_and_null(&bgp
->vrf_export_rtl
);
5630 list_delete_and_null(&bgp
->l2vnis
);
5634 * Initialization for EVPN
5637 * hash for RT to VNI
5639 void bgp_evpn_init(struct bgp
*bgp
)
5642 hash_create(vni_hash_key_make
, vni_hash_cmp
, "BGP VNI Hash");
5644 hash_create(esi_hash_keymake
, esi_cmp
,
5645 "BGP EVPN Local ESI Hash");
5646 bgp
->import_rt_hash
=
5647 hash_create(import_rt_hash_key_make
, import_rt_hash_cmp
,
5648 "BGP Import RT Hash");
5649 bgp
->vrf_import_rt_hash
=
5650 hash_create(vrf_import_rt_hash_key_make
, vrf_import_rt_hash_cmp
,
5651 "BGP VRF Import RT Hash");
5652 bgp
->vrf_import_rtl
= list_new();
5653 bgp
->vrf_import_rtl
->cmp
=
5654 (int (*)(void *, void *))evpn_route_target_cmp
;
5655 bgp
->vrf_import_rtl
->del
= evpn_xxport_delete_ecomm
;
5656 bgp
->vrf_export_rtl
= list_new();
5657 bgp
->vrf_export_rtl
->cmp
=
5658 (int (*)(void *, void *))evpn_route_target_cmp
;
5659 bgp
->vrf_export_rtl
->del
= evpn_xxport_delete_ecomm
;
5660 bgp
->l2vnis
= list_new();
5661 bgp
->l2vnis
->cmp
= (int (*)(void *, void *))vni_hash_cmp
;
5664 void bgp_evpn_vrf_delete(struct bgp
*bgp_vrf
)
5666 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);