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(EC_BGP_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(EC_BGP_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();
229 flog_err(EC_BGP_NO_DFLT
,
230 "vrf import rt lookup - def instance not created yet");
234 memset(&tmp
, 0, sizeof(struct vrf_irt_node
));
235 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
236 irt
= hash_lookup(bgp_def
->vrf_import_rt_hash
, &tmp
);
241 * Is specified VRF present on the RT's list of "importing" VRFs?
243 static int is_vrf_present_in_irt_vrfs(struct list
*vrfs
, struct bgp
*bgp_vrf
)
245 struct listnode
*node
= NULL
, *nnode
= NULL
;
246 struct bgp
*tmp_bgp_vrf
= NULL
;
248 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, tmp_bgp_vrf
)) {
249 if (tmp_bgp_vrf
== bgp_vrf
)
256 * Make import route target hash key.
258 static unsigned int import_rt_hash_key_make(void *p
)
260 struct irt_node
*irt
= p
;
261 char *pnt
= irt
->rt
.val
;
263 return jhash(pnt
, 8, 0xdeadbeef);
267 * Comparison function for import rt hash
269 static int import_rt_hash_cmp(const void *p1
, const void *p2
)
271 const struct irt_node
*irt1
= p1
;
272 const struct irt_node
*irt2
= p2
;
274 if (irt1
== NULL
&& irt2
== NULL
)
277 if (irt1
== NULL
|| irt2
== NULL
)
280 return (memcmp(irt1
->rt
.val
, irt2
->rt
.val
, ECOMMUNITY_SIZE
) == 0);
284 * Create a new import_rt
286 static struct irt_node
*import_rt_new(struct bgp
*bgp
,
287 struct ecommunity_val
*rt
)
289 struct irt_node
*irt
;
294 irt
= XCALLOC(MTYPE_BGP_EVPN_IMPORT_RT
, sizeof(struct irt_node
));
299 irt
->vnis
= list_new();
302 if (!hash_get(bgp
->import_rt_hash
, irt
, hash_alloc_intern
)) {
303 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
311 * Free the import rt node
313 static void import_rt_free(struct bgp
*bgp
, struct irt_node
*irt
)
315 hash_release(bgp
->import_rt_hash
, irt
);
316 list_delete_and_null(&irt
->vnis
);
317 XFREE(MTYPE_BGP_EVPN_IMPORT_RT
, irt
);
321 * Function to lookup Import RT node - used to map a RT to set of
322 * VNIs importing routes with that RT.
324 static struct irt_node
*lookup_import_rt(struct bgp
*bgp
,
325 struct ecommunity_val
*rt
)
327 struct irt_node
*irt
;
330 memset(&tmp
, 0, sizeof(struct irt_node
));
331 memcpy(&tmp
.rt
, rt
, ECOMMUNITY_SIZE
);
332 irt
= hash_lookup(bgp
->import_rt_hash
, &tmp
);
337 * Is specified VNI present on the RT's list of "importing" VNIs?
339 static int is_vni_present_in_irt_vnis(struct list
*vnis
, struct bgpevpn
*vpn
)
341 struct listnode
*node
, *nnode
;
342 struct bgpevpn
*tmp_vpn
;
344 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, tmp_vpn
)) {
353 * Compare Route Targets.
355 static int evpn_route_target_cmp(struct ecommunity
*ecom1
,
356 struct ecommunity
*ecom2
)
364 if (!ecom1
&& !ecom2
)
367 if (ecom1
->str
&& !ecom2
->str
)
370 if (!ecom1
->str
&& ecom2
->str
)
373 if (!ecom1
->str
&& !ecom2
->str
)
376 return strcmp(ecom1
->str
, ecom2
->str
);
379 static void evpn_xxport_delete_ecomm(void *val
)
381 struct ecommunity
*ecomm
= val
;
382 ecommunity_free(&ecomm
);
386 * Mask off global-admin field of specified extended community (RT),
387 * just retain the local-admin field.
389 static inline void mask_ecom_global_admin(struct ecommunity_val
*dst
,
390 struct ecommunity_val
*src
)
396 if (type
== ECOMMUNITY_ENCODE_AS
) {
397 dst
->val
[2] = dst
->val
[3] = 0;
398 } else if (type
== ECOMMUNITY_ENCODE_AS4
399 || type
== ECOMMUNITY_ENCODE_IP
) {
400 dst
->val
[2] = dst
->val
[3] = 0;
401 dst
->val
[4] = dst
->val
[5] = 0;
406 * Map one RT to specified VRF.
407 * bgp_vrf = BGP vrf instance
409 static void map_vrf_to_rt(struct bgp
*bgp_vrf
, struct ecommunity_val
*eval
)
411 struct vrf_irt_node
*irt
= NULL
;
412 struct ecommunity_val eval_tmp
;
414 /* If using "automatic" RT,
415 * we only care about the local-admin sub-field.
416 * This is to facilitate using L3VNI(VRF-VNI)
417 * as the RT for EBGP peering too.
419 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
420 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
421 mask_ecom_global_admin(&eval_tmp
, eval
);
423 irt
= lookup_vrf_import_rt(&eval_tmp
);
424 if (irt
&& is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
425 /* Already mapped. */
429 irt
= vrf_import_rt_new(&eval_tmp
);
431 /* Add VRF to the list for this RT. */
432 listnode_add(irt
->vrfs
, bgp_vrf
);
436 * Unmap specified VRF from specified RT. If there are no other
437 * VRFs for this RT, then the RT hash is deleted.
438 * bgp_vrf: BGP VRF specific instance
440 static void unmap_vrf_from_rt(struct bgp
*bgp_vrf
, struct vrf_irt_node
*irt
)
442 /* Delete VRF from list for this RT. */
443 listnode_delete(irt
->vrfs
, bgp_vrf
);
444 if (!listnode_head(irt
->vrfs
)) {
445 vrf_import_rt_free(irt
);
450 * Map one RT to specified VNI.
452 static void map_vni_to_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
453 struct ecommunity_val
*eval
)
455 struct irt_node
*irt
;
456 struct ecommunity_val eval_tmp
;
458 /* If using "automatic" RT, we only care about the local-admin
460 * This is to facilitate using VNI as the RT for EBGP peering too.
462 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
463 if (!is_import_rt_configured(vpn
))
464 mask_ecom_global_admin(&eval_tmp
, eval
);
466 irt
= lookup_import_rt(bgp
, &eval_tmp
);
468 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
469 /* Already mapped. */
473 irt
= import_rt_new(bgp
, &eval_tmp
);
477 /* Add VNI to the hash list for this RT. */
478 listnode_add(irt
->vnis
, vpn
);
482 * Unmap specified VNI from specified RT. If there are no other
483 * VNIs for this RT, then the RT hash is deleted.
485 static void unmap_vni_from_rt(struct bgp
*bgp
, struct bgpevpn
*vpn
,
486 struct irt_node
*irt
)
488 /* Delete VNI from hash list for this RT. */
489 listnode_delete(irt
->vnis
, vpn
);
490 if (!listnode_head(irt
->vnis
)) {
491 import_rt_free(bgp
, irt
);
496 * Create RT extended community automatically from passed information:
497 * of the form AS:VNI.
498 * NOTE: We use only the lower 16 bits of the AS. This is sufficient as
499 * the need is to get a RT value that will be unique across different
500 * VNIs but the same across routers (in the same AS) for a particular
503 static void form_auto_rt(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
505 struct ecommunity_val eval
;
506 struct ecommunity
*ecomadd
;
508 if (bgp
->advertise_autort_rfc8365
)
509 vni
|= EVPN_AUTORT_VXLAN
;
510 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
512 ecomadd
= ecommunity_new();
513 ecommunity_add_val(ecomadd
, &eval
);
514 listnode_add_sort(rtl
, ecomadd
);
518 * Derive RD and RT for a VNI automatically. Invoked at the time of
521 static void derive_rd_rt_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
523 bgp_evpn_derive_auto_rd(bgp
, vpn
);
524 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
525 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
529 * Convert nexthop (remote VTEP IP) into an IPv6 address.
531 static void evpn_convert_nexthop_to_ipv6(struct attr
*attr
)
533 if (BGP_ATTR_NEXTHOP_AFI_IP6(attr
))
535 ipv4_to_ipv4_mapped_ipv6(&attr
->mp_nexthop_global
, attr
->nexthop
);
536 attr
->mp_nexthop_len
= IPV6_MAX_BYTELEN
;
540 * Add (update) or delete MACIP from zebra.
542 static int bgp_zebra_send_remote_macip(struct bgp
*bgp
, struct bgpevpn
*vpn
,
543 struct prefix_evpn
*p
,
544 struct in_addr remote_vtep_ip
, int add
,
545 uint8_t flags
, uint32_t seq
)
549 char buf1
[ETHER_ADDR_STRLEN
];
550 char buf2
[INET6_ADDRSTRLEN
];
551 char buf3
[INET6_ADDRSTRLEN
];
554 if (!zclient
|| zclient
->sock
< 0)
557 /* Don't try to register if Zebra doesn't know of this instance. */
558 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
564 zclient_create_header(
565 s
, add
? ZEBRA_REMOTE_MACIP_ADD
: ZEBRA_REMOTE_MACIP_DEL
,
567 stream_putl(s
, vpn
->vni
);
568 stream_put(s
, &p
->prefix
.macip_addr
.mac
.octet
, ETH_ALEN
); /* Mac Addr */
569 /* IP address length and IP address, if any. */
570 if (is_evpn_prefix_ipaddr_none(p
))
573 ipa_len
= is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BYTELEN
575 stream_putl(s
, ipa_len
);
576 stream_put(s
, &p
->prefix
.macip_addr
.ip
.ip
.addr
, ipa_len
);
578 stream_put_in_addr(s
, &remote_vtep_ip
);
580 /* TX flags - MAC sticky status and/or gateway mac */
581 /* Also TX the sequence number of the best route. */
583 stream_putc(s
, flags
);
587 stream_putw_at(s
, 0, stream_get_endp(s
));
589 if (bgp_debug_zebra(NULL
))
591 "Tx %s MACIP, VNI %u MAC %s IP %s flags 0x%x seq %u remote VTEP %s",
592 add
? "ADD" : "DEL", vpn
->vni
,
593 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
595 ipaddr2str(&p
->prefix
.macip_addr
.ip
,
596 buf3
, sizeof(buf3
)), flags
, seq
,
597 inet_ntop(AF_INET
, &remote_vtep_ip
, buf2
,
600 return zclient_send_message(zclient
);
604 * Add (update) or delete remote VTEP from zebra.
606 static int bgp_zebra_send_remote_vtep(struct bgp
*bgp
, struct bgpevpn
*vpn
,
607 struct prefix_evpn
*p
, int add
)
612 if (!zclient
|| zclient
->sock
< 0)
615 /* Don't try to register if Zebra doesn't know of this instance. */
616 if (!IS_BGP_INST_KNOWN_TO_ZEBRA(bgp
))
622 zclient_create_header(
623 s
, add
? ZEBRA_REMOTE_VTEP_ADD
: ZEBRA_REMOTE_VTEP_DEL
,
625 stream_putl(s
, vpn
->vni
);
626 if (is_evpn_prefix_ipaddr_v4(p
))
627 stream_put_in_addr(s
, &p
->prefix
.imet_addr
.ip
.ipaddr_v4
);
628 else if (is_evpn_prefix_ipaddr_v6(p
)) {
631 "Bad remote IP when trying to %s remote VTEP for VNI %u",
632 add
? "ADD" : "DEL", vpn
->vni
);
636 stream_putw_at(s
, 0, stream_get_endp(s
));
638 if (bgp_debug_zebra(NULL
))
639 zlog_debug("Tx %s Remote VTEP, VNI %u remote VTEP %s",
640 add
? "ADD" : "DEL", vpn
->vni
,
641 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
643 return zclient_send_message(zclient
);
647 * Build extended community for EVPN ES (type-4) route
649 static void build_evpn_type4_route_extcomm(struct evpnes
*es
,
652 struct ecommunity ecom_encap
;
653 struct ecommunity ecom_es_rt
;
654 struct ecommunity_val eval
;
655 struct ecommunity_val eval_es_rt
;
656 bgp_encap_types tnl_type
;
660 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
661 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
662 encode_encap_extcomm(tnl_type
, &eval
);
664 ecom_encap
.val
= (uint8_t *)eval
.val
;
665 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
668 memset(&mac
, 0, sizeof(struct ethaddr
));
669 memset(&ecom_es_rt
, 0, sizeof(ecom_es_rt
));
670 es_get_system_mac(&es
->esi
, &mac
);
671 encode_es_rt_extcomm(&eval_es_rt
, &mac
);
673 ecom_es_rt
.val
= (uint8_t *)eval_es_rt
.val
;
675 ecommunity_merge(attr
->ecommunity
, &ecom_es_rt
);
677 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
681 * Build extended communities for EVPN prefix route.
683 static void build_evpn_type5_route_extcomm(struct bgp
*bgp_vrf
,
686 struct ecommunity ecom_encap
;
687 struct ecommunity ecom_rmac
;
688 struct ecommunity_val eval
;
689 struct ecommunity_val eval_rmac
;
690 bgp_encap_types tnl_type
;
691 struct listnode
*node
, *nnode
;
692 struct ecommunity
*ecom
;
693 struct list
*vrf_export_rtl
= NULL
;
696 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
697 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
698 encode_encap_extcomm(tnl_type
, &eval
);
700 ecom_encap
.val
= (uint8_t *)eval
.val
;
703 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
705 /* Add the export RTs for L3VNI/VRF */
706 vrf_export_rtl
= bgp_vrf
->vrf_export_rtl
;
707 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
, ecom
))
709 ecommunity_merge(attr
->ecommunity
, ecom
);
711 /* add the router mac extended community */
712 if (!is_zero_mac(&attr
->rmac
)) {
713 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
714 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
716 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
718 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
721 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
725 * Build extended communities for EVPN route.
726 * This function is applicable for type-2 and type-3 routes. The layer-2 RT
727 * and ENCAP extended communities are applicable for all routes.
728 * The default gateway extended community and MAC mobility (sticky) extended
729 * community are added as needed based on passed settings - only for type-2
730 * routes. Likewise, the layer-3 RT and Router MAC extended communities are
731 * added, if present, based on passed settings - only for non-link-local
734 static void build_evpn_route_extcomm(struct bgpevpn
*vpn
, struct attr
*attr
,
737 struct ecommunity ecom_encap
;
738 struct ecommunity ecom_sticky
;
739 struct ecommunity ecom_default_gw
;
740 struct ecommunity ecom_rmac
;
741 struct ecommunity ecom_na
;
742 struct ecommunity_val eval
;
743 struct ecommunity_val eval_sticky
;
744 struct ecommunity_val eval_default_gw
;
745 struct ecommunity_val eval_rmac
;
746 struct ecommunity_val eval_na
;
748 bgp_encap_types tnl_type
;
749 struct listnode
*node
, *nnode
;
750 struct ecommunity
*ecom
;
752 struct list
*vrf_export_rtl
= NULL
;
755 tnl_type
= BGP_ENCAP_TYPE_VXLAN
;
756 memset(&ecom_encap
, 0, sizeof(ecom_encap
));
757 encode_encap_extcomm(tnl_type
, &eval
);
759 ecom_encap
.val
= (uint8_t *)eval
.val
;
762 attr
->ecommunity
= ecommunity_dup(&ecom_encap
);
764 /* Add the export RTs for L2VNI */
765 for (ALL_LIST_ELEMENTS(vpn
->export_rtl
, node
, nnode
, ecom
))
766 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
, ecom
);
768 /* Add the export RTs for L3VNI if told to - caller determines
769 * when this should be done.
772 vrf_export_rtl
= bgpevpn_get_vrf_export_rtl(vpn
);
773 if (vrf_export_rtl
&& !list_isempty(vrf_export_rtl
)) {
774 for (ALL_LIST_ELEMENTS(vrf_export_rtl
, node
, nnode
,
776 attr
->ecommunity
= ecommunity_merge(
777 attr
->ecommunity
, ecom
);
781 /* Add MAC mobility (sticky) if needed. */
784 memset(&ecom_sticky
, 0, sizeof(ecom_sticky
));
785 encode_mac_mobility_extcomm(1, seqnum
, &eval_sticky
);
786 ecom_sticky
.size
= 1;
787 ecom_sticky
.val
= (uint8_t *)eval_sticky
.val
;
789 ecommunity_merge(attr
->ecommunity
, &ecom_sticky
);
792 /* Add RMAC, if told to. */
794 memset(&ecom_rmac
, 0, sizeof(ecom_rmac
));
795 encode_rmac_extcomm(&eval_rmac
, &attr
->rmac
);
797 ecom_rmac
.val
= (uint8_t *)eval_rmac
.val
;
799 ecommunity_merge(attr
->ecommunity
, &ecom_rmac
);
802 /* Add default gateway, if needed. */
803 if (attr
->default_gw
) {
804 memset(&ecom_default_gw
, 0, sizeof(ecom_default_gw
));
805 encode_default_gw_extcomm(&eval_default_gw
);
806 ecom_default_gw
.size
= 1;
807 ecom_default_gw
.val
= (uint8_t *)eval_default_gw
.val
;
809 ecommunity_merge(attr
->ecommunity
, &ecom_default_gw
);
812 if (attr
->router_flag
) {
813 memset(&ecom_na
, 0, sizeof(ecom_na
));
814 encode_na_flag_extcomm(&eval_na
, attr
->router_flag
);
816 ecom_na
.val
= (uint8_t *)eval_na
.val
;
817 attr
->ecommunity
= ecommunity_merge(attr
->ecommunity
,
821 attr
->flag
|= ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
);
825 * Add MAC mobility extended community to attribute.
827 static void add_mac_mobility_to_attr(uint32_t seq_num
, struct attr
*attr
)
829 struct ecommunity ecom_tmp
;
830 struct ecommunity_val eval
;
831 uint8_t *ecom_val_ptr
;
838 encode_mac_mobility_extcomm(0, seq_num
, &eval
);
840 /* Find current MM ecommunity */
843 if (attr
->ecommunity
) {
844 for (i
= 0; i
< attr
->ecommunity
->size
; i
++) {
845 pnt
= attr
->ecommunity
->val
+ (i
* 8);
849 if (type
== ECOMMUNITY_ENCODE_EVPN
851 == ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY
) {
852 ecom_val_ptr
= (uint8_t *)(attr
->ecommunity
->val
859 /* Update the existing MM ecommunity */
861 memcpy(ecom_val_ptr
, eval
.val
, sizeof(char) * ECOMMUNITY_SIZE
);
863 /* Add MM to existing */
865 memset(&ecom_tmp
, 0, sizeof(ecom_tmp
));
867 ecom_tmp
.val
= (uint8_t *)eval
.val
;
869 if (attr
->ecommunity
)
871 ecommunity_merge(attr
->ecommunity
, &ecom_tmp
);
873 attr
->ecommunity
= ecommunity_dup(&ecom_tmp
);
877 /* Install EVPN route into zebra. */
878 static int evpn_zebra_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
879 struct prefix_evpn
*p
,
880 struct in_addr remote_vtep_ip
, uint8_t flags
,
885 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
886 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
889 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 1);
894 /* Uninstall EVPN route from zebra. */
895 static int evpn_zebra_uninstall(struct bgp
*bgp
, struct bgpevpn
*vpn
,
896 struct prefix_evpn
*p
,
897 struct in_addr remote_vtep_ip
)
901 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
902 ret
= bgp_zebra_send_remote_macip(bgp
, vpn
, p
, remote_vtep_ip
,
905 ret
= bgp_zebra_send_remote_vtep(bgp
, vpn
, p
, 0);
911 * Due to MAC mobility, the prior "local" best route has been supplanted
912 * by a "remote" best route. The prior route has to be deleted and withdrawn
915 static void evpn_delete_old_local_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
917 struct bgp_info
*old_local
)
919 struct bgp_node
*global_rn
;
921 afi_t afi
= AFI_L2VPN
;
922 safi_t safi
= SAFI_EVPN
;
924 /* Locate route node in the global EVPN routing table. Note that
925 * this table is a 2-level tree (RD-level + Prefix-level) similar to
928 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
929 (struct prefix
*)&rn
->p
, &vpn
->prd
);
931 /* Delete route entry in the global EVPN table. */
932 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &ri
);
934 /* Schedule for processing - withdraws to peers happen from
938 bgp_process(bgp
, global_rn
, afi
, safi
);
939 bgp_unlock_node(global_rn
);
942 /* Delete route entry in the VNI route table, caller to remove. */
943 bgp_info_delete(rn
, old_local
);
946 static struct in_addr
*es_vtep_new(struct in_addr vtep
)
950 ip
= XCALLOC(MTYPE_BGP_EVPN_ES_VTEP
, sizeof(struct in_addr
));
954 ip
->s_addr
= vtep
.s_addr
;
958 static void es_vtep_free(struct in_addr
*ip
)
960 XFREE(MTYPE_BGP_EVPN_ES_VTEP
, ip
);
963 /* check if VTEP is already part of the list */
964 static int is_vtep_present_in_list(struct list
*list
,
967 struct listnode
*node
= NULL
;
970 for (ALL_LIST_ELEMENTS_RO(list
, node
, tmp
)) {
971 if (tmp
->s_addr
== vtep
.s_addr
)
978 * Best path for ES route was changed,
979 * update the list of VTEPs for this ES
981 static int evpn_es_install_vtep(struct bgp
*bgp
,
983 struct prefix_evpn
*p
,
984 struct in_addr rvtep
)
986 struct in_addr
*vtep_ip
;
988 if (is_vtep_present_in_list(es
->vtep_list
, rvtep
))
992 vtep_ip
= es_vtep_new(rvtep
);
994 listnode_add_sort(es
->vtep_list
, vtep_ip
);
999 * Best path for ES route was changed,
1000 * update the list of VTEPs for this ES
1002 static int evpn_es_uninstall_vtep(struct bgp
*bgp
,
1004 struct prefix_evpn
*p
,
1005 struct in_addr rvtep
)
1007 struct listnode
*node
, *nnode
, *node_to_del
= NULL
;
1008 struct in_addr
*tmp
;
1010 for (ALL_LIST_ELEMENTS(es
->vtep_list
, node
, nnode
, tmp
)) {
1011 if (tmp
->s_addr
== rvtep
.s_addr
) {
1018 list_delete_node(es
->vtep_list
, node_to_del
);
1024 * Calculate the best path for a ES(type-4) route.
1026 static int evpn_es_route_select_install(struct bgp
*bgp
,
1028 struct bgp_node
*rn
)
1031 afi_t afi
= AFI_L2VPN
;
1032 safi_t safi
= SAFI_EVPN
;
1033 struct bgp_info
*old_select
; /* old best */
1034 struct bgp_info
*new_select
; /* new best */
1035 struct bgp_info_pair old_and_new
;
1037 /* Compute the best path. */
1038 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
],
1039 &old_and_new
, afi
, safi
);
1040 old_select
= old_and_new
.old
;
1041 new_select
= old_and_new
.new;
1044 * If the best path hasn't changed - see if something needs to be
1047 if (old_select
&& old_select
== new_select
1048 && old_select
->type
== ZEBRA_ROUTE_BGP
1049 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
1050 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
1051 && !CHECK_FLAG(old_select
->flags
, BGP_INFO_ATTR_CHANGED
)
1052 && !bgp
->addpath_tx_used
[afi
][safi
]) {
1053 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
1054 ret
= evpn_es_install_vtep(bgp
, es
,
1055 (struct prefix_evpn
*)&rn
->p
,
1056 old_select
->attr
->nexthop
);
1058 UNSET_FLAG(old_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
1059 bgp_zebra_clear_route_change_flags(rn
);
1063 /* If the user did a "clear" this flag will be set */
1064 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
1067 * bestpath has changed; update relevant fields and install or uninstall
1068 * into the zebra RIB.
1070 if (old_select
|| new_select
)
1071 bgp_bump_version(rn
);
1074 bgp_info_unset_flag(rn
, old_select
, BGP_INFO_SELECTED
);
1076 bgp_info_set_flag(rn
, new_select
, BGP_INFO_SELECTED
);
1077 bgp_info_unset_flag(rn
, new_select
, BGP_INFO_ATTR_CHANGED
);
1078 UNSET_FLAG(new_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
1081 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
1082 && new_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1083 ret
= evpn_es_install_vtep(bgp
, es
,
1084 (struct prefix_evpn
*)&rn
->p
,
1085 new_select
->attr
->nexthop
);
1087 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
1088 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
)
1089 ret
= evpn_es_uninstall_vtep(
1090 bgp
, es
, (struct prefix_evpn
*)&rn
->p
,
1091 old_select
->attr
->nexthop
);
1094 /* Clear any route change flags. */
1095 bgp_zebra_clear_route_change_flags(rn
);
1097 /* Reap old select bgp_info, if it has been removed */
1098 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_INFO_REMOVED
))
1099 bgp_info_reap(rn
, old_select
);
1105 * Calculate the best path for an EVPN route. Install/update best path in zebra,
1108 static int evpn_route_select_install(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1109 struct bgp_node
*rn
)
1111 struct bgp_info
*old_select
, *new_select
;
1112 struct bgp_info_pair old_and_new
;
1113 struct prefix_evpn
*evp
;
1114 afi_t afi
= AFI_L2VPN
;
1115 safi_t safi
= SAFI_EVPN
;
1119 /* Compute the best path. */
1120 bgp_best_selection(bgp
, rn
, &bgp
->maxpaths
[afi
][safi
], &old_and_new
,
1122 old_select
= old_and_new
.old
;
1123 new_select
= old_and_new
.new;
1125 evp
= (struct prefix_evpn
*)&rn
->p
;
1126 /* If the best path hasn't changed - see if there is still something to
1130 if (old_select
&& old_select
== new_select
1131 && old_select
->type
== ZEBRA_ROUTE_BGP
1132 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
1133 && !CHECK_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
)
1134 && !CHECK_FLAG(old_select
->flags
, BGP_INFO_ATTR_CHANGED
)
1135 && !bgp
->addpath_tx_used
[afi
][safi
]) {
1136 if (bgp_zebra_has_route_changed(rn
, old_select
)) {
1137 if (old_select
->attr
->sticky
)
1138 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1139 if (old_select
->attr
->default_gw
)
1140 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1141 if (is_evpn_prefix_ipaddr_v6(evp
) &&
1142 old_select
->attr
->router_flag
)
1143 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
1145 ret
= evpn_zebra_install(
1146 bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1147 old_select
->attr
->nexthop
, flags
,
1148 mac_mobility_seqnum(old_select
->attr
));
1150 UNSET_FLAG(old_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
1151 bgp_zebra_clear_route_change_flags(rn
);
1155 /* If the user did a "clear" this flag will be set */
1156 UNSET_FLAG(rn
->flags
, BGP_NODE_USER_CLEAR
);
1158 /* bestpath has changed; update relevant fields and install or uninstall
1159 * into the zebra RIB.
1161 if (old_select
|| new_select
)
1162 bgp_bump_version(rn
);
1165 bgp_info_unset_flag(rn
, old_select
, BGP_INFO_SELECTED
);
1167 bgp_info_set_flag(rn
, new_select
, BGP_INFO_SELECTED
);
1168 bgp_info_unset_flag(rn
, new_select
, BGP_INFO_ATTR_CHANGED
);
1169 UNSET_FLAG(new_select
->flags
, BGP_INFO_MULTIPATH_CHG
);
1172 if (new_select
&& new_select
->type
== ZEBRA_ROUTE_BGP
1173 && new_select
->sub_type
== BGP_ROUTE_IMPORTED
) {
1175 if (new_select
->attr
->sticky
)
1176 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
);
1177 if (new_select
->attr
->default_gw
)
1178 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
);
1179 if (is_evpn_prefix_ipaddr_v6(evp
) &&
1180 new_select
->attr
->router_flag
)
1181 SET_FLAG(flags
, ZEBRA_MACIP_TYPE_ROUTER_FLAG
);
1183 ret
= evpn_zebra_install(bgp
, vpn
, (struct prefix_evpn
*)&rn
->p
,
1184 new_select
->attr
->nexthop
, flags
,
1185 mac_mobility_seqnum(new_select
->attr
));
1186 /* If an old best existed and it was a "local" route, the only
1188 * it would be supplanted is due to MAC mobility procedures. So,
1190 * need to do an implicit delete and withdraw that route from
1193 if (old_select
&& old_select
->peer
== bgp
->peer_self
1194 && old_select
->type
== ZEBRA_ROUTE_BGP
1195 && old_select
->sub_type
== BGP_ROUTE_STATIC
)
1196 evpn_delete_old_local_route(bgp
, vpn
, rn
, old_select
);
1198 if (old_select
&& old_select
->type
== ZEBRA_ROUTE_BGP
1199 && old_select
->sub_type
== BGP_ROUTE_IMPORTED
)
1200 ret
= evpn_zebra_uninstall(bgp
, vpn
,
1201 (struct prefix_evpn
*)&rn
->p
,
1202 old_select
->attr
->nexthop
);
1205 /* Clear any route change flags. */
1206 bgp_zebra_clear_route_change_flags(rn
);
1208 /* Reap old select bgp_info, if it has been removed */
1209 if (old_select
&& CHECK_FLAG(old_select
->flags
, BGP_INFO_REMOVED
))
1210 bgp_info_reap(rn
, old_select
);
1216 * Return true if the local ri for this rn is of type gateway mac
1218 static int evpn_route_is_def_gw(struct bgp
*bgp
, struct bgp_node
*rn
)
1220 struct bgp_info
*tmp_ri
= NULL
;
1221 struct bgp_info
*local_ri
= NULL
;
1224 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1225 if (tmp_ri
->peer
== bgp
->peer_self
1226 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1227 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1234 return local_ri
->attr
->default_gw
;
1239 * Return true if the local ri for this rn has sticky set
1241 static int evpn_route_is_sticky(struct bgp
*bgp
, struct bgp_node
*rn
)
1243 struct bgp_info
*tmp_ri
;
1244 struct bgp_info
*local_ri
;
1247 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1248 if (tmp_ri
->peer
== bgp
->peer_self
1249 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1250 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1257 return local_ri
->attr
->sticky
;
1261 * create or update EVPN type4 route entry.
1262 * This could be in the ES table or the global table.
1263 * TODO: handle remote ES (type4) routes as well
1265 static int update_evpn_type4_route_entry(struct bgp
*bgp
,
1267 afi_t afi
, safi_t safi
,
1268 struct bgp_node
*rn
,
1271 struct bgp_info
**ri
,
1274 char buf
[ESI_STR_LEN
];
1275 char buf1
[INET6_ADDRSTRLEN
];
1276 struct bgp_info
*tmp_ri
= NULL
;
1277 struct bgp_info
*local_ri
= NULL
; /* local route entry if any */
1278 struct bgp_info
*remote_ri
= NULL
; /* remote route entry if any */
1279 struct attr
*attr_new
= NULL
;
1280 struct prefix_evpn
*evp
= NULL
;
1284 evp
= (struct prefix_evpn
*)&rn
->p
;
1286 /* locate the local and remote entries if any */
1287 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1288 if (tmp_ri
->peer
== bgp
->peer_self
&&
1289 tmp_ri
->type
== ZEBRA_ROUTE_BGP
&&
1290 tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1292 if (tmp_ri
->type
== ZEBRA_ROUTE_BGP
&&
1293 tmp_ri
->sub_type
== BGP_ROUTE_IMPORTED
&&
1294 CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
))
1298 /* we don't expect to see a remote_ri at this point.
1299 * An ES route has esi + vtep_ip as the key,
1300 * We shouldn't see the same route from any other vtep.
1305 "%u ERROR: local es route for ESI: %s Vtep %s also learnt from remote",
1307 esi_to_str(&evp
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)),
1308 ipaddr2str(&es
->originator_ip
, buf1
, sizeof(buf1
)));
1312 if (!local_ri
&& !add
)
1315 /* create or update the entry */
1318 /* Add or update attribute to hash */
1319 attr_new
= bgp_attr_intern(attr
);
1321 /* Create new route with its attribute. */
1322 tmp_ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
,
1323 0, bgp
->peer_self
, attr_new
, rn
);
1324 SET_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
);
1326 /* add the newly created path to the route-node */
1327 bgp_info_add(rn
, tmp_ri
);
1330 if (attrhash_cmp(tmp_ri
->attr
, attr
)
1331 && !CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1334 /* The attribute has changed.
1335 * Add (or update) attribute to hash. */
1336 attr_new
= bgp_attr_intern(attr
);
1337 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1339 /* Restore route, if needed. */
1340 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1341 bgp_info_restore(rn
, tmp_ri
);
1343 /* Unintern existing, set to new. */
1344 bgp_attr_unintern(&tmp_ri
->attr
);
1345 tmp_ri
->attr
= attr_new
;
1346 tmp_ri
->uptime
= bgp_clock();
1350 /* Return back the route entry. */
1355 /* update evpn es (type-4) route */
1356 static int update_evpn_type4_route(struct bgp
*bgp
,
1358 struct prefix_evpn
*p
)
1361 int route_changed
= 0;
1362 char buf
[ESI_STR_LEN
];
1363 char buf1
[INET6_ADDRSTRLEN
];
1364 afi_t afi
= AFI_L2VPN
;
1365 safi_t safi
= SAFI_EVPN
;
1367 struct attr
*attr_new
= NULL
;
1368 struct bgp_node
*rn
= NULL
;
1369 struct bgp_info
*ri
= NULL
;
1371 memset(&attr
, 0, sizeof(struct attr
));
1373 /* Build path-attribute for this route. */
1374 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1375 attr
.nexthop
= es
->originator_ip
.ipaddr_v4
;
1376 attr
.mp_nexthop_global_in
= es
->originator_ip
.ipaddr_v4
;
1377 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1379 /* Set up extended community. */
1380 build_evpn_type4_route_extcomm(es
, &attr
);
1382 /* First, create (or fetch) route node within the ESI. */
1383 /* NOTE: There is no RD here. */
1384 rn
= bgp_node_get(es
->route_table
, (struct prefix
*)p
);
1386 /* Create or update route entry. */
1387 ret
= update_evpn_type4_route_entry(bgp
, es
, afi
, safi
, rn
,
1391 flog_err(EC_BGP_ES_INVALID
,
1392 "%u ERROR: Failed to updated ES route ESI: %s VTEP %s",
1394 esi_to_str(&p
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)),
1395 ipaddr2str(&es
->originator_ip
, buf1
, sizeof(buf1
)));
1399 attr_new
= ri
->attr
;
1401 /* Perform route selection;
1402 * this is just to set the flags correctly
1403 * as local route in the ES always wins.
1405 evpn_es_route_select_install(bgp
, es
, rn
);
1406 bgp_unlock_node(rn
);
1408 /* If this is a new route or some attribute has changed, export the
1409 * route to the global table. The route will be advertised to peers
1410 * from there. Note that this table is a 2-level tree (RD-level +
1411 * Prefix-level) similar to L3VPN routes.
1413 if (route_changed
) {
1414 struct bgp_info
*global_ri
;
1416 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1417 (struct prefix
*)p
, &es
->prd
);
1418 update_evpn_type4_route_entry(bgp
, es
, afi
, safi
,
1423 /* Schedule for processing and unlock node. */
1424 bgp_process(bgp
, rn
, afi
, safi
);
1425 bgp_unlock_node(rn
);
1428 /* Unintern temporary. */
1429 aspath_unintern(&attr
.aspath
);
1433 static int update_evpn_type5_route_entry(struct bgp
*bgp_def
,
1434 struct bgp
*bgp_vrf
, afi_t afi
,
1435 safi_t safi
, struct bgp_node
*rn
,
1436 struct attr
*attr
, int *route_changed
)
1438 struct attr
*attr_new
= NULL
;
1439 struct bgp_info
*ri
= NULL
;
1440 mpls_label_t label
= MPLS_INVALID_LABEL
;
1441 struct bgp_info
*local_ri
= NULL
;
1442 struct bgp_info
*tmp_ri
= NULL
;
1445 /* locate the local route entry if any */
1446 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1447 if (tmp_ri
->peer
== bgp_def
->peer_self
1448 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1449 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1454 * create a new route entry if one doesnt exist.
1455 * Otherwise see if route attr has changed
1459 /* route has changed as this is the first entry */
1462 /* Add (or update) attribute to hash. */
1463 attr_new
= bgp_attr_intern(attr
);
1465 /* create the route info from attribute */
1466 ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1467 bgp_def
->peer_self
, attr_new
, rn
);
1468 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
1470 /* Type-5 routes advertise the L3-VNI */
1471 bgp_info_extra_get(ri
);
1472 vni2label(bgp_vrf
->l3vni
, &label
);
1473 memcpy(&ri
->extra
->label
, &label
, sizeof(label
));
1474 ri
->extra
->num_labels
= 1;
1476 /* add the route entry to route node*/
1477 bgp_info_add(rn
, ri
);
1481 if (!attrhash_cmp(tmp_ri
->attr
, attr
)) {
1483 /* attribute changed */
1486 /* The attribute has changed. */
1487 /* Add (or update) attribute to hash. */
1488 attr_new
= bgp_attr_intern(attr
);
1489 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1491 /* Restore route, if needed. */
1492 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1493 bgp_info_restore(rn
, tmp_ri
);
1495 /* Unintern existing, set to new. */
1496 bgp_attr_unintern(&tmp_ri
->attr
);
1497 tmp_ri
->attr
= attr_new
;
1498 tmp_ri
->uptime
= bgp_clock();
1504 /* update evpn type-5 route entry */
1505 static int update_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
,
1506 struct attr
*src_attr
)
1508 afi_t afi
= AFI_L2VPN
;
1509 safi_t safi
= SAFI_EVPN
;
1511 struct bgp_node
*rn
= NULL
;
1512 struct bgp
*bgp_def
= NULL
;
1513 int route_changed
= 0;
1515 bgp_def
= bgp_get_default();
1519 /* Build path attribute for this route - use the source attr, if
1520 * present, else treat as locally originated.
1523 bgp_attr_dup(&attr
, src_attr
);
1525 memset(&attr
, 0, sizeof(struct attr
));
1526 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1528 /* Set nexthop to ourselves and fill in the Router MAC. */
1529 attr
.nexthop
= bgp_vrf
->originator_ip
;
1530 attr
.mp_nexthop_global_in
= bgp_vrf
->originator_ip
;
1531 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1532 memcpy(&attr
.rmac
, &bgp_vrf
->rmac
, sizeof(struct ethaddr
));
1534 /* Setup RT and encap extended community */
1535 build_evpn_type5_route_extcomm(bgp_vrf
, &attr
);
1537 /* get the route node in global table */
1538 rn
= bgp_afi_node_get(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1539 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1542 /* create or update the route entry within the route node */
1543 update_evpn_type5_route_entry(bgp_def
, bgp_vrf
, afi
, safi
, rn
, &attr
,
1546 /* schedule for processing and unlock node */
1547 if (route_changed
) {
1548 bgp_process(bgp_def
, rn
, afi
, safi
);
1549 bgp_unlock_node(rn
);
1552 /* uninten temporary */
1554 aspath_unintern(&attr
.aspath
);
1559 * Create or update EVPN route entry. This could be in the VNI route table
1560 * or the global route table.
1562 static int update_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1563 afi_t afi
, safi_t safi
, struct bgp_node
*rn
,
1564 struct attr
*attr
, int add
,
1565 struct bgp_info
**ri
, uint8_t flags
,
1568 struct bgp_info
*tmp_ri
;
1569 struct bgp_info
*local_ri
;
1570 struct attr
*attr_new
;
1571 mpls_label_t label
[BGP_MAX_LABELS
];
1572 uint32_t num_labels
= 1;
1573 int route_change
= 1;
1575 struct prefix_evpn
*evp
;
1578 evp
= (struct prefix_evpn
*)&rn
->p
;
1579 memset(&label
, 0, sizeof(label
));
1581 /* See if this is an update of an existing route, or a new add. */
1583 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1584 if (tmp_ri
->peer
== bgp
->peer_self
1585 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1586 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1590 /* If route doesn't exist already, create a new one, if told to.
1591 * Otherwise act based on whether the attributes of the route have
1594 if (!local_ri
&& !add
)
1597 /* For non-GW MACs, update MAC mobility seq number, if needed. */
1598 if (seq
&& !CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
))
1599 add_mac_mobility_to_attr(seq
, attr
);
1602 /* Add (or update) attribute to hash. */
1603 attr_new
= bgp_attr_intern(attr
);
1605 /* Extract MAC mobility sequence number, if any. */
1606 attr_new
->mm_seqnum
=
1607 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1608 attr_new
->sticky
= sticky
;
1610 /* Create new route with its attribute. */
1611 tmp_ri
= info_make(ZEBRA_ROUTE_BGP
, BGP_ROUTE_STATIC
, 0,
1612 bgp
->peer_self
, attr_new
, rn
);
1613 SET_FLAG(tmp_ri
->flags
, BGP_INFO_VALID
);
1614 bgp_info_extra_get(tmp_ri
);
1616 /* The VNI goes into the 'label' field of the route */
1617 vni2label(vpn
->vni
, &label
[0]);
1619 /* Type-2 routes may carry a second VNI - the L3-VNI.
1620 * Only attach second label if we are advertising two labels for
1623 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1624 && CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
)) {
1627 l3vni
= bgpevpn_get_l3vni(vpn
);
1629 vni2label(l3vni
, &label
[1]);
1634 memcpy(&tmp_ri
->extra
->label
, label
, sizeof(label
));
1635 tmp_ri
->extra
->num_labels
= num_labels
;
1636 bgp_info_add(rn
, tmp_ri
);
1639 if (attrhash_cmp(tmp_ri
->attr
, attr
)
1640 && !CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1644 * The attributes have changed, type-2 routes needs to
1645 * be advertised with right labels.
1647 vni2label(vpn
->vni
, &label
[0]);
1648 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
1649 && CHECK_FLAG(vpn
->flags
,
1650 VNI_FLAG_USE_TWO_LABELS
)) {
1653 l3vni
= bgpevpn_get_l3vni(vpn
);
1655 vni2label(l3vni
, &label
[1]);
1659 memcpy(&tmp_ri
->extra
->label
, label
, sizeof(label
));
1660 tmp_ri
->extra
->num_labels
= num_labels
;
1662 /* The attribute has changed. */
1663 /* Add (or update) attribute to hash. */
1664 attr_new
= bgp_attr_intern(attr
);
1665 bgp_info_set_flag(rn
, tmp_ri
, BGP_INFO_ATTR_CHANGED
);
1667 /* Extract MAC mobility sequence number, if any. */
1668 attr_new
->mm_seqnum
=
1669 bgp_attr_mac_mobility_seqnum(attr_new
, &sticky
);
1670 attr_new
->sticky
= sticky
;
1672 /* Restore route, if needed. */
1673 if (CHECK_FLAG(tmp_ri
->flags
, BGP_INFO_REMOVED
))
1674 bgp_info_restore(rn
, tmp_ri
);
1676 /* Unintern existing, set to new. */
1677 bgp_attr_unintern(&tmp_ri
->attr
);
1678 tmp_ri
->attr
= attr_new
;
1679 tmp_ri
->uptime
= bgp_clock();
1683 /* Return back the route entry. */
1685 return route_change
;
1689 * Create or update EVPN route (of type based on prefix) for specified VNI
1690 * and schedule for processing.
1692 static int update_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1693 struct prefix_evpn
*p
, uint8_t flags
,
1696 struct bgp_node
*rn
;
1698 struct attr
*attr_new
;
1699 int add_l3_ecomm
= 0;
1700 struct bgp_info
*ri
;
1701 afi_t afi
= AFI_L2VPN
;
1702 safi_t safi
= SAFI_EVPN
;
1705 memset(&attr
, 0, sizeof(struct attr
));
1707 /* Build path-attribute for this route. */
1708 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1709 attr
.nexthop
= vpn
->originator_ip
;
1710 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1711 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1712 attr
.sticky
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
) ? 1 : 0;
1713 attr
.default_gw
= CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_GW
) ? 1 : 0;
1714 attr
.router_flag
= CHECK_FLAG(flags
,
1715 ZEBRA_MACIP_TYPE_ROUTER_FLAG
) ? 1 : 0;
1717 /* PMSI is only needed for type-3 routes */
1718 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
)
1719 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
);
1721 /* router mac is only needed for type-2 routes here. */
1722 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
1723 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1724 vni2label(vpn
->vni
, &(attr
.label
));
1726 /* Include L3 VNI related RTs and RMAC for type-2 routes, if they're
1727 * IPv4 or IPv6 global addresses and we're advertising L3VNI with
1730 if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
&&
1731 (is_evpn_prefix_ipaddr_v4(p
) ||
1732 !IN6_IS_ADDR_LINKLOCAL(&p
->prefix
.macip_addr
.ip
.ipaddr_v6
)) &&
1733 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
) &&
1734 bgpevpn_get_l3vni(vpn
))
1737 /* Set up extended community. */
1738 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
1740 /* First, create (or fetch) route node within the VNI. */
1741 /* NOTE: There is no RD here. */
1742 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
1744 /* Create or update route entry. */
1745 route_change
= update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, &attr
,
1746 1, &ri
, flags
, seq
);
1748 attr_new
= ri
->attr
;
1750 /* Perform route selection; this is just to set the flags correctly
1751 * as local route in the VNI always wins.
1753 evpn_route_select_install(bgp
, vpn
, rn
);
1754 bgp_unlock_node(rn
);
1756 /* If this is a new route or some attribute has changed, export the
1757 * route to the global table. The route will be advertised to peers
1758 * from there. Note that this table is a 2-level tree (RD-level +
1759 * Prefix-level) similar to L3VPN routes.
1762 struct bgp_info
*global_ri
;
1764 rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
1765 (struct prefix
*)p
, &vpn
->prd
);
1766 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
, attr_new
, 1,
1767 &global_ri
, flags
, seq
);
1769 /* Schedule for processing and unlock node. */
1770 bgp_process(bgp
, rn
, afi
, safi
);
1771 bgp_unlock_node(rn
);
1774 /* Unintern temporary. */
1775 aspath_unintern(&attr
.aspath
);
1781 * Delete EVPN route entry.
1782 * The entry can be in ESI/VNI table or the global table.
1784 static void delete_evpn_route_entry(struct bgp
*bgp
,
1785 afi_t afi
, safi_t safi
,
1786 struct bgp_node
*rn
,
1787 struct bgp_info
**ri
)
1789 struct bgp_info
*tmp_ri
;
1793 /* Now, find matching route. */
1794 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
)
1795 if (tmp_ri
->peer
== bgp
->peer_self
1796 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1797 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1802 /* Mark route for delete. */
1804 bgp_info_delete(rn
, tmp_ri
);
1809 /* Delete EVPN ES (type-4) route */
1810 static int delete_evpn_type4_route(struct bgp
*bgp
,
1812 struct prefix_evpn
*p
)
1814 afi_t afi
= AFI_L2VPN
;
1815 safi_t safi
= SAFI_EVPN
;
1816 struct bgp_info
*ri
;
1817 struct bgp_node
*rn
= NULL
; /* rn in esi table */
1818 struct bgp_node
*global_rn
= NULL
; /* rn in global table */
1820 /* First, locate the route node within the ESI.
1821 * If it doesn't exist, ther is nothing to do.
1822 * Note: there is no RD here.
1824 rn
= bgp_node_lookup(es
->route_table
, (struct prefix
*)p
);
1828 /* Next, locate route node in the global EVPN routing table.
1829 * Note that this table is a 2-level tree (RD-level + Prefix-level)
1831 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1832 (struct prefix
*)p
, &es
->prd
);
1835 /* Delete route entry in the global EVPN table. */
1836 delete_evpn_route_entry(bgp
, afi
, safi
,
1839 /* Schedule for processing - withdraws to peers happen from
1843 bgp_process(bgp
, global_rn
, afi
, safi
);
1844 bgp_unlock_node(global_rn
);
1848 * Delete route entry in the ESI route table.
1849 * This can just be removed.
1851 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &ri
);
1853 bgp_info_reap(rn
, ri
);
1854 bgp_unlock_node(rn
);
1858 /* Delete EVPN type5 route */
1859 static int delete_evpn_type5_route(struct bgp
*bgp_vrf
, struct prefix_evpn
*evp
)
1861 afi_t afi
= AFI_L2VPN
;
1862 safi_t safi
= SAFI_EVPN
;
1863 struct bgp_node
*rn
= NULL
;
1864 struct bgp_info
*ri
= NULL
;
1865 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
1867 bgp_def
= bgp_get_default();
1871 /* locate the global route entry for this type-5 prefix */
1872 rn
= bgp_afi_node_lookup(bgp_def
->rib
[afi
][safi
], afi
, safi
,
1873 (struct prefix
*)evp
, &bgp_vrf
->vrf_prd
);
1877 delete_evpn_route_entry(bgp_def
, afi
, safi
, rn
, &ri
);
1879 bgp_process(bgp_def
, rn
, afi
, safi
);
1880 bgp_unlock_node(rn
);
1885 * Delete EVPN route (of type based on prefix) for specified VNI and
1886 * schedule for processing.
1888 static int delete_evpn_route(struct bgp
*bgp
, struct bgpevpn
*vpn
,
1889 struct prefix_evpn
*p
)
1891 struct bgp_node
*rn
, *global_rn
;
1892 struct bgp_info
*ri
;
1893 afi_t afi
= AFI_L2VPN
;
1894 safi_t safi
= SAFI_EVPN
;
1896 /* First, locate the route node within the VNI. If it doesn't exist,
1898 * is nothing further to do.
1900 /* NOTE: There is no RD here. */
1901 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
1905 /* Next, locate route node in the global EVPN routing table. Note that
1906 * this table is a 2-level tree (RD-level + Prefix-level) similar to
1909 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
1910 (struct prefix
*)p
, &vpn
->prd
);
1912 /* Delete route entry in the global EVPN table. */
1913 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &ri
);
1915 /* Schedule for processing - withdraws to peers happen from
1919 bgp_process(bgp
, global_rn
, afi
, safi
);
1920 bgp_unlock_node(global_rn
);
1923 /* Delete route entry in the VNI route table. This can just be removed.
1925 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &ri
);
1927 bgp_info_reap(rn
, ri
);
1928 bgp_unlock_node(rn
);
1934 * Update all type-2 (MACIP) local routes for this VNI - these should also
1935 * be scheduled for advertise to peers.
1937 static int update_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
1941 struct bgp_node
*rn
;
1942 struct bgp_info
*ri
, *tmp_ri
;
1944 struct attr
*attr_new
;
1946 int add_l3_ecomm
= 0;
1951 /* Walk this VNI's route table and update local type-2 routes. For any
1952 * routes updated, update corresponding entry in the global table too.
1954 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
1955 rn
= bgp_route_next(rn
)) {
1956 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
1957 struct bgp_node
*rd_rn
;
1958 struct bgp_info
*global_ri
;
1960 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
1963 /* Identify local route. */
1964 for (tmp_ri
= rn
->info
; tmp_ri
; tmp_ri
= tmp_ri
->next
) {
1965 if (tmp_ri
->peer
== bgp
->peer_self
1966 && tmp_ri
->type
== ZEBRA_ROUTE_BGP
1967 && tmp_ri
->sub_type
== BGP_ROUTE_STATIC
)
1975 * Build attribute per local route as the MAC mobility and
1976 * some other values could differ for different routes. The
1977 * attributes will be shared in the hash table.
1979 bgp_attr_default_set(&attr
, BGP_ORIGIN_IGP
);
1980 attr
.nexthop
= vpn
->originator_ip
;
1981 attr
.mp_nexthop_global_in
= vpn
->originator_ip
;
1982 attr
.mp_nexthop_len
= BGP_ATTR_NHLEN_IPV4
;
1983 bgpevpn_get_rmac(vpn
, &attr
.rmac
);
1985 if (evpn_route_is_sticky(bgp
, rn
))
1987 else if (evpn_route_is_def_gw(bgp
, rn
)) {
1988 attr
.default_gw
= 1;
1989 if (is_evpn_prefix_ipaddr_v6(evp
))
1990 attr
.router_flag
= 1;
1993 /* Add L3 VNI RTs and RMAC for non IPv6 link-local if
1994 * using L3 VNI for type-2 routes also.
1996 if ((is_evpn_prefix_ipaddr_v4(evp
) ||
1997 !IN6_IS_ADDR_LINKLOCAL(
1998 &evp
->prefix
.macip_addr
.ip
.ipaddr_v6
)) &&
1999 CHECK_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
) &&
2000 bgpevpn_get_l3vni(vpn
))
2003 /* Set up extended community. */
2004 build_evpn_route_extcomm(vpn
, &attr
, add_l3_ecomm
);
2006 seq
= mac_mobility_seqnum(tmp_ri
->attr
);
2008 /* Update the route entry. */
2009 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rn
,
2010 &attr
, 0, &ri
, 0, seq
);
2012 /* Perform route selection; this is just to set the flags
2013 * correctly as local route in the VNI always wins.
2015 evpn_route_select_install(bgp
, vpn
, rn
);
2017 attr_new
= ri
->attr
;
2019 /* Update route in global routing table. */
2020 rd_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
2021 (struct prefix
*)evp
, &vpn
->prd
);
2023 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, rd_rn
, attr_new
, 0,
2025 mac_mobility_seqnum(attr_new
));
2027 /* Schedule for processing and unlock node. */
2028 bgp_process(bgp
, rd_rn
, afi
, safi
);
2029 bgp_unlock_node(rd_rn
);
2031 /* Unintern temporary. */
2032 aspath_unintern(&attr
.aspath
);
2040 * Delete all type-2 (MACIP) local routes for this VNI - only from the
2041 * global routing table. These are also scheduled for withdraw from peers.
2043 static int delete_global_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2047 struct bgp_node
*rdrn
, *rn
;
2048 struct bgp_table
*table
;
2049 struct bgp_info
*ri
;
2054 rdrn
= bgp_node_lookup(bgp
->rib
[afi
][safi
], (struct prefix
*)&vpn
->prd
);
2055 if (rdrn
&& rdrn
->info
) {
2056 table
= (struct bgp_table
*)rdrn
->info
;
2057 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2058 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2060 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2063 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &ri
);
2065 bgp_process(bgp
, rn
, afi
, safi
);
2069 /* Unlock RD node. */
2071 bgp_unlock_node(rdrn
);
2077 * Delete all type-2 (MACIP) local routes for this VNI - from the global
2078 * table as well as the per-VNI route table.
2080 static int delete_all_type2_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2084 struct bgp_node
*rn
;
2085 struct bgp_info
*ri
;
2090 /* First, walk the global route table for this VNI's type-2 local
2092 * EVPN routes are a 2-level table, first get the RD table.
2094 delete_global_type2_routes(bgp
, vpn
);
2096 /* Next, walk this VNI's route table and delete local type-2 routes. */
2097 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2098 rn
= bgp_route_next(rn
)) {
2099 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2101 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
2104 delete_evpn_route_entry(bgp
, afi
, safi
, rn
, &ri
);
2106 /* Route entry in local table gets deleted immediately. */
2108 bgp_info_reap(rn
, ri
);
2115 * Delete all routes in per ES route-table
2117 static int delete_all_es_routes(struct bgp
*bgp
, struct evpnes
*es
)
2119 struct bgp_node
*rn
;
2120 struct bgp_info
*ri
, *nextri
;
2122 /* Walk this ES's route table and delete all routes. */
2123 for (rn
= bgp_table_top(es
->route_table
); rn
;
2124 rn
= bgp_route_next(rn
)) {
2125 for (ri
= rn
->info
; (ri
!= NULL
) && (nextri
= ri
->next
, 1);
2127 bgp_info_delete(rn
, ri
);
2128 bgp_info_reap(rn
, ri
);
2136 * Delete all routes in the per-VNI route table.
2138 static int delete_all_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2140 struct bgp_node
*rn
;
2141 struct bgp_info
*ri
, *nextri
;
2143 /* Walk this VNI's route table and delete all routes. */
2144 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
2145 rn
= bgp_route_next(rn
)) {
2146 for (ri
= rn
->info
; (ri
!= NULL
) && (nextri
= ri
->next
, 1);
2148 bgp_info_delete(rn
, ri
);
2149 bgp_info_reap(rn
, ri
);
2157 * Update (and advertise) local routes for a VNI. Invoked upon the VNI
2158 * export RT getting modified or change to tunnel IP. Note that these
2159 * situations need the route in the per-VNI table as well as the global
2160 * table to be updated (as attributes change).
2162 static int update_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2165 struct prefix_evpn p
;
2167 /* Update and advertise the type-3 route (only one) followed by the
2168 * locally learnt type-2 routes (MACIP) - for this VNI.
2170 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2171 ret
= update_evpn_route(bgp
, vpn
, &p
, 0, 0);
2175 return update_all_type2_routes(bgp
, vpn
);
2178 /* Delete (and withdraw) local routes for specified ES from global and ES table.
2179 * Also remove all other routes from the per ES table.
2180 * Invoked when ES is deleted.
2182 static int delete_routes_for_es(struct bgp
*bgp
, struct evpnes
*es
)
2185 char buf
[ESI_STR_LEN
];
2186 struct prefix_evpn p
;
2188 /* Delete and withdraw locally learnt ES route */
2189 build_evpn_type4_prefix(&p
, &es
->esi
, es
->originator_ip
.ipaddr_v4
);
2190 ret
= delete_evpn_type4_route(bgp
, es
, &p
);
2192 flog_err(EC_BGP_EVPN_ROUTE_DELETE
,
2193 "%u failed to delete type-4 route for ESI %s",
2194 bgp
->vrf_id
, esi_to_str(&es
->esi
, buf
, sizeof(buf
)));
2197 /* Delete all routes from per ES table */
2198 return delete_all_es_routes(bgp
, es
);
2202 * Delete (and withdraw) local routes for specified VNI from the global
2203 * table and per-VNI table. After this, remove all other routes from
2204 * the per-VNI table. Invoked upon the VNI being deleted or EVPN
2205 * (advertise-all-vni) being disabled.
2207 static int delete_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
2210 struct prefix_evpn p
;
2212 /* Delete and withdraw locally learnt type-2 routes (MACIP)
2213 * followed by type-3 routes (only one) - for this VNI.
2215 ret
= delete_all_type2_routes(bgp
, vpn
);
2219 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2220 ret
= delete_evpn_route(bgp
, vpn
, &p
);
2224 /* Delete all routes from the per-VNI table. */
2225 return delete_all_vni_routes(bgp
, vpn
);
2229 * There is a tunnel endpoint IP address change for this VNI, delete
2230 * prior type-3 route (if needed) and update.
2231 * Note: Route re-advertisement happens elsewhere after other processing
2234 static int handle_tunnel_ip_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2235 struct in_addr originator_ip
)
2237 struct prefix_evpn p
;
2239 /* If VNI is not live, we only need to update the originator ip */
2240 if (!is_vni_live(vpn
)) {
2241 vpn
->originator_ip
= originator_ip
;
2245 /* Update the tunnel-ip hash */
2246 bgp_tip_del(bgp
, &vpn
->originator_ip
);
2247 bgp_tip_add(bgp
, &originator_ip
);
2249 /* filter routes as martian nexthop db has changed */
2250 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
2252 /* Need to withdraw type-3 route as the originator IP is part
2255 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
2256 delete_evpn_route(bgp
, vpn
, &p
);
2258 /* Update the tunnel IP and re-advertise all routes for this VNI. */
2259 vpn
->originator_ip
= originator_ip
;
2263 /* Install EVPN route entry in ES */
2264 static int install_evpn_route_entry_in_es(struct bgp
*bgp
,
2266 struct prefix_evpn
*p
,
2267 struct bgp_info
*parent_ri
)
2270 struct bgp_node
*rn
= NULL
;
2271 struct bgp_info
*ri
= NULL
;
2272 struct attr
*attr_new
= NULL
;
2274 /* Create (or fetch) route within the VNI.
2275 * NOTE: There is no RD here.
2277 rn
= bgp_node_get(es
->route_table
, (struct prefix
*)p
);
2279 /* Check if route entry is already present. */
2280 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2282 (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2286 /* Add (or update) attribute to hash. */
2287 attr_new
= bgp_attr_intern(parent_ri
->attr
);
2289 /* Create new route with its attribute. */
2290 ri
= info_make(parent_ri
->type
, BGP_ROUTE_IMPORTED
, 0,
2291 parent_ri
->peer
, attr_new
, rn
);
2292 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
2293 bgp_info_extra_get(ri
);
2294 ri
->extra
->parent
= parent_ri
;
2295 bgp_info_add(rn
, ri
);
2297 if (attrhash_cmp(ri
->attr
, parent_ri
->attr
)
2298 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
2299 bgp_unlock_node(rn
);
2302 /* The attribute has changed. */
2303 /* Add (or update) attribute to hash. */
2304 attr_new
= bgp_attr_intern(parent_ri
->attr
);
2306 /* Restore route, if needed. */
2307 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
2308 bgp_info_restore(rn
, ri
);
2310 /* Mark if nexthop has changed. */
2311 if (!IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
))
2312 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
2314 /* Unintern existing, set to new. */
2315 bgp_attr_unintern(&ri
->attr
);
2316 ri
->attr
= attr_new
;
2317 ri
->uptime
= bgp_clock();
2320 /* Perform route selection and update zebra, if required. */
2321 ret
= evpn_es_route_select_install(bgp
, es
, rn
);
2326 * Install route entry into the VRF routing table and invoke route selection.
2328 static int install_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
2329 struct prefix_evpn
*evp
,
2330 struct bgp_info
*parent_ri
)
2332 struct bgp_node
*rn
;
2333 struct bgp_info
*ri
;
2335 struct attr
*attr_new
;
2338 struct prefix
*pp
= &p
;
2341 char buf
[PREFIX_STRLEN
];
2342 char buf1
[PREFIX_STRLEN
];
2344 memset(pp
, 0, sizeof(struct prefix
));
2345 ip_prefix_from_evpn_prefix(evp
, pp
);
2347 if (bgp_debug_zebra(NULL
)) {
2349 "installing evpn prefix %s as ip prefix %s in vrf %s",
2350 prefix2str(evp
, buf
, sizeof(buf
)),
2351 prefix2str(pp
, buf1
, sizeof(buf
)),
2352 vrf_id_to_name(bgp_vrf
->vrf_id
));
2355 /* Create (or fetch) route within the VRF. */
2356 /* NOTE: There is no RD here. */
2357 if (is_evpn_prefix_ipaddr_v4(evp
)) {
2359 safi
= SAFI_UNICAST
;
2360 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
2361 } else if (is_evpn_prefix_ipaddr_v6(evp
)) {
2363 safi
= SAFI_UNICAST
;
2364 rn
= bgp_node_get(bgp_vrf
->rib
[afi
][safi
], pp
);
2368 /* EVPN routes currently only support a IPv4 next hop which corresponds
2369 * to the remote VTEP. When importing into a VRF, if it is IPv6 host
2370 * or prefix route, we have to convert the next hop to an IPv4-mapped
2371 * address for the rest of the code to flow through. In the case of IPv4,
2372 * make sure to set the flag for next hop attribute.
2374 bgp_attr_dup(&attr
, parent_ri
->attr
);
2376 evpn_convert_nexthop_to_ipv6(&attr
);
2378 attr
.flag
|= ATTR_FLAG_BIT(BGP_ATTR_NEXT_HOP
);
2380 /* Check if route entry is already present. */
2381 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2383 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2387 /* Add (or update) attribute to hash. */
2388 attr_new
= bgp_attr_intern(&attr
);
2390 /* Create new route with its attribute. */
2391 ri
= info_make(parent_ri
->type
, BGP_ROUTE_IMPORTED
, 0,
2392 parent_ri
->peer
, attr_new
, rn
);
2393 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
2394 bgp_info_extra_get(ri
);
2395 ri
->extra
->parent
= bgp_info_lock(parent_ri
);
2396 bgp_lock_node((struct bgp_node
*)parent_ri
->net
);
2397 if (parent_ri
->extra
) {
2398 memcpy(&ri
->extra
->label
, &parent_ri
->extra
->label
,
2399 sizeof(ri
->extra
->label
));
2400 ri
->extra
->num_labels
= parent_ri
->extra
->num_labels
;
2402 bgp_info_add(rn
, ri
);
2404 if (attrhash_cmp(ri
->attr
, &attr
)
2405 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
2406 bgp_unlock_node(rn
);
2409 /* The attribute has changed. */
2410 /* Add (or update) attribute to hash. */
2411 attr_new
= bgp_attr_intern(&attr
);
2413 /* Restore route, if needed. */
2414 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
2415 bgp_info_restore(rn
, ri
);
2417 /* Mark if nexthop has changed. */
2418 if ((afi
== AFI_IP
&&
2419 !IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
)) ||
2421 !IPV6_ADDR_SAME(&ri
->attr
->mp_nexthop_global
,
2422 &attr_new
->mp_nexthop_global
)))
2423 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
2425 /* Unintern existing, set to new. */
2426 bgp_attr_unintern(&ri
->attr
);
2427 ri
->attr
= attr_new
;
2428 ri
->uptime
= bgp_clock();
2431 /* Perform route selection and update zebra, if required. */
2432 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2438 * Install route entry into the VNI routing table and invoke route selection.
2440 static int install_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2441 struct prefix_evpn
*p
,
2442 struct bgp_info
*parent_ri
)
2444 struct bgp_node
*rn
;
2445 struct bgp_info
*ri
;
2446 struct attr
*attr_new
;
2449 /* Create (or fetch) route within the VNI. */
2450 /* NOTE: There is no RD here. */
2451 rn
= bgp_node_get(vpn
->route_table
, (struct prefix
*)p
);
2453 /* Check if route entry is already present. */
2454 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2456 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2460 /* Add (or update) attribute to hash. */
2461 attr_new
= bgp_attr_intern(parent_ri
->attr
);
2463 /* Create new route with its attribute. */
2464 ri
= info_make(parent_ri
->type
, BGP_ROUTE_IMPORTED
, 0,
2465 parent_ri
->peer
, attr_new
, rn
);
2466 SET_FLAG(ri
->flags
, BGP_INFO_VALID
);
2467 bgp_info_extra_get(ri
);
2468 ri
->extra
->parent
= bgp_info_lock(parent_ri
);
2469 bgp_lock_node((struct bgp_node
*)parent_ri
->net
);
2470 if (parent_ri
->extra
) {
2471 memcpy(&ri
->extra
->label
, &parent_ri
->extra
->label
,
2472 sizeof(ri
->extra
->label
));
2473 ri
->extra
->num_labels
= parent_ri
->extra
->num_labels
;
2475 bgp_info_add(rn
, ri
);
2477 if (attrhash_cmp(ri
->attr
, parent_ri
->attr
)
2478 && !CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
)) {
2479 bgp_unlock_node(rn
);
2482 /* The attribute has changed. */
2483 /* Add (or update) attribute to hash. */
2484 attr_new
= bgp_attr_intern(parent_ri
->attr
);
2486 /* Restore route, if needed. */
2487 if (CHECK_FLAG(ri
->flags
, BGP_INFO_REMOVED
))
2488 bgp_info_restore(rn
, ri
);
2490 /* Mark if nexthop has changed. */
2491 if (!IPV4_ADDR_SAME(&ri
->attr
->nexthop
, &attr_new
->nexthop
))
2492 SET_FLAG(ri
->flags
, BGP_INFO_IGP_CHANGED
);
2494 /* Unintern existing, set to new. */
2495 bgp_attr_unintern(&ri
->attr
);
2496 ri
->attr
= attr_new
;
2497 ri
->uptime
= bgp_clock();
2500 /* Perform route selection and update zebra, if required. */
2501 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2506 /* Uninstall EVPN route entry from ES route table */
2507 static int uninstall_evpn_route_entry_in_es(struct bgp
*bgp
,
2509 struct prefix_evpn
*p
,
2510 struct bgp_info
*parent_ri
)
2513 struct bgp_node
*rn
;
2514 struct bgp_info
*ri
;
2516 if (!es
->route_table
)
2519 /* Locate route within the ESI.
2520 * NOTE: There is no RD here.
2522 rn
= bgp_node_lookup(es
->route_table
, (struct prefix
*)p
);
2526 /* Find matching route entry. */
2527 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2529 (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2535 /* Mark entry for deletion */
2536 bgp_info_delete(rn
, ri
);
2538 /* Perform route selection and update zebra, if required. */
2539 ret
= evpn_es_route_select_install(bgp
, es
, rn
);
2541 /* Unlock route node. */
2542 bgp_unlock_node(rn
);
2548 * Uninstall route entry from the VRF routing table and send message
2549 * to zebra, if appropriate.
2551 static int uninstall_evpn_route_entry_in_vrf(struct bgp
*bgp_vrf
,
2552 struct prefix_evpn
*evp
,
2553 struct bgp_info
*parent_ri
)
2555 struct bgp_node
*rn
;
2556 struct bgp_info
*ri
;
2559 struct prefix
*pp
= &p
;
2562 char buf
[PREFIX_STRLEN
];
2563 char buf1
[PREFIX_STRLEN
];
2565 memset(pp
, 0, sizeof(struct prefix
));
2566 ip_prefix_from_evpn_prefix(evp
, pp
);
2568 if (bgp_debug_zebra(NULL
)) {
2570 "uninstalling evpn prefix %s as ip prefix %s in vrf %s",
2571 prefix2str(evp
, buf
, sizeof(buf
)),
2572 prefix2str(pp
, buf1
, sizeof(buf
)),
2573 vrf_id_to_name(bgp_vrf
->vrf_id
));
2576 /* Locate route within the VRF. */
2577 /* NOTE: There is no RD here. */
2578 if (is_evpn_prefix_ipaddr_v4(evp
)) {
2580 safi
= SAFI_UNICAST
;
2581 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2584 safi
= SAFI_UNICAST
;
2585 rn
= bgp_node_lookup(bgp_vrf
->rib
[afi
][safi
], pp
);
2591 /* Find matching route entry. */
2592 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2594 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2600 /* Mark entry for deletion */
2601 bgp_info_delete(rn
, ri
);
2603 /* Perform route selection and update zebra, if required. */
2604 bgp_process(bgp_vrf
, rn
, afi
, safi
);
2606 /* Unlock route node. */
2607 bgp_unlock_node(rn
);
2613 * Uninstall route entry from the VNI routing table and send message
2614 * to zebra, if appropriate.
2616 static int uninstall_evpn_route_entry(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2617 struct prefix_evpn
*p
,
2618 struct bgp_info
*parent_ri
)
2620 struct bgp_node
*rn
;
2621 struct bgp_info
*ri
;
2624 /* Locate route within the VNI. */
2625 /* NOTE: There is no RD here. */
2626 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)p
);
2630 /* Find matching route entry. */
2631 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
2633 && (struct bgp_info
*)ri
->extra
->parent
== parent_ri
)
2639 /* Mark entry for deletion */
2640 bgp_info_delete(rn
, ri
);
2642 /* Perform route selection and update zebra, if required. */
2643 ret
= evpn_route_select_install(bgp
, vpn
, rn
);
2645 /* Unlock route node. */
2646 bgp_unlock_node(rn
);
2652 * Given a prefix, see if it belongs to ES.
2654 static int is_prefix_matching_for_es(struct prefix_evpn
*p
,
2657 /* if not an ES route return false */
2658 if (p
->prefix
.route_type
!= BGP_EVPN_ES_ROUTE
)
2661 if (memcmp(&p
->prefix
.es_addr
.esi
, &es
->esi
, sizeof(esi_t
)) == 0)
2668 * Given a route entry and a VRF, see if this route entry should be
2669 * imported into the VRF i.e., RTs match.
2671 static int is_route_matching_for_vrf(struct bgp
*bgp_vrf
, struct bgp_info
*ri
)
2673 struct attr
*attr
= ri
->attr
;
2674 struct ecommunity
*ecom
;
2678 /* Route should have valid RT to be even considered. */
2679 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2682 ecom
= attr
->ecommunity
;
2683 if (!ecom
|| !ecom
->size
)
2686 /* For each extended community RT, see if it matches this VNI. If any RT
2687 * matches, we're done.
2689 for (i
= 0; i
< ecom
->size
; i
++) {
2691 uint8_t type
, sub_type
;
2692 struct ecommunity_val
*eval
;
2693 struct ecommunity_val eval_tmp
;
2694 struct vrf_irt_node
*irt
;
2696 /* Only deal with RTs */
2697 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2698 eval
= (struct ecommunity_val
*)(ecom
->val
2699 + (i
* ECOMMUNITY_SIZE
));
2702 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2705 /* See if this RT matches specified VNIs import RTs */
2706 irt
= lookup_vrf_import_rt(eval
);
2708 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2711 /* Also check for non-exact match. In this, we mask out the AS
2713 * only check on the local-admin sub-field. This is to
2715 * VNI as the RT for EBGP peering too.
2718 if (type
== ECOMMUNITY_ENCODE_AS
2719 || type
== ECOMMUNITY_ENCODE_AS4
2720 || type
== ECOMMUNITY_ENCODE_IP
) {
2721 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2722 mask_ecom_global_admin(&eval_tmp
, eval
);
2723 irt
= lookup_vrf_import_rt(&eval_tmp
);
2726 if (is_vrf_present_in_irt_vrfs(irt
->vrfs
, bgp_vrf
))
2734 * Given a route entry and a VNI, see if this route entry should be
2735 * imported into the VNI i.e., RTs match.
2737 static int is_route_matching_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
,
2738 struct bgp_info
*ri
)
2740 struct attr
*attr
= ri
->attr
;
2741 struct ecommunity
*ecom
;
2745 /* Route should have valid RT to be even considered. */
2746 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
2749 ecom
= attr
->ecommunity
;
2750 if (!ecom
|| !ecom
->size
)
2753 /* For each extended community RT, see if it matches this VNI. If any RT
2754 * matches, we're done.
2756 for (i
= 0; i
< ecom
->size
; i
++) {
2758 uint8_t type
, sub_type
;
2759 struct ecommunity_val
*eval
;
2760 struct ecommunity_val eval_tmp
;
2761 struct irt_node
*irt
;
2763 /* Only deal with RTs */
2764 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
2765 eval
= (struct ecommunity_val
*)(ecom
->val
2766 + (i
* ECOMMUNITY_SIZE
));
2769 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
2772 /* See if this RT matches specified VNIs import RTs */
2773 irt
= lookup_import_rt(bgp
, eval
);
2775 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2778 /* Also check for non-exact match. In this, we mask out the AS
2780 * only check on the local-admin sub-field. This is to
2782 * VNI as the RT for EBGP peering too.
2785 if (type
== ECOMMUNITY_ENCODE_AS
2786 || type
== ECOMMUNITY_ENCODE_AS4
2787 || type
== ECOMMUNITY_ENCODE_IP
) {
2788 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
2789 mask_ecom_global_admin(&eval_tmp
, eval
);
2790 irt
= lookup_import_rt(bgp
, &eval_tmp
);
2793 if (is_vni_present_in_irt_vnis(irt
->vnis
, vpn
))
2800 static int install_uninstall_routes_for_es(struct bgp
*bgp
,
2807 char buf
[PREFIX_STRLEN
];
2808 char buf1
[ESI_STR_LEN
];
2809 struct bgp_node
*rd_rn
, *rn
;
2810 struct bgp_table
*table
;
2811 struct bgp_info
*ri
;
2817 * Walk entire global routing table and evaluate routes which could be
2818 * imported into this VRF. Note that we need to loop through all global
2819 * routes to determine which route matches the import rt on vrf
2821 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
2822 rd_rn
= bgp_route_next(rd_rn
)) {
2823 table
= (struct bgp_table
*)(rd_rn
->info
);
2827 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2828 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2830 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2832 * Consider "valid" remote routes applicable for
2835 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2836 && ri
->type
== ZEBRA_ROUTE_BGP
2837 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2840 if (!is_prefix_matching_for_es(evp
, es
))
2844 ret
= install_evpn_route_entry_in_es(
2847 ret
= uninstall_evpn_route_entry_in_es(
2853 "Failed to %s EVPN %s route in ESI %s",
2856 prefix2str(evp
, buf
,
2858 esi_to_str(&es
->esi
, buf1
,
2869 * Install or uninstall mac-ip routes are appropriate for this
2872 static int install_uninstall_routes_for_vrf(struct bgp
*bgp_vrf
, int install
)
2876 struct bgp_node
*rd_rn
, *rn
;
2877 struct bgp_table
*table
;
2878 struct bgp_info
*ri
;
2880 char buf
[PREFIX_STRLEN
];
2881 struct bgp
*bgp_def
= NULL
;
2885 bgp_def
= bgp_get_default();
2889 /* Walk entire global routing table and evaluate routes which could be
2890 * imported into this VRF. Note that we need to loop through all global
2891 * routes to determine which route matches the import rt on vrf
2893 for (rd_rn
= bgp_table_top(bgp_def
->rib
[afi
][safi
]); rd_rn
;
2894 rd_rn
= bgp_route_next(rd_rn
)) {
2895 table
= (struct bgp_table
*)(rd_rn
->info
);
2899 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2900 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2902 /* if not mac-ip route skip this route */
2903 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
2904 || evp
->prefix
.route_type
2905 == BGP_EVPN_IP_PREFIX_ROUTE
))
2908 /* if not a mac+ip route skip this route */
2909 if (!(is_evpn_prefix_ipaddr_v4(evp
)
2910 || is_evpn_prefix_ipaddr_v6(evp
)))
2913 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2914 /* Consider "valid" remote routes applicable for
2917 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2918 && ri
->type
== ZEBRA_ROUTE_BGP
2919 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2922 if (is_route_matching_for_vrf(bgp_vrf
, ri
)) {
2924 ret
= install_evpn_route_entry_in_vrf(
2927 ret
= uninstall_evpn_route_entry_in_vrf(
2933 "Failed to %s EVPN %s route in VRF %s",
2936 prefix2str(evp
, buf
,
2951 * Install or uninstall routes of specified type that are appropriate for this
2954 static int install_uninstall_routes_for_vni(struct bgp
*bgp
,
2955 struct bgpevpn
*vpn
,
2956 bgp_evpn_route_type rtype
,
2961 struct bgp_node
*rd_rn
, *rn
;
2962 struct bgp_table
*table
;
2963 struct bgp_info
*ri
;
2969 /* Walk entire global routing table and evaluate routes which could be
2970 * imported into this VPN. Note that we cannot just look at the routes
2972 * the VNI's RD - remote routes applicable for this VNI could have any
2975 /* EVPN routes are a 2-level table. */
2976 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
2977 rd_rn
= bgp_route_next(rd_rn
)) {
2978 table
= (struct bgp_table
*)(rd_rn
->info
);
2982 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
2983 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
2985 if (evp
->prefix
.route_type
!= rtype
)
2988 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
2989 /* Consider "valid" remote routes applicable for
2991 if (!(CHECK_FLAG(ri
->flags
, BGP_INFO_VALID
)
2992 && ri
->type
== ZEBRA_ROUTE_BGP
2993 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
2996 if (is_route_matching_for_vni(bgp
, vpn
, ri
)) {
2998 ret
= install_evpn_route_entry(
3001 ret
= uninstall_evpn_route_entry(
3007 "%u: Failed to %s EVPN %s route in VNI %u",
3011 rtype
== BGP_EVPN_MAC_IP_ROUTE
3025 /* Install any existing remote ES routes applicable for this ES into its routing
3026 * table. This is invoked when ES comes up.
3028 static int install_routes_for_es(struct bgp
*bgp
, struct evpnes
*es
)
3030 return install_uninstall_routes_for_es(bgp
, es
, 1);
3034 /* Install any existing remote routes applicable for this VRF into VRF RIB. This
3035 * is invoked upon l3vni-add or l3vni import rt change
3037 static int install_routes_for_vrf(struct bgp
*bgp_vrf
)
3039 install_uninstall_routes_for_vrf(bgp_vrf
, 1);
3044 * Install any existing remote routes applicable for this VNI into its
3045 * routing table. This is invoked when a VNI becomes "live" or its Import
3048 static int install_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3052 /* Install type-3 routes followed by type-2 routes - the ones applicable
3055 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
3060 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
3064 /* uninstall routes from l3vni vrf. */
3065 static int uninstall_routes_for_vrf(struct bgp
*bgp_vrf
)
3067 install_uninstall_routes_for_vrf(bgp_vrf
, 0);
3072 * Uninstall any existing remote routes for this VNI. One scenario in which
3073 * this is invoked is upon an import RT change.
3075 static int uninstall_routes_for_vni(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3079 /* Uninstall type-2 routes followed by type-3 routes - the ones
3083 ret
= install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_MAC_IP_ROUTE
,
3088 return install_uninstall_routes_for_vni(bgp
, vpn
, BGP_EVPN_IMET_ROUTE
,
3092 /* Install or unistall route in ES */
3093 static int install_uninstall_route_in_es(struct bgp
*bgp
, struct evpnes
*es
,
3094 afi_t afi
, safi_t safi
,
3095 struct prefix_evpn
*evp
,
3096 struct bgp_info
*ri
,
3100 char buf
[ESI_STR_LEN
];
3103 ret
= install_evpn_route_entry_in_es(bgp
, es
, evp
, ri
);
3105 ret
= uninstall_evpn_route_entry_in_es(bgp
, es
, evp
, ri
);
3110 "%u: Failed to %s EVPN %s route in ESI %s", bgp
->vrf_id
,
3111 install
? "install" : "uninstall", "ES",
3112 esi_to_str(&evp
->prefix
.es_addr
.esi
, buf
, sizeof(buf
)));
3119 * Install or uninstall route in matching VRFs (list).
3121 static int install_uninstall_route_in_vrfs(struct bgp
*bgp_def
, afi_t afi
,
3122 safi_t safi
, struct prefix_evpn
*evp
,
3123 struct bgp_info
*ri
,
3124 struct list
*vrfs
, int install
)
3126 char buf
[PREFIX2STR_BUFFER
];
3127 struct bgp
*bgp_vrf
;
3128 struct listnode
*node
, *nnode
;
3130 /* Only type-2/type-5 routes go into a VRF */
3131 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3132 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
3135 /* if it is type-2 route and not a mac+ip route skip this route */
3136 if ((evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
)
3137 && !(is_evpn_prefix_ipaddr_v4(evp
)
3138 || is_evpn_prefix_ipaddr_v6(evp
)))
3141 for (ALL_LIST_ELEMENTS(vrfs
, node
, nnode
, bgp_vrf
)) {
3145 ret
= install_evpn_route_entry_in_vrf(bgp_vrf
, evp
, ri
);
3147 ret
= uninstall_evpn_route_entry_in_vrf(bgp_vrf
, evp
,
3151 flog_err(EC_BGP_EVPN_FAIL
,
3152 "%u: Failed to %s prefix %s in VRF %s",
3154 install
? "install" : "uninstall",
3155 prefix2str(evp
, buf
, sizeof(buf
)),
3156 vrf_id_to_name(bgp_vrf
->vrf_id
));
3165 * Install or uninstall route in matching VNIs (list).
3167 static int install_uninstall_route_in_vnis(struct bgp
*bgp
, afi_t afi
,
3168 safi_t safi
, struct prefix_evpn
*evp
,
3169 struct bgp_info
*ri
,
3170 struct list
*vnis
, int install
)
3172 struct bgpevpn
*vpn
;
3173 struct listnode
*node
, *nnode
;
3175 for (ALL_LIST_ELEMENTS(vnis
, node
, nnode
, vpn
)) {
3178 if (!is_vni_live(vpn
))
3182 ret
= install_evpn_route_entry(bgp
, vpn
, evp
, ri
);
3184 ret
= uninstall_evpn_route_entry(bgp
, vpn
, evp
, ri
);
3187 flog_err(EC_BGP_EVPN_FAIL
,
3188 "%u: Failed to %s EVPN %s route in VNI %u",
3189 bgp
->vrf_id
, install
? "install" : "uninstall",
3190 evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3202 * Install or uninstall route for appropriate VNIs/ESIs.
3204 static int install_uninstall_evpn_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
3205 struct prefix
*p
, struct bgp_info
*ri
,
3208 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
3209 struct attr
*attr
= ri
->attr
;
3210 struct ecommunity
*ecom
;
3215 /* Only type-2, type-3, type-4 and type-5 are supported currently */
3216 if (!(evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
3217 || evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
3218 || evp
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
3219 || evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
))
3222 /* If we don't have Route Target, nothing much to do. */
3223 if (!(attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_EXT_COMMUNITIES
)))
3226 ecom
= attr
->ecommunity
;
3227 if (!ecom
|| !ecom
->size
)
3230 /* An EVPN route belongs to a VNI or a VRF or an ESI based on the RTs
3231 * attached to the route */
3232 for (i
= 0; i
< ecom
->size
; i
++) {
3234 uint8_t type
, sub_type
;
3235 struct ecommunity_val
*eval
;
3236 struct ecommunity_val eval_tmp
;
3237 struct irt_node
*irt
; /* import rt for l2vni */
3238 struct vrf_irt_node
*vrf_irt
; /* import rt for l3vni */
3241 /* Only deal with RTs */
3242 pnt
= (ecom
->val
+ (i
* ECOMMUNITY_SIZE
));
3243 eval
= (struct ecommunity_val
*)(ecom
->val
3244 + (i
* ECOMMUNITY_SIZE
));
3247 if (sub_type
!= ECOMMUNITY_ROUTE_TARGET
)
3251 * macip routes (type-2) are imported into VNI and VRF tables.
3252 * IMET route is imported into VNI table.
3253 * prefix routes are imported into VRF table.
3255 if (evp
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
||
3256 evp
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
||
3257 evp
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
3259 irt
= lookup_import_rt(bgp
, eval
);
3261 install_uninstall_route_in_vnis(bgp
, afi
, safi
,
3266 vrf_irt
= lookup_vrf_import_rt(eval
);
3268 install_uninstall_route_in_vrfs(bgp
, afi
, safi
,
3273 /* Also check for non-exact match.
3274 * In this, we mask out the AS and
3275 * only check on the local-admin sub-field.
3276 * This is to facilitate using
3277 * VNI as the RT for EBGP peering too.
3281 if (type
== ECOMMUNITY_ENCODE_AS
3282 || type
== ECOMMUNITY_ENCODE_AS4
3283 || type
== ECOMMUNITY_ENCODE_IP
) {
3284 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
3285 mask_ecom_global_admin(&eval_tmp
, eval
);
3286 irt
= lookup_import_rt(bgp
, &eval_tmp
);
3287 vrf_irt
= lookup_vrf_import_rt(&eval_tmp
);
3291 install_uninstall_route_in_vnis(bgp
, afi
, safi
,
3296 install_uninstall_route_in_vrfs(bgp
, afi
, safi
,
3302 /* es route is imported into the es table */
3303 if (evp
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
) {
3305 /* we will match based on the entire esi to avoid
3306 * imoort of an es route for esi2 into esi1
3308 es
= bgp_evpn_lookup_es(bgp
, &evp
->prefix
.es_addr
.esi
);
3309 if (es
&& is_es_local(es
))
3310 install_uninstall_route_in_es(bgp
, es
,
3320 * delete and withdraw all ipv4 and ipv6 routes in the vrf table as type-5
3323 static void delete_withdraw_vrf_routes(struct bgp
*bgp_vrf
)
3325 /* delete all ipv4 routes and withdraw from peers */
3326 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
3327 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
3329 /* delete all ipv6 routes and withdraw from peers */
3330 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
3331 bgp_evpn_withdraw_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
3335 * update and advertise all ipv4 and ipv6 routes in thr vrf table as type-5
3338 static void update_advertise_vrf_routes(struct bgp
*bgp_vrf
)
3340 /* update all ipv4 routes */
3341 if (advertise_type5_routes(bgp_vrf
, AFI_IP
))
3342 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP
, SAFI_UNICAST
);
3344 /* update all ipv6 routes */
3345 if (advertise_type5_routes(bgp_vrf
, AFI_IP6
))
3346 bgp_evpn_advertise_type5_routes(bgp_vrf
, AFI_IP6
, SAFI_UNICAST
);
3350 * update and advertise local routes for a VRF as type-5 routes.
3351 * This is invoked upon RD change for a VRF. Note taht the processing is only
3352 * done in the global route table using the routes which already exist in the
3355 static void update_router_id_vrf(struct bgp
*bgp_vrf
)
3357 /* skip if the RD is configured */
3358 if (is_vrf_rd_configured(bgp_vrf
))
3361 /* derive the RD for the VRF based on new router-id */
3362 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
3364 /* update advertise ipv4|ipv6 routes as type-5 routes */
3365 update_advertise_vrf_routes(bgp_vrf
);
3369 * Delete and withdraw all type-5 routes for the RD corresponding to VRF.
3370 * This is invoked upon VRF RD change. The processing is done only from global
3373 static void withdraw_router_id_vrf(struct bgp
*bgp_vrf
)
3375 /* skip if the RD is configured */
3376 if (is_vrf_rd_configured(bgp_vrf
))
3379 /* delete/withdraw ipv4|ipv6 routes as type-5 routes */
3380 delete_withdraw_vrf_routes(bgp_vrf
);
3384 * Update and advertise local routes for a VNI. Invoked upon router-id
3385 * change. Note that the processing is done only on the global route table
3386 * using routes that already exist in the per-VNI table.
3388 static int update_advertise_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3390 struct prefix_evpn p
;
3391 struct bgp_node
*rn
, *global_rn
;
3392 struct bgp_info
*ri
, *global_ri
;
3394 afi_t afi
= AFI_L2VPN
;
3395 safi_t safi
= SAFI_EVPN
;
3397 /* Locate type-3 route for VNI in the per-VNI table and use its
3398 * attributes to create and advertise the type-3 route for this VNI
3399 * in the global table.
3401 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3402 rn
= bgp_node_lookup(vpn
->route_table
, (struct prefix
*)&p
);
3403 if (!rn
) /* unexpected */
3405 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
3406 if (ri
->peer
== bgp
->peer_self
&& ri
->type
== ZEBRA_ROUTE_BGP
3407 && ri
->sub_type
== BGP_ROUTE_STATIC
)
3409 if (!ri
) /* unexpected */
3413 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
3414 (struct prefix
*)&p
, &vpn
->prd
);
3415 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1, &ri
,
3416 0, mac_mobility_seqnum(attr
));
3418 /* Schedule for processing and unlock node. */
3419 bgp_process(bgp
, global_rn
, afi
, safi
);
3420 bgp_unlock_node(global_rn
);
3422 /* Now, walk this VNI's route table and use the route and its attribute
3423 * to create and schedule route in global table.
3425 for (rn
= bgp_table_top(vpn
->route_table
); rn
;
3426 rn
= bgp_route_next(rn
)) {
3427 struct prefix_evpn
*evp
= (struct prefix_evpn
*)&rn
->p
;
3429 /* Identify MAC-IP local routes. */
3430 if (evp
->prefix
.route_type
!= BGP_EVPN_MAC_IP_ROUTE
)
3433 for (ri
= rn
->info
; ri
; ri
= ri
->next
)
3434 if (ri
->peer
== bgp
->peer_self
3435 && ri
->type
== ZEBRA_ROUTE_BGP
3436 && ri
->sub_type
== BGP_ROUTE_STATIC
)
3441 /* Create route in global routing table using this route entry's
3445 global_rn
= bgp_afi_node_get(bgp
->rib
[afi
][safi
], afi
, safi
,
3446 (struct prefix
*)evp
, &vpn
->prd
);
3448 update_evpn_route_entry(bgp
, vpn
, afi
, safi
, global_rn
, attr
, 1,
3450 mac_mobility_seqnum(attr
));
3452 /* Schedule for processing and unlock node. */
3453 bgp_process(bgp
, global_rn
, afi
, safi
);
3454 bgp_unlock_node(global_rn
);
3461 * Delete (and withdraw) local routes for a VNI - only from the global
3462 * table. Invoked upon router-id change.
3464 static int delete_withdraw_vni_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
3467 struct prefix_evpn p
;
3468 struct bgp_node
*global_rn
;
3469 struct bgp_info
*ri
;
3470 afi_t afi
= AFI_L2VPN
;
3471 safi_t safi
= SAFI_EVPN
;
3473 /* Delete and withdraw locally learnt type-2 routes (MACIP)
3474 * for this VNI - from the global table.
3476 ret
= delete_global_type2_routes(bgp
, vpn
);
3480 /* Remove type-3 route for this VNI from global table. */
3481 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
3482 global_rn
= bgp_afi_node_lookup(bgp
->rib
[afi
][safi
], afi
, safi
,
3483 (struct prefix
*)&p
, &vpn
->prd
);
3485 /* Delete route entry in the global EVPN table. */
3486 delete_evpn_route_entry(bgp
, afi
, safi
, global_rn
, &ri
);
3488 /* Schedule for processing - withdraws to peers happen from
3492 bgp_process(bgp
, global_rn
, afi
, safi
);
3493 bgp_unlock_node(global_rn
);
3500 * Handle router-id change. Update and advertise local routes corresponding
3501 * to this VNI from peers. Note that this is invoked after updating the
3502 * router-id. The routes in the per-VNI table are used to create routes in
3503 * the global table and schedule them.
3505 static void update_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
3507 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3509 /* Skip VNIs with configured RD. */
3510 if (is_rd_configured(vpn
))
3513 bgp_evpn_derive_auto_rd(bgp
, vpn
);
3514 update_advertise_vni_routes(bgp
, vpn
);
3518 * Handle router-id change. Delete and withdraw local routes corresponding
3519 * to this VNI from peers. Note that this is invoked prior to updating
3520 * the router-id and is done only on the global route table, the routes
3521 * are needed in the per-VNI table to re-advertise with new router id.
3523 static void withdraw_router_id_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
3525 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3527 /* Skip VNIs with configured RD. */
3528 if (is_rd_configured(vpn
))
3531 delete_withdraw_vni_routes(bgp
, vpn
);
3535 * Process received EVPN type-2 route (advertise or withdraw).
3537 static int process_type2_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3538 struct attr
*attr
, uint8_t *pfx
, int psize
,
3539 uint32_t addpath_id
)
3541 struct prefix_rd prd
;
3542 struct prefix_evpn p
;
3543 struct bgp_route_evpn evpn
;
3545 uint8_t macaddr_len
;
3546 mpls_label_t label
[BGP_MAX_LABELS
]; /* holds the VNI(s) as in packet */
3547 uint32_t num_labels
= 0;
3551 /* Type-2 route should be either 33, 37 or 49 bytes or an
3552 * additional 3 bytes if there is a second label (VNI):
3553 * RD (8), ESI (10), Eth Tag (4), MAC Addr Len (1),
3554 * MAC Addr (6), IP len (1), IP (0, 4 or 16),
3555 * MPLS Lbl1 (3), MPLS Lbl2 (0 or 3)
3557 if (psize
!= 33 && psize
!= 37 && psize
!= 49 && psize
!= 36
3558 && psize
!= 40 && psize
!= 52) {
3559 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3560 "%u:%s - Rx EVPN Type-2 NLRI with invalid length %d",
3561 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3565 memset(&evpn
, 0, sizeof(evpn
));
3567 /* Make prefix_rd */
3568 prd
.family
= AF_UNSPEC
;
3570 memcpy(&prd
.val
, pfx
, 8);
3573 /* Make EVPN prefix. */
3574 memset(&p
, 0, sizeof(struct prefix_evpn
));
3576 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3577 p
.prefix
.route_type
= BGP_EVPN_MAC_IP_ROUTE
;
3579 /* Copy Ethernet Seg Identifier */
3580 memcpy(&evpn
.eth_s_id
.val
, pfx
, ESI_LEN
);
3583 /* Copy Ethernet Tag */
3584 memcpy(ð_tag
, pfx
, 4);
3585 p
.prefix
.macip_addr
.eth_tag
= ntohl(eth_tag
);
3588 /* Get the MAC Addr len */
3589 macaddr_len
= *pfx
++;
3591 /* Get the MAC Addr */
3592 if (macaddr_len
== (ETH_ALEN
* 8)) {
3593 memcpy(&p
.prefix
.macip_addr
.mac
.octet
, pfx
, ETH_ALEN
);
3597 EC_BGP_EVPN_ROUTE_INVALID
,
3598 "%u:%s - Rx EVPN Type-2 NLRI with unsupported MAC address length %d",
3599 peer
->bgp
->vrf_id
, peer
->host
, macaddr_len
);
3605 ipaddr_len
= *pfx
++;
3606 if (ipaddr_len
!= 0 && ipaddr_len
!= IPV4_MAX_BITLEN
3607 && ipaddr_len
!= IPV6_MAX_BITLEN
) {
3609 EC_BGP_EVPN_ROUTE_INVALID
,
3610 "%u:%s - Rx EVPN Type-2 NLRI with unsupported IP address length %d",
3611 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3616 ipaddr_len
/= 8; /* Convert to bytes. */
3617 p
.prefix
.macip_addr
.ip
.ipa_type
= (ipaddr_len
== IPV4_MAX_BYTELEN
)
3620 memcpy(&p
.prefix
.macip_addr
.ip
.ip
.addr
, pfx
, ipaddr_len
);
3624 /* Get the VNI(s). Stored as bytes here. */
3626 memset(label
, 0, sizeof(label
));
3627 memcpy(&label
[0], pfx
, BGP_LABEL_BYTES
);
3628 pfx
+= BGP_LABEL_BYTES
;
3629 psize
-= (33 + ipaddr_len
);
3630 /* Do we have a second VNI? */
3633 memcpy(&label
[1], pfx
, BGP_LABEL_BYTES
);
3635 * If in future, we are required to access additional fields,
3636 * we MUST increment pfx by BGP_LABEL_BYTES in before reading
3641 /* Process the route. */
3643 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3644 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3645 &prd
, &label
[0], num_labels
, 0, &evpn
);
3647 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3648 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3649 &prd
, &label
[0], num_labels
, &evpn
);
3654 * Process received EVPN type-3 route (advertise or withdraw).
3656 static int process_type3_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3657 struct attr
*attr
, uint8_t *pfx
, int psize
,
3658 uint32_t addpath_id
)
3660 struct prefix_rd prd
;
3661 struct prefix_evpn p
;
3666 /* Type-3 route should be either 17 or 29 bytes: RD (8), Eth Tag (4),
3667 * IP len (1) and IP (4 or 16).
3669 if (psize
!= 17 && psize
!= 29) {
3670 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3671 "%u:%s - Rx EVPN Type-3 NLRI with invalid length %d",
3672 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3676 /* If PMSI is present, log if it is anything other than IR.
3677 * Note: We just simply ignore the values as it is not clear if
3678 * doing anything else is better.
3681 (attr
->flag
& ATTR_FLAG_BIT(BGP_ATTR_PMSI_TUNNEL
))) {
3682 if (attr
->pmsi_tnl_type
!= PMSI_TNLTYPE_INGR_REPL
) {
3684 EC_BGP_EVPN_PMSI_PRESENT
,
3685 "%u:%s - Rx EVPN Type-3 NLRI with unsupported PTA %d",
3686 peer
->bgp
->vrf_id
, peer
->host
,
3687 attr
->pmsi_tnl_type
);
3691 /* Make prefix_rd */
3692 prd
.family
= AF_UNSPEC
;
3694 memcpy(&prd
.val
, pfx
, 8);
3697 /* Make EVPN prefix. */
3698 memset(&p
, 0, sizeof(struct prefix_evpn
));
3700 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3701 p
.prefix
.route_type
= BGP_EVPN_IMET_ROUTE
;
3703 /* Copy Ethernet Tag */
3704 memcpy(ð_tag
, pfx
, 4);
3705 p
.prefix
.imet_addr
.eth_tag
= ntohl(eth_tag
);
3709 ipaddr_len
= *pfx
++;
3710 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
3711 p
.prefix
.imet_addr
.ip
.ipa_type
= IPADDR_V4
;
3712 memcpy(&p
.prefix
.imet_addr
.ip
.ip
.addr
, pfx
, IPV4_MAX_BYTELEN
);
3715 EC_BGP_EVPN_ROUTE_INVALID
,
3716 "%u:%s - Rx EVPN Type-3 NLRI with unsupported IP address length %d",
3717 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3721 /* Process the route. */
3723 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3724 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3725 &prd
, NULL
, 0, 0, NULL
);
3727 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3728 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3729 &prd
, NULL
, 0, NULL
);
3734 * Process received EVPN type-4 route (advertise or withdraw).
3736 static int process_type4_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3737 struct attr
*attr
, uint8_t *pfx
, int psize
,
3738 uint32_t addpath_id
)
3743 struct in_addr vtep_ip
;
3744 struct prefix_rd prd
;
3745 struct prefix_evpn p
;
3747 /* Type-4 route should be either 23 or 35 bytes
3748 * RD (8), ESI (10), ip-len (1), ip (4 or 16)
3750 if (psize
!= 23 && psize
!= 35) {
3751 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3752 "%u:%s - Rx EVPN Type-4 NLRI with invalid length %d",
3753 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3757 /* Make prefix_rd */
3758 prd
.family
= AF_UNSPEC
;
3760 memcpy(&prd
.val
, pfx
, 8);
3764 memcpy(&esi
, pfx
, ESI_BYTES
);
3769 ipaddr_len
= *pfx
++;
3770 if (ipaddr_len
== IPV4_MAX_BITLEN
) {
3771 memcpy(&vtep_ip
, pfx
, IPV4_MAX_BYTELEN
);
3774 EC_BGP_EVPN_ROUTE_INVALID
,
3775 "%u:%s - Rx EVPN Type-4 NLRI with unsupported IP address length %d",
3776 peer
->bgp
->vrf_id
, peer
->host
, ipaddr_len
);
3780 build_evpn_type4_prefix(&p
, &esi
, vtep_ip
);
3781 /* Process the route. */
3783 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3784 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3785 &prd
, NULL
, 0, 0, NULL
);
3787 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3788 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3789 &prd
, NULL
, 0, NULL
);
3796 * Process received EVPN type-5 route (advertise or withdraw).
3798 static int process_type5_route(struct peer
*peer
, afi_t afi
, safi_t safi
,
3799 struct attr
*attr
, uint8_t *pfx
, int psize
,
3800 uint32_t addpath_id
, int withdraw
)
3802 struct prefix_rd prd
;
3803 struct prefix_evpn p
;
3804 struct bgp_route_evpn evpn
;
3807 mpls_label_t label
; /* holds the VNI as in the packet */
3810 /* Type-5 route should be 34 or 58 bytes:
3811 * RD (8), ESI (10), Eth Tag (4), IP len (1), IP (4 or 16),
3812 * GW (4 or 16) and VNI (3).
3813 * Note that the IP and GW should both be IPv4 or both IPv6.
3815 if (psize
!= 34 && psize
!= 58) {
3816 flog_err(EC_BGP_EVPN_ROUTE_INVALID
,
3817 "%u:%s - Rx EVPN Type-5 NLRI with invalid length %d",
3818 peer
->bgp
->vrf_id
, peer
->host
, psize
);
3822 /* Make prefix_rd */
3823 prd
.family
= AF_UNSPEC
;
3825 memcpy(&prd
.val
, pfx
, 8);
3828 /* Make EVPN prefix. */
3829 memset(&p
, 0, sizeof(struct prefix_evpn
));
3831 p
.prefixlen
= EVPN_ROUTE_PREFIXLEN
;
3832 p
.prefix
.route_type
= BGP_EVPN_IP_PREFIX_ROUTE
;
3834 /* Additional information outside of prefix - ESI and GW IP */
3835 memset(&evpn
, 0, sizeof(evpn
));
3838 memcpy(&evpn
.eth_s_id
.val
, pfx
, 10);
3841 /* Fetch Ethernet Tag. */
3842 memcpy(ð_tag
, pfx
, 4);
3843 p
.prefix
.prefix_addr
.eth_tag
= ntohl(eth_tag
);
3846 /* Fetch IP prefix length. */
3848 if (ippfx_len
> IPV6_MAX_BITLEN
) {
3850 EC_BGP_EVPN_ROUTE_INVALID
,
3851 "%u:%s - Rx EVPN Type-5 NLRI with invalid IP Prefix length %d",
3852 peer
->bgp
->vrf_id
, peer
->host
, ippfx_len
);
3855 p
.prefix
.prefix_addr
.ip_prefix_length
= ippfx_len
;
3857 /* Determine IPv4 or IPv6 prefix */
3858 /* Since the address and GW are from the same family, this just becomes
3859 * a simple check on the total size.
3862 SET_IPADDR_V4(&p
.prefix
.prefix_addr
.ip
);
3863 memcpy(&p
.prefix
.prefix_addr
.ip
.ipaddr_v4
, pfx
, 4);
3865 memcpy(&evpn
.gw_ip
.ipv4
, pfx
, 4);
3868 SET_IPADDR_V6(&p
.prefix
.prefix_addr
.ip
);
3869 memcpy(&p
.prefix
.prefix_addr
.ip
.ipaddr_v6
, pfx
, 16);
3871 memcpy(&evpn
.gw_ip
.ipv6
, pfx
, 16);
3875 /* Get the VNI (in MPLS label field). Stored as bytes here. */
3876 memset(&label
, 0, sizeof(label
));
3877 memcpy(&label
, pfx
, BGP_LABEL_BYTES
);
3880 * If in future, we are required to access additional fields,
3881 * we MUST increment pfx by BGP_LABEL_BYTES in before reading the next
3885 /* Process the route. */
3887 ret
= bgp_update(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3888 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3889 &prd
, &label
, 1, 0, &evpn
);
3891 ret
= bgp_withdraw(peer
, (struct prefix
*)&p
, addpath_id
, attr
,
3892 afi
, safi
, ZEBRA_ROUTE_BGP
, BGP_ROUTE_NORMAL
,
3893 &prd
, &label
, 1, &evpn
);
3898 static void evpn_mpattr_encode_type5(struct stream
*s
, struct prefix
*p
,
3899 struct prefix_rd
*prd
, mpls_label_t
*label
,
3900 uint32_t num_labels
, struct attr
*attr
)
3904 struct evpn_addr
*p_evpn_p
;
3906 memset(&temp
, 0, 16);
3907 if (p
->family
!= AF_EVPN
)
3909 p_evpn_p
= &(p
->u
.prefix_evpn
);
3911 /* len denites the total len of IP and GW-IP in the route
3912 IP and GW-IP have to be both ipv4 or ipv6
3914 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3915 len
= 8; /* IP and GWIP are both ipv4 */
3917 len
= 32; /* IP and GWIP are both ipv6 */
3918 /* Prefix contains RD, ESI, EthTag, IP length, IP, GWIP and VNI */
3919 stream_putc(s
, 8 + 10 + 4 + 1 + len
+ 3);
3920 stream_put(s
, prd
->val
, 8);
3922 stream_put(s
, &(attr
->evpn_overlay
.eth_s_id
), 10);
3924 stream_put(s
, &temp
, 10);
3925 stream_putl(s
, p_evpn_p
->prefix_addr
.eth_tag
);
3926 stream_putc(s
, p_evpn_p
->prefix_addr
.ip_prefix_length
);
3927 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3928 stream_put_ipv4(s
, p_evpn_p
->prefix_addr
.ip
.ipaddr_v4
.s_addr
);
3930 stream_put(s
, &p_evpn_p
->prefix_addr
.ip
.ipaddr_v6
, 16);
3932 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3934 attr
->evpn_overlay
.gw_ip
.ipv4
.s_addr
);
3936 stream_put(s
, &(attr
->evpn_overlay
.gw_ip
.ipv6
), 16);
3938 if (IS_IPADDR_V4(&p_evpn_p
->prefix_addr
.ip
))
3939 stream_put_ipv4(s
, 0);
3941 stream_put(s
, &temp
, 16);
3945 stream_put(s
, label
, 3);
3951 * Cleanup specific VNI upon EVPN (advertise-all-vni) being disabled.
3953 static void cleanup_vni_on_disable(struct hash_backet
*backet
, struct bgp
*bgp
)
3955 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3957 /* Remove EVPN routes and schedule for processing. */
3958 delete_routes_for_vni(bgp
, vpn
);
3960 /* Clear "live" flag and see if hash needs to be freed. */
3961 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
3962 if (!is_vni_configured(vpn
))
3963 bgp_evpn_free(bgp
, vpn
);
3967 * Free a VNI entry; iterator function called during cleanup.
3969 static void free_vni_entry(struct hash_backet
*backet
, struct bgp
*bgp
)
3971 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
3973 delete_all_vni_routes(bgp
, vpn
);
3974 bgp_evpn_free(bgp
, vpn
);
3978 * Derive AUTO import RT for BGP VRF - L3VNI
3980 static void evpn_auto_rt_import_add_for_vrf(struct bgp
*bgp_vrf
)
3982 struct bgp
*bgp_def
= NULL
;
3984 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
3985 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
3988 bgp_def
= bgp_get_default();
3991 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
3995 * Delete AUTO import RT from BGP VRF - L3VNI
3997 static void evpn_auto_rt_import_delete_for_vrf(struct bgp
*bgp_vrf
)
3999 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_import_rtl
);
4003 * Derive AUTO export RT for BGP VRF - L3VNI
4005 static void evpn_auto_rt_export_add_for_vrf(struct bgp
*bgp_vrf
)
4007 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4008 form_auto_rt(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
4012 * Delete AUTO export RT from BGP VRF - L3VNI
4014 static void evpn_auto_rt_export_delete_for_vrf(struct bgp
*bgp_vrf
)
4016 evpn_rt_delete_auto(bgp_vrf
, bgp_vrf
->l3vni
, bgp_vrf
->vrf_export_rtl
);
4019 static void bgp_evpn_handle_export_rt_change_for_vrf(struct bgp
*bgp_vrf
)
4021 struct bgp
*bgp_def
= NULL
;
4022 struct listnode
*node
= NULL
;
4023 struct bgpevpn
*vpn
= NULL
;
4025 bgp_def
= bgp_get_default();
4029 /* update all type-5 routes */
4030 update_advertise_vrf_routes(bgp_vrf
);
4032 /* update all type-2 routes */
4033 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
4034 update_routes_for_vni(bgp_def
, vpn
);
4038 * Handle autort change for a given VNI.
4040 static void update_autort_vni(struct hash_backet
*backet
, struct bgp
*bgp
)
4042 struct bgpevpn
*vpn
= backet
->data
;
4044 if (!is_import_rt_configured(vpn
)) {
4045 if (is_vni_live(vpn
))
4046 bgp_evpn_uninstall_routes(bgp
, vpn
);
4047 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
4048 list_delete_all_node(vpn
->import_rtl
);
4049 bgp_evpn_derive_auto_rt_import(bgp
, vpn
);
4050 if (is_vni_live(vpn
))
4051 bgp_evpn_install_routes(bgp
, vpn
);
4053 if (!is_export_rt_configured(vpn
)) {
4054 list_delete_all_node(vpn
->export_rtl
);
4055 bgp_evpn_derive_auto_rt_export(bgp
, vpn
);
4056 if (is_vni_live(vpn
))
4057 bgp_evpn_handle_export_rt_change(bgp
, vpn
);
4065 /* withdraw type-5 route corresponding to ip prefix */
4066 void bgp_evpn_withdraw_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
4067 afi_t afi
, safi_t safi
)
4070 struct prefix_evpn evp
;
4071 char buf
[PREFIX_STRLEN
];
4073 build_type5_prefix_from_ip_prefix(&evp
, p
);
4074 ret
= delete_evpn_type5_route(bgp_vrf
, &evp
);
4077 EC_BGP_EVPN_ROUTE_DELETE
,
4078 "%u failed to delete type-5 route for prefix %s in vrf %s",
4079 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)),
4080 vrf_id_to_name(bgp_vrf
->vrf_id
));
4084 /* withdraw all type-5 routes for an address family */
4085 void bgp_evpn_withdraw_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
, safi_t safi
)
4087 struct bgp_table
*table
= NULL
;
4088 struct bgp_node
*rn
= NULL
;
4089 struct bgp_info
*ri
;
4091 table
= bgp_vrf
->rib
[afi
][safi
];
4092 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4093 /* Only care about "selected" routes - non-imported. */
4094 /* TODO: Support for AddPath for EVPN. */
4095 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
4096 if (CHECK_FLAG(ri
->flags
, BGP_INFO_SELECTED
)
4097 && (!ri
->extra
|| !ri
->extra
->parent
)) {
4098 bgp_evpn_withdraw_type5_route(bgp_vrf
, &rn
->p
,
4107 * Advertise IP prefix as type-5 route. The afi/safi and src_attr passed
4108 * to this function correspond to those of the source IP prefix (best
4109 * path in the case of the attr. In the case of a local prefix (when we
4110 * are advertising local subnets), the src_attr will be NULL.
4112 void bgp_evpn_advertise_type5_route(struct bgp
*bgp_vrf
, struct prefix
*p
,
4113 struct attr
*src_attr
, afi_t afi
,
4117 struct prefix_evpn evp
;
4118 char buf
[PREFIX_STRLEN
];
4120 build_type5_prefix_from_ip_prefix(&evp
, p
);
4121 ret
= update_evpn_type5_route(bgp_vrf
, &evp
, src_attr
);
4123 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
4124 "%u: Failed to create type-5 route for prefix %s",
4125 bgp_vrf
->vrf_id
, prefix2str(p
, buf
, sizeof(buf
)));
4128 /* Inject all prefixes of a particular address-family (currently, IPv4 or
4129 * IPv6 unicast) into EVPN as type-5 routes. This is invoked when the
4130 * advertisement is enabled.
4132 void bgp_evpn_advertise_type5_routes(struct bgp
*bgp_vrf
, afi_t afi
,
4135 struct bgp_table
*table
= NULL
;
4136 struct bgp_node
*rn
= NULL
;
4137 struct bgp_info
*ri
;
4139 table
= bgp_vrf
->rib
[afi
][safi
];
4140 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
4141 /* Need to identify the "selected" route entry to use its
4142 * attribute. Also, we only consider "non-imported" routes.
4143 * TODO: Support for AddPath for EVPN.
4145 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
4146 if (CHECK_FLAG(ri
->flags
, BGP_INFO_SELECTED
)
4147 && (!ri
->extra
|| !ri
->extra
->parent
)) {
4149 /* apply the route-map */
4150 if (bgp_vrf
->adv_cmd_rmap
[afi
][safi
].map
) {
4153 ret
= route_map_apply(
4154 bgp_vrf
->adv_cmd_rmap
[afi
][safi
]
4156 &rn
->p
, RMAP_BGP
, ri
);
4157 if (ret
== RMAP_DENYMATCH
)
4160 bgp_evpn_advertise_type5_route(
4161 bgp_vrf
, &rn
->p
, ri
->attr
, afi
, safi
);
4168 void evpn_rt_delete_auto(struct bgp
*bgp
, vni_t vni
, struct list
*rtl
)
4170 struct listnode
*node
, *nnode
, *node_to_del
;
4171 struct ecommunity
*ecom
, *ecom_auto
;
4172 struct ecommunity_val eval
;
4174 if (bgp
->advertise_autort_rfc8365
)
4175 vni
|= EVPN_AUTORT_VXLAN
;
4176 encode_route_target_as((bgp
->as
& 0xFFFF), vni
, &eval
);
4178 ecom_auto
= ecommunity_new();
4179 ecommunity_add_val(ecom_auto
, &eval
);
4182 for (ALL_LIST_ELEMENTS(rtl
, node
, nnode
, ecom
)) {
4183 if (ecommunity_match(ecom
, ecom_auto
)) {
4184 ecommunity_free(&ecom
);
4190 list_delete_node(rtl
, node_to_del
);
4192 ecommunity_free(&ecom_auto
);
4195 void bgp_evpn_configure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
4196 struct ecommunity
*ecomadd
)
4198 /* uninstall routes from vrf */
4199 uninstall_routes_for_vrf(bgp_vrf
);
4201 /* Cleanup the RT to VRF mapping */
4202 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4204 /* Remove auto generated RT */
4205 evpn_auto_rt_import_delete_for_vrf(bgp_vrf
);
4207 /* Add the newly configured RT to RT list */
4208 listnode_add_sort(bgp_vrf
->vrf_import_rtl
, ecomadd
);
4209 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4211 /* map VRF to its RTs */
4212 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4214 /* install routes matching the new VRF */
4215 install_routes_for_vrf(bgp_vrf
);
4218 void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp
*bgp_vrf
,
4219 struct ecommunity
*ecomdel
)
4221 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
4222 struct ecommunity
*ecom
= NULL
;
4224 /* uninstall routes from vrf */
4225 uninstall_routes_for_vrf(bgp_vrf
);
4227 /* Cleanup the RT to VRF mapping */
4228 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
4230 /* remove the RT from the RT list */
4231 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4232 if (ecommunity_match(ecom
, ecomdel
)) {
4233 ecommunity_free(&ecom
);
4240 list_delete_node(bgp_vrf
->vrf_import_rtl
, node_to_del
);
4242 assert(bgp_vrf
->vrf_import_rtl
);
4243 /* fallback to auto import rt, if this was the last RT */
4244 if (bgp_vrf
->vrf_import_rtl
&& list_isempty(bgp_vrf
->vrf_import_rtl
)) {
4245 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
);
4246 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
4249 /* map VRFs to its RTs */
4250 bgp_evpn_map_vrf_to_its_rts(bgp_vrf
);
4252 /* install routes matching this new RT */
4253 install_routes_for_vrf(bgp_vrf
);
4256 void bgp_evpn_configure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
4257 struct ecommunity
*ecomadd
)
4259 /* remove auto-generated RT */
4260 evpn_auto_rt_export_delete_for_vrf(bgp_vrf
);
4262 /* Add the new RT to the RT list */
4263 listnode_add_sort(bgp_vrf
->vrf_export_rtl
, ecomadd
);
4264 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4266 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
4269 void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp
*bgp_vrf
,
4270 struct ecommunity
*ecomdel
)
4272 struct listnode
*node
= NULL
, *nnode
= NULL
, *node_to_del
= NULL
;
4273 struct ecommunity
*ecom
= NULL
;
4275 /* Remove the RT from the RT list */
4276 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_export_rtl
, node
, nnode
, ecom
)) {
4277 if (ecommunity_match(ecom
, ecomdel
)) {
4278 ecommunity_free(&ecom
);
4285 list_delete_node(bgp_vrf
->vrf_export_rtl
, node_to_del
);
4288 * Temporary assert to make SA happy.
4289 * The ALL_LIST_ELEMENTS macro above has a NULL check
4290 * which means that SA is going to complain about
4291 * the list_isempty call, which doesn't NULL check.
4292 * So until we get this situation cleaned up, here
4295 assert(bgp_vrf
->vrf_export_rtl
);
4297 /* fall back to auto-generated RT if this was the last RT */
4298 if (list_isempty(bgp_vrf
->vrf_export_rtl
)) {
4299 UNSET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
);
4300 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
4303 bgp_evpn_handle_export_rt_change_for_vrf(bgp_vrf
);
4307 * Handle change to BGP router id. This is invoked twice by the change
4308 * handler, first before the router id has been changed and then after
4309 * the router id has been changed. The first invocation will result in
4310 * local routes for all VNIs/VRF being deleted and withdrawn and the next
4311 * will result in the routes being re-advertised.
4313 void bgp_evpn_handle_router_id_update(struct bgp
*bgp
, int withdraw
)
4317 /* delete and withdraw all the type-5 routes
4318 stored in the global table for this vrf
4320 withdraw_router_id_vrf(bgp
);
4322 /* delete all the VNI routes (type-2/type-3) routes for all the
4325 hash_iterate(bgp
->vnihash
,
4326 (void (*)(struct hash_backet
*,
4327 void *))withdraw_router_id_vni
,
4331 /* advertise all routes in the vrf as type-5 routes with the new
4334 update_router_id_vrf(bgp
);
4336 /* advertise all the VNI routes (type-2/type-3) routes with the
4339 hash_iterate(bgp
->vnihash
,
4340 (void (*)(struct hash_backet
*,
4341 void *))update_router_id_vni
,
4347 * Handle change to auto-RT algorithm - update and advertise local routes.
4349 void bgp_evpn_handle_autort_change(struct bgp
*bgp
)
4351 hash_iterate(bgp
->vnihash
,
4352 (void (*)(struct hash_backet
*,
4353 void*))update_autort_vni
,
4358 * Handle change to export RT - update and advertise local routes.
4360 int bgp_evpn_handle_export_rt_change(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4362 return update_routes_for_vni(bgp
, vpn
);
4365 void bgp_evpn_handle_vrf_rd_change(struct bgp
*bgp_vrf
, int withdraw
)
4368 delete_withdraw_vrf_routes(bgp_vrf
);
4370 update_advertise_vrf_routes(bgp_vrf
);
4374 * Handle change to RD. This is invoked twice by the change handler,
4375 * first before the RD has been changed and then after the RD has
4376 * been changed. The first invocation will result in local routes
4377 * of this VNI being deleted and withdrawn and the next will result
4378 * in the routes being re-advertised.
4380 void bgp_evpn_handle_rd_change(struct bgp
*bgp
, struct bgpevpn
*vpn
,
4384 delete_withdraw_vni_routes(bgp
, vpn
);
4386 update_advertise_vni_routes(bgp
, vpn
);
4390 * Install routes for this VNI. Invoked upon change to Import RT.
4392 int bgp_evpn_install_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4394 return install_routes_for_vni(bgp
, vpn
);
4398 * Uninstall all routes installed for this VNI. Invoked upon change
4401 int bgp_evpn_uninstall_routes(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4403 return uninstall_routes_for_vni(bgp
, vpn
);
4407 * TODO: Hardcoded for a maximum of 2 VNIs right now
4409 char *bgp_evpn_label2str(mpls_label_t
*label
, uint32_t num_labels
, char *buf
,
4414 vni1
= label2vni(label
);
4415 if (num_labels
== 2) {
4416 vni2
= label2vni(label
+ 1);
4417 snprintf(buf
, len
, "%u/%u", vni1
, vni2
);
4419 snprintf(buf
, len
, "%u", vni1
);
4424 * Function to convert evpn route to json format.
4425 * NOTE: We don't use prefix2str as the output here is a bit different.
4427 void bgp_evpn_route2json(struct prefix_evpn
*p
, json_object
*json
)
4429 char buf1
[ETHER_ADDR_STRLEN
];
4430 char buf2
[PREFIX2STR_BUFFER
];
4435 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
4436 json_object_int_add(json
, "routeType", p
->prefix
.route_type
);
4437 json_object_int_add(json
, "ethTag",
4438 p
->prefix
.imet_addr
.eth_tag
);
4439 json_object_int_add(json
, "ipLen",
4440 is_evpn_prefix_ipaddr_v4(p
)
4443 json_object_string_add(json
, "ip",
4444 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
4445 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
4446 if (is_evpn_prefix_ipaddr_none(p
)) {
4447 json_object_int_add(json
, "routeType",
4448 p
->prefix
.route_type
);
4449 json_object_int_add(json
, "ethTag",
4450 p
->prefix
.macip_addr
.eth_tag
);
4451 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
4452 json_object_string_add(json
, "mac",
4453 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
4459 family
= is_evpn_prefix_ipaddr_v4(p
) ? AF_INET
4462 json_object_int_add(json
, "routeType",
4463 p
->prefix
.route_type
);
4464 json_object_int_add(json
, "ethTag",
4465 p
->prefix
.macip_addr
.eth_tag
);
4466 json_object_int_add(json
, "macLen", 8 * ETH_ALEN
);
4467 json_object_string_add(json
, "mac",
4468 prefix_mac2str(&p
->prefix
.macip_addr
.mac
,
4471 json_object_int_add(json
, "ipLen",
4472 is_evpn_prefix_ipaddr_v4(p
)
4475 json_object_string_add(
4478 &p
->prefix
.macip_addr
.ip
.ip
.addr
,
4480 PREFIX2STR_BUFFER
));
4483 /* Currently, this is to cater to other AF_ETHERNET code. */
4488 * Function to convert evpn route to string.
4489 * NOTE: We don't use prefix2str as the output here is a bit different.
4491 char *bgp_evpn_route2str(struct prefix_evpn
*p
, char *buf
, int len
)
4493 char buf1
[ETHER_ADDR_STRLEN
];
4494 char buf2
[PREFIX2STR_BUFFER
];
4495 char buf3
[ESI_STR_LEN
];
4497 if (p
->prefix
.route_type
== BGP_EVPN_IMET_ROUTE
) {
4498 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]", p
->prefix
.route_type
,
4499 p
->prefix
.imet_addr
.eth_tag
,
4500 is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BITLEN
4502 inet_ntoa(p
->prefix
.imet_addr
.ip
.ipaddr_v4
));
4503 } else if (p
->prefix
.route_type
== BGP_EVPN_MAC_IP_ROUTE
) {
4504 if (is_evpn_prefix_ipaddr_none(p
))
4505 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]",
4506 p
->prefix
.route_type
,
4507 p
->prefix
.macip_addr
.eth_tag
,
4509 prefix_mac2str(&p
->prefix
.macip_addr
.mac
, buf1
,
4514 family
= is_evpn_prefix_ipaddr_v4(p
) ? AF_INET
4516 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]:[%d]:[%s]",
4517 p
->prefix
.route_type
,
4518 p
->prefix
.macip_addr
.eth_tag
,
4520 prefix_mac2str(&p
->prefix
.macip_addr
.mac
, buf1
,
4522 family
== AF_INET
? IPV4_MAX_BITLEN
4525 &p
->prefix
.macip_addr
.ip
.ip
.addr
,
4527 PREFIX2STR_BUFFER
));
4529 } else if (p
->prefix
.route_type
== BGP_EVPN_IP_PREFIX_ROUTE
) {
4530 snprintf(buf
, len
, "[%d]:[%d]:[%d]:[%s]",
4531 p
->prefix
.route_type
,
4532 p
->prefix
.prefix_addr
.eth_tag
,
4533 p
->prefix
.prefix_addr
.ip_prefix_length
,
4534 is_evpn_prefix_ipaddr_v4(p
)
4535 ? inet_ntoa(p
->prefix
.prefix_addr
.ip
.ipaddr_v4
)
4536 : inet6_ntoa(p
->prefix
.prefix_addr
.ip
.ipaddr_v6
));
4537 } else if (p
->prefix
.route_type
== BGP_EVPN_ES_ROUTE
) {
4538 snprintf(buf
, len
, "[%d]:[%s]:[%d]:[%s]",
4539 p
->prefix
.route_type
,
4540 esi_to_str(&p
->prefix
.es_addr
.esi
, buf3
, sizeof(buf3
)),
4541 is_evpn_prefix_ipaddr_v4(p
) ? IPV4_MAX_BITLEN
4543 inet_ntoa(p
->prefix
.es_addr
.ip
.ipaddr_v4
));
4545 /* For EVPN route types not supported yet. */
4546 snprintf(buf
, len
, "(unsupported route type %d)",
4547 p
->prefix
.route_type
);
4554 * Encode EVPN prefix in Update (MP_REACH)
4556 void bgp_evpn_encode_prefix(struct stream
*s
, struct prefix
*p
,
4557 struct prefix_rd
*prd
, mpls_label_t
*label
,
4558 uint32_t num_labels
, struct attr
*attr
,
4559 int addpath_encode
, uint32_t addpath_tx_id
)
4561 struct prefix_evpn
*evp
= (struct prefix_evpn
*)p
;
4562 int len
, ipa_len
= 0;
4565 stream_putl(s
, addpath_tx_id
);
4568 stream_putc(s
, evp
->prefix
.route_type
);
4570 switch (evp
->prefix
.route_type
) {
4571 case BGP_EVPN_MAC_IP_ROUTE
:
4572 if (is_evpn_prefix_ipaddr_v4(evp
))
4573 ipa_len
= IPV4_MAX_BYTELEN
;
4574 else if (is_evpn_prefix_ipaddr_v6(evp
))
4575 ipa_len
= IPV6_MAX_BYTELEN
;
4576 /* RD, ESI, EthTag, MAC+len, IP len, [IP], 1 VNI */
4577 len
= 8 + 10 + 4 + 1 + 6 + 1 + ipa_len
+ 3;
4578 if (ipa_len
&& num_labels
> 1) /* There are 2 VNIs */
4580 stream_putc(s
, len
);
4581 stream_put(s
, prd
->val
, 8); /* RD */
4583 stream_put(s
, &attr
->evpn_overlay
.eth_s_id
, ESI_LEN
);
4585 stream_put(s
, 0, 10);
4586 stream_putl(s
, evp
->prefix
.macip_addr
.eth_tag
); /* Ethernet Tag ID */
4587 stream_putc(s
, 8 * ETH_ALEN
); /* Mac Addr Len - bits */
4588 stream_put(s
, evp
->prefix
.macip_addr
.mac
.octet
, 6); /* Mac Addr */
4589 stream_putc(s
, 8 * ipa_len
); /* IP address Length */
4590 if (ipa_len
) /* IP */
4591 stream_put(s
, &evp
->prefix
.macip_addr
.ip
.ip
.addr
,
4593 /* 1st label is the L2 VNI */
4594 stream_put(s
, label
, BGP_LABEL_BYTES
);
4595 /* Include 2nd label (L3 VNI) if advertising MAC+IP */
4596 if (ipa_len
&& num_labels
> 1)
4597 stream_put(s
, label
+ 1, BGP_LABEL_BYTES
);
4600 case BGP_EVPN_IMET_ROUTE
:
4601 stream_putc(s
, 17); // TODO: length - assumes IPv4 address
4602 stream_put(s
, prd
->val
, 8); /* RD */
4603 stream_putl(s
, evp
->prefix
.imet_addr
.eth_tag
); /* Ethernet Tag ID */
4604 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
4605 /* Originating Router's IP Addr */
4606 stream_put_in_addr(s
, &evp
->prefix
.imet_addr
.ip
.ipaddr_v4
);
4609 case BGP_EVPN_ES_ROUTE
:
4610 stream_putc(s
, 23); /* TODO: length: assumes ipv4 VTEP */
4611 stream_put(s
, prd
->val
, 8); /* RD */
4612 stream_put(s
, evp
->prefix
.es_addr
.esi
.val
, 10); /* ESI */
4613 stream_putc(s
, IPV4_MAX_BITLEN
); /* IP address Length - bits */
4615 stream_put_in_addr(s
, &evp
->prefix
.es_addr
.ip
.ipaddr_v4
);
4618 case BGP_EVPN_IP_PREFIX_ROUTE
:
4619 /* TODO: AddPath support. */
4620 evpn_mpattr_encode_type5(s
, p
, prd
, label
, num_labels
, attr
);
4628 int bgp_nlri_parse_evpn(struct peer
*peer
, struct attr
*attr
,
4629 struct bgp_nlri
*packet
, int withdraw
)
4635 uint32_t addpath_id
;
4636 int addpath_encoded
;
4641 /* Start processing the NLRI - there may be multiple in the MP_REACH */
4643 lim
= pnt
+ packet
->length
;
4645 safi
= packet
->safi
;
4649 (CHECK_FLAG(peer
->af_cap
[afi
][safi
], PEER_CAP_ADDPATH_AF_RX_ADV
)
4650 && CHECK_FLAG(peer
->af_cap
[afi
][safi
],
4651 PEER_CAP_ADDPATH_AF_TX_RCV
));
4653 for (; pnt
< lim
; pnt
+= psize
) {
4654 /* Clear prefix structure. */
4655 memset(&p
, 0, sizeof(struct prefix
));
4657 /* Deal with path-id if AddPath is supported. */
4658 if (addpath_encoded
) {
4659 /* When packet overflow occurs return immediately. */
4660 if (pnt
+ BGP_ADDPATH_ID_LEN
> lim
)
4663 addpath_id
= ntohl(*((uint32_t *)pnt
));
4664 pnt
+= BGP_ADDPATH_ID_LEN
;
4667 /* All EVPN NLRI types start with type and length. */
4674 /* When packet overflow occur return immediately. */
4675 if (pnt
+ psize
> lim
)
4679 case BGP_EVPN_MAC_IP_ROUTE
:
4680 if (process_type2_route(peer
, afi
, safi
,
4681 withdraw
? NULL
: attr
, pnt
,
4682 psize
, addpath_id
)) {
4685 "%u:%s - Error in processing EVPN type-2 NLRI size %d",
4686 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4691 case BGP_EVPN_IMET_ROUTE
:
4692 if (process_type3_route(peer
, afi
, safi
,
4693 withdraw
? NULL
: attr
, pnt
,
4694 psize
, addpath_id
)) {
4697 "%u:%s - Error in processing EVPN type-3 NLRI size %d",
4698 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4703 case BGP_EVPN_ES_ROUTE
:
4704 if (process_type4_route(peer
, afi
, safi
,
4705 withdraw
? NULL
: attr
, pnt
,
4706 psize
, addpath_id
)) {
4709 "%u:%s - Error in processing EVPN type-4 NLRI size %d",
4710 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4715 case BGP_EVPN_IP_PREFIX_ROUTE
:
4716 if (process_type5_route(peer
, afi
, safi
, attr
, pnt
,
4717 psize
, addpath_id
, withdraw
)) {
4720 "%u:%s - Error in processing EVPN type-5 NLRI size %d",
4721 peer
->bgp
->vrf_id
, peer
->host
, psize
);
4731 /* Packet length consistency check. */
4739 * Map the RTs (configured or automatically derived) of a VRF to the VRF.
4740 * The mapping will be used during route processing.
4741 * bgp_def: default bgp instance
4742 * bgp_vrf: specific bgp vrf instance on which RT is configured
4744 void bgp_evpn_map_vrf_to_its_rts(struct bgp
*bgp_vrf
)
4747 struct ecommunity_val
*eval
= NULL
;
4748 struct listnode
*node
= NULL
, *nnode
= NULL
;
4749 struct ecommunity
*ecom
= NULL
;
4751 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4752 for (i
= 0; i
< ecom
->size
; i
++) {
4753 eval
= (struct ecommunity_val
*)(ecom
->val
4755 * ECOMMUNITY_SIZE
));
4756 map_vrf_to_rt(bgp_vrf
, eval
);
4762 * Unmap the RTs (configured or automatically derived) of a VRF from the VRF.
4764 void bgp_evpn_unmap_vrf_from_its_rts(struct bgp
*bgp_vrf
)
4767 struct ecommunity_val
*eval
;
4768 struct listnode
*node
, *nnode
;
4769 struct ecommunity
*ecom
;
4771 for (ALL_LIST_ELEMENTS(bgp_vrf
->vrf_import_rtl
, node
, nnode
, ecom
)) {
4772 for (i
= 0; i
< ecom
->size
; i
++) {
4773 struct vrf_irt_node
*irt
;
4774 struct ecommunity_val eval_tmp
;
4776 eval
= (struct ecommunity_val
*)(ecom
->val
4778 * ECOMMUNITY_SIZE
));
4779 /* If using "automatic" RT, we only care about the
4780 * local-admin sub-field.
4781 * This is to facilitate using VNI as the RT for EBGP
4784 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
4785 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
,
4786 BGP_VRF_IMPORT_RT_CFGD
))
4787 mask_ecom_global_admin(&eval_tmp
, eval
);
4789 irt
= lookup_vrf_import_rt(&eval_tmp
);
4791 unmap_vrf_from_rt(bgp_vrf
, irt
);
4798 * Map the RTs (configured or automatically derived) of a VNI to the VNI.
4799 * The mapping will be used during route processing.
4801 void bgp_evpn_map_vni_to_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4804 struct ecommunity_val
*eval
;
4805 struct listnode
*node
, *nnode
;
4806 struct ecommunity
*ecom
;
4808 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
4809 for (i
= 0; i
< ecom
->size
; i
++) {
4810 eval
= (struct ecommunity_val
*)(ecom
->val
4812 * ECOMMUNITY_SIZE
));
4813 map_vni_to_rt(bgp
, vpn
, eval
);
4819 * Unmap the RTs (configured or automatically derived) of a VNI from the VNI.
4821 void bgp_evpn_unmap_vni_from_its_rts(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4824 struct ecommunity_val
*eval
;
4825 struct listnode
*node
, *nnode
;
4826 struct ecommunity
*ecom
;
4828 for (ALL_LIST_ELEMENTS(vpn
->import_rtl
, node
, nnode
, ecom
)) {
4829 for (i
= 0; i
< ecom
->size
; i
++) {
4830 struct irt_node
*irt
;
4831 struct ecommunity_val eval_tmp
;
4833 eval
= (struct ecommunity_val
*)(ecom
->val
4835 * ECOMMUNITY_SIZE
));
4836 /* If using "automatic" RT, we only care about the
4837 * local-admin sub-field.
4838 * This is to facilitate using VNI as the RT for EBGP
4841 memcpy(&eval_tmp
, eval
, ECOMMUNITY_SIZE
);
4842 if (!is_import_rt_configured(vpn
))
4843 mask_ecom_global_admin(&eval_tmp
, eval
);
4845 irt
= lookup_import_rt(bgp
, &eval_tmp
);
4847 unmap_vni_from_rt(bgp
, vpn
, irt
);
4853 * Derive Import RT automatically for VNI and map VNI to RT.
4854 * The mapping will be used during route processing.
4856 void bgp_evpn_derive_auto_rt_import(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4858 form_auto_rt(bgp
, vpn
->vni
, vpn
->import_rtl
);
4859 UNSET_FLAG(vpn
->flags
, VNI_FLAG_IMPRT_CFGD
);
4862 bgp_evpn_map_vni_to_its_rts(bgp
, vpn
);
4866 * Derive Export RT automatically for VNI.
4868 void bgp_evpn_derive_auto_rt_export(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4870 form_auto_rt(bgp
, vpn
->vni
, vpn
->export_rtl
);
4871 UNSET_FLAG(vpn
->flags
, VNI_FLAG_EXPRT_CFGD
);
4875 * Derive RD automatically for VNI using passed information - it
4876 * is of the form RouterId:unique-id-for-vni.
4878 void bgp_evpn_derive_auto_rd_for_vrf(struct bgp
*bgp
)
4880 form_auto_rd(bgp
->router_id
, bgp
->vrf_rd_id
, &bgp
->vrf_prd
);
4884 * Derive RD automatically for VNI using passed information - it
4885 * is of the form RouterId:unique-id-for-vni.
4887 void bgp_evpn_derive_auto_rd(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4891 vpn
->prd
.family
= AF_UNSPEC
;
4892 vpn
->prd
.prefixlen
= 64;
4893 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), vpn
->rd_id
);
4894 (void)str2prefix_rd(buf
, &vpn
->prd
);
4895 UNSET_FLAG(vpn
->flags
, VNI_FLAG_RD_CFGD
);
4901 bool bgp_evpn_lookup_l3vni_l2vni_table(vni_t vni
)
4903 struct list
*inst
= bm
->bgp
;
4904 struct listnode
*node
;
4905 struct bgp
*bgp_vrf
;
4907 for (ALL_LIST_ELEMENTS_RO(inst
, node
, bgp_vrf
)) {
4908 if (bgp_vrf
->l3vni
== vni
)
4918 struct bgpevpn
*bgp_evpn_lookup_vni(struct bgp
*bgp
, vni_t vni
)
4920 struct bgpevpn
*vpn
;
4923 memset(&tmp
, 0, sizeof(struct bgpevpn
));
4925 vpn
= hash_lookup(bgp
->vnihash
, &tmp
);
4930 * Create a new vpn - invoked upon configuration or zebra notification.
4932 struct bgpevpn
*bgp_evpn_new(struct bgp
*bgp
, vni_t vni
,
4933 struct in_addr originator_ip
,
4934 vrf_id_t tenant_vrf_id
)
4936 struct bgpevpn
*vpn
;
4941 vpn
= XCALLOC(MTYPE_BGP_EVPN
, sizeof(struct bgpevpn
));
4945 /* Set values - RD and RT set to defaults. */
4947 vpn
->originator_ip
= originator_ip
;
4948 vpn
->tenant_vrf_id
= tenant_vrf_id
;
4950 /* Initialize route-target import and export lists */
4951 vpn
->import_rtl
= list_new();
4952 vpn
->import_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
4953 vpn
->import_rtl
->del
= evpn_xxport_delete_ecomm
;
4954 vpn
->export_rtl
= list_new();
4955 vpn
->export_rtl
->cmp
= (int (*)(void *, void *))evpn_route_target_cmp
;
4956 vpn
->export_rtl
->del
= evpn_xxport_delete_ecomm
;
4957 bf_assign_index(bm
->rd_idspace
, vpn
->rd_id
);
4958 derive_rd_rt_for_vni(bgp
, vpn
);
4960 /* Initialize EVPN route table. */
4961 vpn
->route_table
= bgp_table_init(bgp
, AFI_L2VPN
, SAFI_EVPN
);
4964 if (!hash_get(bgp
->vnihash
, vpn
, hash_alloc_intern
)) {
4965 XFREE(MTYPE_BGP_EVPN
, vpn
);
4969 /* add to l2vni list on corresponding vrf */
4970 bgpevpn_link_to_l3vni(vpn
);
4972 QOBJ_REG(vpn
, bgpevpn
);
4977 * Free a given VPN - called in multiple scenarios such as zebra
4978 * notification, configuration being deleted, advertise-all-vni disabled etc.
4979 * This just frees appropriate memory, caller should have taken other
4982 void bgp_evpn_free(struct bgp
*bgp
, struct bgpevpn
*vpn
)
4984 bgpevpn_unlink_from_l3vni(vpn
);
4985 bgp_table_unlock(vpn
->route_table
);
4986 bgp_evpn_unmap_vni_from_its_rts(bgp
, vpn
);
4987 list_delete_and_null(&vpn
->import_rtl
);
4988 list_delete_and_null(&vpn
->export_rtl
);
4989 bf_release_index(bm
->rd_idspace
, vpn
->rd_id
);
4990 hash_release(bgp
->vnihash
, vpn
);
4992 XFREE(MTYPE_BGP_EVPN
, vpn
);
4998 struct evpnes
*bgp_evpn_lookup_es(struct bgp
*bgp
, esi_t
*esi
)
5003 memset(&tmp
, 0, sizeof(struct evpnes
));
5004 memcpy(&tmp
.esi
, esi
, sizeof(esi_t
));
5005 es
= hash_lookup(bgp
->esihash
, &tmp
);
5010 * Create a new local es - invoked upon zebra notification.
5012 struct evpnes
*bgp_evpn_es_new(struct bgp
*bgp
,
5014 struct ipaddr
*originator_ip
)
5022 es
= XCALLOC(MTYPE_BGP_EVPN_ES
, sizeof(struct evpnes
));
5026 /* set the ESI and originator_ip */
5027 memcpy(&es
->esi
, esi
, sizeof(esi_t
));
5028 memcpy(&es
->originator_ip
, originator_ip
, sizeof(struct ipaddr
));
5030 /* Initialise the VTEP list */
5031 es
->vtep_list
= list_new();
5032 es
->vtep_list
->cmp
= (int (*)(void *, void *))evpn_vtep_ip_cmp
;
5034 /* auto derive RD for this es */
5035 bf_assign_index(bm
->rd_idspace
, es
->rd_id
);
5036 es
->prd
.family
= AF_UNSPEC
;
5037 es
->prd
.prefixlen
= 64;
5038 sprintf(buf
, "%s:%hu", inet_ntoa(bgp
->router_id
), es
->rd_id
);
5039 (void)str2prefix_rd(buf
, &es
->prd
);
5041 /* Initialize the ES route table */
5042 es
->route_table
= bgp_table_init(bgp
, AFI_L2VPN
, SAFI_EVPN
);
5045 if (!hash_get(bgp
->esihash
, es
, hash_alloc_intern
)) {
5046 XFREE(MTYPE_BGP_EVPN_ES
, es
);
5050 QOBJ_REG(es
, evpnes
);
5056 * This just frees appropriate memory, caller should have taken other
5059 void bgp_evpn_es_free(struct bgp
*bgp
, struct evpnes
*es
)
5061 list_delete_and_null(&es
->vtep_list
);
5062 bgp_table_unlock(es
->route_table
);
5063 bf_release_index(bm
->rd_idspace
, es
->rd_id
);
5064 hash_release(bgp
->esihash
, es
);
5066 XFREE(MTYPE_BGP_EVPN_ES
, es
);
5070 * Import evpn route from global table to VNI/VRF/ESI.
5072 int bgp_evpn_import_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5073 struct prefix
*p
, struct bgp_info
*ri
)
5075 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, ri
, 1);
5079 * Unimport evpn route from VNI/VRF/ESI.
5081 int bgp_evpn_unimport_route(struct bgp
*bgp
, afi_t afi
, safi_t safi
,
5082 struct prefix
*p
, struct bgp_info
*ri
)
5084 return install_uninstall_evpn_route(bgp
, afi
, safi
, p
, ri
, 0);
5087 /* filter routes which have martian next hops */
5088 int bgp_filter_evpn_routes_upon_martian_nh_change(struct bgp
*bgp
)
5092 struct bgp_node
*rd_rn
, *rn
;
5093 struct bgp_table
*table
;
5094 struct bgp_info
*ri
;
5099 /* Walk entire global routing table and evaluate routes which could be
5100 * imported into this VPN. Note that we cannot just look at the routes
5101 * for the VNI's RD -
5102 * remote routes applicable for this VNI could have any RD.
5104 /* EVPN routes are a 2-level table. */
5105 for (rd_rn
= bgp_table_top(bgp
->rib
[afi
][safi
]); rd_rn
;
5106 rd_rn
= bgp_route_next(rd_rn
)) {
5107 table
= (struct bgp_table
*)(rd_rn
->info
);
5111 for (rn
= bgp_table_top(table
); rn
; rn
= bgp_route_next(rn
)) {
5113 for (ri
= rn
->info
; ri
; ri
= ri
->next
) {
5115 /* Consider "valid" remote routes applicable for
5117 if (!(ri
->type
== ZEBRA_ROUTE_BGP
5118 && ri
->sub_type
== BGP_ROUTE_NORMAL
))
5121 if (bgp_nexthop_self(bgp
, ri
->attr
->nexthop
)) {
5123 char attr_str
[BUFSIZ
];
5124 char pbuf
[PREFIX_STRLEN
];
5126 bgp_dump_attr(ri
->attr
, attr_str
,
5129 if (bgp_debug_update(ri
->peer
, &rn
->p
,
5132 "%u: prefix %s with attr %s - DENIED due to martian or self nexthop",
5139 bgp_evpn_unimport_route(bgp
, afi
, safi
,
5142 bgp_rib_remove(rn
, ri
, ri
->peer
, afi
,
5153 * Handle del of a local MACIP.
5155 int bgp_evpn_local_macip_del(struct bgp
*bgp
, vni_t vni
, struct ethaddr
*mac
,
5158 struct bgpevpn
*vpn
;
5159 struct prefix_evpn p
;
5161 /* Lookup VNI hash - should exist. */
5162 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5163 if (!vpn
|| !is_vni_live(vpn
)) {
5164 flog_warn(EC_BGP_EVPN_VPN_VNI
,
5165 "%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 flog_warn(EC_BGP_EVPN_VPN_VNI
,
5190 "%u: VNI hash entry for VNI %u %s at MACIP ADD",
5191 bgp
->vrf_id
, vni
, vpn
? "not live" : "not found");
5195 /* Create EVPN type-2 route and schedule for processing. */
5196 build_evpn_type2_prefix(&p
, mac
, ip
);
5197 if (update_evpn_route(bgp
, vpn
, &p
, flags
, seq
)) {
5198 char buf
[ETHER_ADDR_STRLEN
];
5199 char buf2
[INET6_ADDRSTRLEN
];
5202 EC_BGP_EVPN_ROUTE_CREATE
,
5203 "%u:Failed to create Type-2 route, VNI %u %s MAC %s IP %s (flags: 0x%x)",
5204 bgp
->vrf_id
, vpn
->vni
,
5205 CHECK_FLAG(flags
, ZEBRA_MACIP_TYPE_STICKY
)
5208 prefix_mac2str(mac
, buf
, sizeof(buf
)),
5209 ipaddr2str(ip
, buf2
, sizeof(buf2
)), flags
);
5216 static void link_l2vni_hash_to_l3vni(struct hash_backet
*backet
,
5217 struct bgp
*bgp_vrf
)
5219 struct bgpevpn
*vpn
= (struct bgpevpn
*)backet
->data
;
5220 struct bgp
*bgp_def
= NULL
;
5222 bgp_def
= bgp_get_default();
5225 if (vpn
->tenant_vrf_id
== bgp_vrf
->vrf_id
)
5226 bgpevpn_link_to_l3vni(vpn
);
5229 int bgp_evpn_local_l3vni_add(vni_t l3vni
, vrf_id_t vrf_id
, struct ethaddr
*rmac
,
5230 struct in_addr originator_ip
, int filter
)
5232 struct bgp
*bgp_vrf
= NULL
; /* bgp VRF instance */
5233 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
5234 struct listnode
*node
= NULL
;
5235 struct bgpevpn
*vpn
= NULL
;
5238 /* get the default instance - required to get the AS number for VRF
5241 bgp_def
= bgp_get_default();
5245 "Cannot process L3VNI %u ADD - default BGP instance not yet created",
5251 /* if the BGP vrf instance doesnt exist - create one */
5252 bgp_vrf
= bgp_lookup_by_name(vrf_id_to_name(vrf_id
));
5257 ret
= bgp_get(&bgp_vrf
, &as
, vrf_id_to_name(vrf_id
),
5258 BGP_INSTANCE_TYPE_VRF
);
5260 case BGP_ERR_MULTIPLE_INSTANCE_NOT_SET
:
5261 flog_err(EC_BGP_MULTI_INSTANCE
,
5262 "'bgp multiple-instance' not present\n");
5264 case BGP_ERR_AS_MISMATCH
:
5265 flog_err(EC_BGP_EVPN_AS_MISMATCH
,
5266 "BGP is already running; AS is %u\n", as
);
5268 case BGP_ERR_INSTANCE_MISMATCH
:
5269 flog_err(EC_BGP_EVPN_INSTANCE_MISMATCH
,
5270 "BGP instance name and AS number mismatch\n");
5274 /* mark as auto created */
5275 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
);
5278 /* associate with l3vni */
5279 bgp_vrf
->l3vni
= l3vni
;
5281 /* set the router mac - to be used in mac-ip routes for this vrf */
5282 memcpy(&bgp_vrf
->rmac
, rmac
, sizeof(struct ethaddr
));
5284 /* set the originator ip */
5285 bgp_vrf
->originator_ip
= originator_ip
;
5287 /* set the right filter - are we using l3vni only for prefix routes? */
5289 SET_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
);
5291 /* auto derive RD/RT */
5292 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_IMPORT_RT_CFGD
))
5293 evpn_auto_rt_import_add_for_vrf(bgp_vrf
);
5294 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_EXPORT_RT_CFGD
))
5295 evpn_auto_rt_export_add_for_vrf(bgp_vrf
);
5296 bgp_evpn_derive_auto_rd_for_vrf(bgp_vrf
);
5298 /* link all corresponding l2vnis */
5299 hash_iterate(bgp_def
->vnihash
,
5300 (void (*)(struct hash_backet
*,
5301 void *))link_l2vni_hash_to_l3vni
,
5304 /* Only update all corresponding type-2 routes if we are advertising two
5305 * labels along with type-2 routes
5308 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
))
5309 update_routes_for_vni(bgp_def
, vpn
);
5311 /* advertise type-5 routes if needed */
5312 update_advertise_vrf_routes(bgp_vrf
);
5314 /* install all remote routes belonging to this l3vni into correspondng
5316 install_routes_for_vrf(bgp_vrf
);
5321 int bgp_evpn_local_l3vni_del(vni_t l3vni
, vrf_id_t vrf_id
)
5323 struct bgp
*bgp_vrf
= NULL
; /* bgp vrf instance */
5324 struct bgp
*bgp_def
= NULL
; /* default bgp instance */
5325 struct listnode
*node
= NULL
;
5326 struct listnode
*next
= NULL
;
5327 struct bgpevpn
*vpn
= NULL
;
5329 bgp_vrf
= bgp_lookup_by_vrf_id(vrf_id
);
5333 "Cannot process L3VNI %u Del - Could not find BGP instance",
5338 bgp_def
= bgp_get_default();
5342 "Cannot process L3VNI %u Del - Could not find default BGP instance",
5347 /* Remove remote routes from BGT VRF even if BGP_VRF_AUTO is configured,
5348 * bgp_delete would not remove/decrement bgp_info of the ip_prefix
5349 * routes. This will uninstalling the routes from zebra and decremnt the
5352 uninstall_routes_for_vrf(bgp_vrf
);
5354 /* delete/withdraw all type-5 routes */
5355 delete_withdraw_vrf_routes(bgp_vrf
);
5357 /* remove the l3vni from vrf instance */
5360 /* remove the Rmac from the BGP vrf */
5361 memset(&bgp_vrf
->rmac
, 0, sizeof(struct ethaddr
));
5364 if (!list_isempty(bgp_vrf
->vrf_import_rtl
)) {
5365 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);
5366 list_delete_all_node(bgp_vrf
->vrf_import_rtl
);
5368 if (!list_isempty(bgp_vrf
->vrf_export_rtl
)) {
5369 list_delete_all_node(bgp_vrf
->vrf_export_rtl
);
5372 /* update all corresponding local mac-ip routes */
5373 if (!CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY
)) {
5374 for (ALL_LIST_ELEMENTS_RO(bgp_vrf
->l2vnis
, node
, vpn
)) {
5375 UNSET_FLAG(vpn
->flags
, VNI_FLAG_USE_TWO_LABELS
);
5376 update_routes_for_vni(bgp_def
, vpn
);
5380 /* If any L2VNIs point to this instance, unlink them. */
5381 for (ALL_LIST_ELEMENTS(bgp_vrf
->l2vnis
, node
, next
, vpn
))
5382 bgpevpn_unlink_from_l3vni(vpn
);
5384 /* Delete the instance if it was autocreated */
5385 if (CHECK_FLAG(bgp_vrf
->vrf_flags
, BGP_VRF_AUTO
))
5386 bgp_delete(bgp_vrf
);
5392 * Handle del of a local VNI.
5394 int bgp_evpn_local_vni_del(struct bgp
*bgp
, vni_t vni
)
5396 struct bgpevpn
*vpn
;
5398 /* Locate VNI hash */
5399 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5401 if (bgp_debug_zebra(NULL
))
5403 EC_BGP_EVPN_VPN_VNI
,
5404 "%u: VNI hash entry for VNI %u not found at DEL",
5409 /* Remove all local EVPN routes and schedule for processing (to
5410 * withdraw from peers).
5412 delete_routes_for_vni(bgp
, vpn
);
5415 * tunnel is no longer active, del tunnel ip address from tip_hash
5417 bgp_tip_del(bgp
, &vpn
->originator_ip
);
5419 /* Clear "live" flag and see if hash needs to be freed. */
5420 UNSET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
5421 if (!is_vni_configured(vpn
))
5422 bgp_evpn_free(bgp
, vpn
);
5428 * Handle add (or update) of a local VNI. The VNI changes we care
5429 * about are for the local-tunnel-ip and the (tenant) VRF.
5431 int bgp_evpn_local_vni_add(struct bgp
*bgp
, vni_t vni
,
5432 struct in_addr originator_ip
, vrf_id_t tenant_vrf_id
)
5434 struct bgpevpn
*vpn
;
5435 struct prefix_evpn p
;
5437 /* Lookup VNI. If present and no change, exit. */
5438 vpn
= bgp_evpn_lookup_vni(bgp
, vni
);
5441 if (is_vni_live(vpn
)
5442 && IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
)
5443 && vpn
->tenant_vrf_id
== tenant_vrf_id
)
5444 /* Probably some other param has changed that we don't
5448 /* Update tenant_vrf_id if it has changed. */
5449 if (vpn
->tenant_vrf_id
!= tenant_vrf_id
) {
5450 bgpevpn_unlink_from_l3vni(vpn
);
5451 vpn
->tenant_vrf_id
= tenant_vrf_id
;
5452 bgpevpn_link_to_l3vni(vpn
);
5455 /* If tunnel endpoint IP has changed, update (and delete prior
5456 * type-3 route, if needed.)
5458 if (!IPV4_ADDR_SAME(&vpn
->originator_ip
, &originator_ip
))
5459 handle_tunnel_ip_change(bgp
, vpn
, originator_ip
);
5461 /* Update all routes with new endpoint IP and/or export RT
5464 if (is_vni_live(vpn
))
5465 update_routes_for_vni(bgp
, vpn
);
5468 /* Create or update as appropriate. */
5470 vpn
= bgp_evpn_new(bgp
, vni
, originator_ip
, tenant_vrf_id
);
5474 "%u: Failed to allocate VNI entry for VNI %u - at Add",
5480 /* if the VNI is live already, there is nothing more to do */
5481 if (is_vni_live(vpn
))
5484 /* Mark as "live" */
5485 SET_FLAG(vpn
->flags
, VNI_FLAG_LIVE
);
5487 /* tunnel is now active, add tunnel-ip to db */
5488 bgp_tip_add(bgp
, &originator_ip
);
5490 /* filter routes as nexthop database has changed */
5491 bgp_filter_evpn_routes_upon_martian_nh_change(bgp
);
5493 /* Create EVPN type-3 route and schedule for processing. */
5494 build_evpn_type3_prefix(&p
, vpn
->originator_ip
);
5495 if (update_evpn_route(bgp
, vpn
, &p
, 0, 0)) {
5496 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
5497 "%u: Type3 route creation failure for VNI %u",
5502 /* If we have learnt and retained remote routes (VTEPs, MACs) for this
5506 install_routes_for_vni(bgp
, vpn
);
5508 /* If we are advertising gateway mac-ip
5509 It needs to be conveyed again to zebra */
5510 bgp_zebra_advertise_gw_macip(bgp
, vpn
->advertise_gw_macip
, vpn
->vni
);
5516 * bgp_evpn_local_es_del
5518 int bgp_evpn_local_es_del(struct bgp
*bgp
,
5520 struct ipaddr
*originator_ip
)
5522 char buf
[ESI_STR_LEN
];
5523 struct evpnes
*es
= NULL
;
5525 if (!bgp
->esihash
) {
5526 flog_err(EC_BGP_ES_CREATE
, "%u: ESI hash not yet created",
5531 /* Lookup ESI hash - should exist. */
5532 es
= bgp_evpn_lookup_es(bgp
, esi
);
5534 flog_warn(EC_BGP_EVPN_ESI
,
5535 "%u: ESI hash entry for ESI %s at Local ES DEL",
5536 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5540 /* Delete all local EVPN ES routes from ESI table
5541 * and schedule for processing (to withdraw from peers))
5543 delete_routes_for_es(bgp
, es
);
5545 /* free the hash entry */
5546 bgp_evpn_es_free(bgp
, es
);
5552 * bgp_evpn_local_es_add
5554 int bgp_evpn_local_es_add(struct bgp
*bgp
,
5556 struct ipaddr
*originator_ip
)
5558 char buf
[ESI_STR_LEN
];
5559 struct evpnes
*es
= NULL
;
5560 struct prefix_evpn p
;
5562 if (!bgp
->esihash
) {
5563 flog_err(EC_BGP_ES_CREATE
, "%u: ESI hash not yet created",
5568 /* create the new es */
5569 es
= bgp_evpn_lookup_es(bgp
, esi
);
5571 es
= bgp_evpn_es_new(bgp
, esi
, originator_ip
);
5575 "%u: Failed to allocate ES entry for ESI %s - at Local ES Add",
5576 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5580 UNSET_FLAG(es
->flags
, EVPNES_REMOTE
);
5581 SET_FLAG(es
->flags
, EVPNES_LOCAL
);
5583 build_evpn_type4_prefix(&p
, esi
, originator_ip
->ipaddr_v4
);
5584 if (update_evpn_type4_route(bgp
, es
, &p
)) {
5585 flog_err(EC_BGP_EVPN_ROUTE_CREATE
,
5586 "%u: Type4 route creation failure for ESI %s",
5587 bgp
->vrf_id
, esi_to_str(esi
, buf
, sizeof(buf
)));
5591 /* import all remote ES routes in th ES table */
5592 install_routes_for_es(bgp
, es
);
5598 * Cleanup EVPN information on disable - Need to delete and withdraw
5599 * EVPN routes from peers.
5601 void bgp_evpn_cleanup_on_disable(struct bgp
*bgp
)
5603 hash_iterate(bgp
->vnihash
, (void (*)(struct hash_backet
*,
5604 void *))cleanup_vni_on_disable
,
5609 * Cleanup EVPN information - invoked at the time of bgpd exit or when the
5610 * BGP instance (default) is being freed.
5612 void bgp_evpn_cleanup(struct bgp
*bgp
)
5614 hash_iterate(bgp
->vnihash
,
5615 (void (*)(struct hash_backet
*, void *))free_vni_entry
,
5618 hash_free(bgp
->import_rt_hash
);
5619 bgp
->import_rt_hash
= NULL
;
5621 hash_free(bgp
->vrf_import_rt_hash
);
5622 bgp
->vrf_import_rt_hash
= NULL
;
5624 hash_free(bgp
->vnihash
);
5625 bgp
->vnihash
= NULL
;
5627 hash_free(bgp
->esihash
);
5628 bgp
->esihash
= NULL
;
5630 list_delete_and_null(&bgp
->vrf_import_rtl
);
5631 list_delete_and_null(&bgp
->vrf_export_rtl
);
5632 list_delete_and_null(&bgp
->l2vnis
);
5636 * Initialization for EVPN
5639 * hash for RT to VNI
5641 void bgp_evpn_init(struct bgp
*bgp
)
5644 hash_create(vni_hash_key_make
, vni_hash_cmp
, "BGP VNI Hash");
5646 hash_create(esi_hash_keymake
, esi_cmp
,
5647 "BGP EVPN Local ESI Hash");
5648 bgp
->import_rt_hash
=
5649 hash_create(import_rt_hash_key_make
, import_rt_hash_cmp
,
5650 "BGP Import RT Hash");
5651 bgp
->vrf_import_rt_hash
=
5652 hash_create(vrf_import_rt_hash_key_make
, vrf_import_rt_hash_cmp
,
5653 "BGP VRF Import RT Hash");
5654 bgp
->vrf_import_rtl
= list_new();
5655 bgp
->vrf_import_rtl
->cmp
=
5656 (int (*)(void *, void *))evpn_route_target_cmp
;
5657 bgp
->vrf_import_rtl
->del
= evpn_xxport_delete_ecomm
;
5658 bgp
->vrf_export_rtl
= list_new();
5659 bgp
->vrf_export_rtl
->cmp
=
5660 (int (*)(void *, void *))evpn_route_target_cmp
;
5661 bgp
->vrf_export_rtl
->del
= evpn_xxport_delete_ecomm
;
5662 bgp
->l2vnis
= list_new();
5663 bgp
->l2vnis
->cmp
= (int (*)(void *, void *))vni_hash_cmp
;
5666 void bgp_evpn_vrf_delete(struct bgp
*bgp_vrf
)
5668 bgp_evpn_unmap_vrf_from_its_rts(bgp_vrf
);