[mirror_frr.git] / bgpd / bgp_evpn_private.h

/* BGP EVPN internal definitions
 * Copyright (C) 2017 Cumulus Networks, Inc.
 *
 * This file is part of FRR.
 *
 * FRR is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * FRR is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with FRR; see the file COPYING.  If not, write to the Free
 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 * 02111-1307, USA.
 */

#ifndef _BGP_EVPN_PRIVATE_H
#define _BGP_EVPN_PRIVATE_H

#include "vxlan.h"
#include "zebra.h"

#include "bgpd/bgpd.h"
#include "bgpd/bgp_ecommunity.h"

#define RT_ADDRSTRLEN 28

/* EVPN prefix lengths. This represents the sizeof struct evpn_addr
 * in bits  */
#define EVPN_ROUTE_PREFIXLEN (sizeof(struct evpn_addr) * 8)

/* EVPN route types. */
typedef enum {
	BGP_EVPN_AD_ROUTE = 1,    /* Ethernet Auto-Discovery (A-D) route */
	BGP_EVPN_MAC_IP_ROUTE,    /* MAC/IP Advertisement route */
	BGP_EVPN_IMET_ROUTE,      /* Inclusive Multicast Ethernet Tag route */
	BGP_EVPN_ES_ROUTE,	/* Ethernet Segment route */
	BGP_EVPN_IP_PREFIX_ROUTE, /* IP Prefix route */
} bgp_evpn_route_type;

/*
 * Hash table of EVIs. Right now, the only type of EVI supported is with
 * VxLAN encapsulation, hence each EVI corresponds to a L2 VNI.
 * The VNIs are not "created" through BGP but through some other interface
 * on the system. This table stores VNIs that BGP comes to know as present
 * on the system (through interaction with zebra) as well as pre-configured
 * VNIs (which need to be defined in the system to become "live").
 */
struct bgpevpn {
	vni_t vni;
	vrf_id_t tenant_vrf_id;
	uint32_t flags;
#define VNI_FLAG_CFGD              0x1  /* VNI is user configured */
#define VNI_FLAG_LIVE              0x2  /* VNI is "live" */
#define VNI_FLAG_RD_CFGD           0x4  /* RD is user configured. */
#define VNI_FLAG_IMPRT_CFGD        0x8  /* Import RT is user configured */
#define VNI_FLAG_EXPRT_CFGD        0x10 /* Export RT is user configured */
#define VNI_FLAG_USE_TWO_LABELS    0x20 /* Attach both L2-VNI and L3-VNI if
					   needed for this VPN */

	struct bgp *bgp_vrf; /* back pointer to the vrf instance */

					   /* Flag to indicate if we are
					    * advertising the g/w mac ip for
					    * this VNI*/
	uint8_t advertise_gw_macip;

	/* Flag to indicate if we are
	 * advertising subnet for this VNI */
	uint8_t advertise_subnet;

	/* Flag to indicate if we are advertising the svi mac ip for this VNI*/
	uint8_t advertise_svi_macip;

	/* Id for deriving the RD
	 * automatically for this VNI */
	uint16_t rd_id;

	/* RD for this VNI. */
	struct prefix_rd prd;

	/* Route type 3 field */
	struct in_addr originator_ip;

	/* PIM-SM MDT group for BUM flooding */
	struct in_addr mcast_grp;

	/* Import and Export RTs. */
	struct list *import_rtl;
	struct list *export_rtl;

	/* Route table for EVPN routes for
	 * this VNI. */
	struct bgp_table *route_table;

	QOBJ_FIELDS
};

DECLARE_QOBJ_TYPE(bgpevpn)

struct evpnes {

	/* Ethernet Segment Identifier */
	esi_t esi;

	/* es flags */
	uint16_t flags;
#define EVPNES_LOCAL	0x01
#define EVPNES_REMOTE	0x02

	/*
	 * Id for deriving the RD
	 * automatically for this ESI
	 */
	uint16_t rd_id;

	/* RD for this VNI. */
	struct prefix_rd prd;

	/* originator ip address  */
	struct ipaddr originator_ip;

	/* list of VTEPs in the same site */
	struct list *vtep_list;

	/*
	 * Route table for EVPN routes for
	 * this ESI. - type4 routes
	 */
	struct bgp_table *route_table;

	QOBJ_FIELDS
};

DECLARE_QOBJ_TYPE(evpnes)

/* Mapping of Import RT to VNIs.
 * The Import RTs of all VNIs are maintained in a hash table with each
 * RT linking to all VNIs that will import routes matching this RT.
 */
struct irt_node {
	/* RT */
	struct ecommunity_val rt;

	/* List of VNIs importing routes matching this RT. */
	struct list *vnis;
};

/* Mapping of Import RT to VRFs.
 * The Import RTs of all VRFss are maintained in a hash table with each
 * RT linking to all VRFs that will import routes matching this RT.
 */
struct vrf_irt_node {
	/* RT */
	struct ecommunity_val rt;

	/* List of VNIs importing routes matching this RT. */
	struct list *vrfs;
};


#define RT_TYPE_IMPORT 1
#define RT_TYPE_EXPORT 2
#define RT_TYPE_BOTH   3

#define EVPN_DAD_DEFAULT_TIME 180 /* secs */
#define EVPN_DAD_DEFAULT_MAX_MOVES 5 /* default from RFC 7432 */
#define EVPN_DAD_DEFAULT_AUTO_RECOVERY_TIME 1800 /* secs */

struct bgp_evpn_info {
	/* enable disable dup detect */
	bool dup_addr_detect;

	/* Detection time(M) */
	int dad_time;
	/* Detection max moves(N) */
	uint32_t dad_max_moves;
	/* Permanent freeze */
	bool dad_freeze;
	/* Recovery time */
	uint32_t dad_freeze_time;

	/* EVPN enable - advertise svi macip routes */
	int advertise_svi_macip;

};

static inline int is_vrf_rd_configured(struct bgp *bgp_vrf)
{
	return (CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_RD_CFGD));
}

static inline int bgp_evpn_vrf_rd_matches_existing(struct bgp *bgp_vrf,
						   struct prefix_rd *prd)
{
	return (memcmp(&bgp_vrf->vrf_prd.val, prd->val, ECOMMUNITY_SIZE) == 0);
}

static inline vni_t bgpevpn_get_l3vni(struct bgpevpn *vpn)
{
	return vpn->bgp_vrf ? vpn->bgp_vrf->l3vni : 0;
}

static inline void bgpevpn_get_rmac(struct bgpevpn *vpn, struct ethaddr *rmac)
{
	memset(rmac, 0, sizeof(struct ethaddr));
	if (!vpn->bgp_vrf)
		return;
	memcpy(rmac, &vpn->bgp_vrf->rmac, sizeof(struct ethaddr));
}

static inline struct list *bgpevpn_get_vrf_export_rtl(struct bgpevpn *vpn)
{
	if (!vpn->bgp_vrf)
		return NULL;

	return vpn->bgp_vrf->vrf_export_rtl;
}

static inline struct list *bgpevpn_get_vrf_import_rtl(struct bgpevpn *vpn)
{
	if (!vpn->bgp_vrf)
		return NULL;

	return vpn->bgp_vrf->vrf_import_rtl;
}

static inline void bgpevpn_unlink_from_l3vni(struct bgpevpn *vpn)
{
	/* bail if vpn is not associated to bgp_vrf */
	if (!vpn->bgp_vrf)
		return;

	UNSET_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS);
	listnode_delete(vpn->bgp_vrf->l2vnis, vpn);

	/* remove the backpointer to the vrf instance */
	bgp_unlock(vpn->bgp_vrf);
	vpn->bgp_vrf = NULL;
}

static inline void bgpevpn_link_to_l3vni(struct bgpevpn *vpn)
{
	struct bgp *bgp_vrf = NULL;

	/* bail if vpn is already associated to vrf */
	if (vpn->bgp_vrf)
		return;

	bgp_vrf = bgp_lookup_by_vrf_id(vpn->tenant_vrf_id);
	if (!bgp_vrf)
		return;

	/* associate the vpn to the bgp_vrf instance */
	vpn->bgp_vrf = bgp_lock(bgp_vrf);
	listnode_add_sort(bgp_vrf->l2vnis, vpn);

	/* check if we are advertising two labels for this vpn */
	if (!CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY))
		SET_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS);
}

static inline int is_vni_configured(struct bgpevpn *vpn)
{
	return (CHECK_FLAG(vpn->flags, VNI_FLAG_CFGD));
}

static inline int is_vni_live(struct bgpevpn *vpn)
{
	return (CHECK_FLAG(vpn->flags, VNI_FLAG_LIVE));
}

static inline int is_rd_configured(struct bgpevpn *vpn)
{
	return (CHECK_FLAG(vpn->flags, VNI_FLAG_RD_CFGD));
}

static inline int bgp_evpn_rd_matches_existing(struct bgpevpn *vpn,
					       struct prefix_rd *prd)
{
	return (memcmp(&vpn->prd.val, prd->val, ECOMMUNITY_SIZE) == 0);
}

static inline int is_import_rt_configured(struct bgpevpn *vpn)
{
	return (CHECK_FLAG(vpn->flags, VNI_FLAG_IMPRT_CFGD));
}

static inline int is_export_rt_configured(struct bgpevpn *vpn)
{
	return (CHECK_FLAG(vpn->flags, VNI_FLAG_EXPRT_CFGD));
}

static inline int is_vni_param_configured(struct bgpevpn *vpn)
{
	return (is_rd_configured(vpn) || is_import_rt_configured(vpn)
		|| is_export_rt_configured(vpn));
}

static inline void encode_es_rt_extcomm(struct ecommunity_val *eval,
					struct ethaddr *mac)
{
	memset(eval, 0, sizeof(struct ecommunity_val));
	eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_ES_IMPORT_RT;
	memcpy(&eval->val[2], mac, ETH_ALEN);
}

static inline void encode_rmac_extcomm(struct ecommunity_val *eval,
				       struct ethaddr *rmac)
{
	memset(eval, 0, sizeof(*eval));
	eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC;
	memcpy(&eval->val[2], rmac, ETH_ALEN);
}

static inline void encode_default_gw_extcomm(struct ecommunity_val *eval)
{
	memset(eval, 0, sizeof(*eval));
	eval->val[0] = ECOMMUNITY_ENCODE_OPAQUE;
	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_DEF_GW;
}

static inline void encode_mac_mobility_extcomm(int static_mac, uint32_t seq,
					       struct ecommunity_val *eval)
{
	memset(eval, 0, sizeof(*eval));
	eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY;
	if (static_mac)
		eval->val[2] = ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY_FLAG_STICKY;
	eval->val[4] = (seq >> 24) & 0xff;
	eval->val[5] = (seq >> 16) & 0xff;
	eval->val[6] = (seq >> 8) & 0xff;
	eval->val[7] = seq & 0xff;
}

static inline void encode_na_flag_extcomm(struct ecommunity_val *eval,
					  uint8_t na_flag)
{
	memset(eval, 0, sizeof(*eval));
	eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_ND;
	if (na_flag)
		eval->val[2] |= ECOMMUNITY_EVPN_SUBTYPE_ND_ROUTER_FLAG;
}

static inline void ip_prefix_from_type5_prefix(struct prefix_evpn *evp,
					       struct prefix *ip)
{
	memset(ip, 0, sizeof(struct prefix));
	if (is_evpn_prefix_ipaddr_v4(evp)) {
		ip->family = AF_INET;
		ip->prefixlen = evp->prefix.prefix_addr.ip_prefix_length;
		memcpy(&(ip->u.prefix4), &(evp->prefix.prefix_addr.ip.ip),
		       IPV4_MAX_BYTELEN);
	} else if (is_evpn_prefix_ipaddr_v6(evp)) {
		ip->family = AF_INET6;
		ip->prefixlen = evp->prefix.prefix_addr.ip_prefix_length;
		memcpy(&(ip->u.prefix6), &(evp->prefix.prefix_addr.ip.ip),
		       IPV6_MAX_BYTELEN);
	}
}

static inline int is_evpn_prefix_default(const struct prefix *evp)
{
	if (evp->family != AF_EVPN)
		return 0;

	return ((evp->u.prefix_evpn.prefix_addr.ip_prefix_length  == 0) ?
		1 : 0);
}

static inline void ip_prefix_from_type2_prefix(struct prefix_evpn *evp,
					       struct prefix *ip)
{
	memset(ip, 0, sizeof(struct prefix));
	if (is_evpn_prefix_ipaddr_v4(evp)) {
		ip->family = AF_INET;
		ip->prefixlen = IPV4_MAX_BITLEN;
		memcpy(&(ip->u.prefix4), &(evp->prefix.macip_addr.ip.ip),
		       IPV4_MAX_BYTELEN);
	} else if (is_evpn_prefix_ipaddr_v6(evp)) {
		ip->family = AF_INET6;
		ip->prefixlen = IPV6_MAX_BITLEN;
		memcpy(&(ip->u.prefix6), &(evp->prefix.macip_addr.ip.ip),
		       IPV6_MAX_BYTELEN);
	}
}

static inline void ip_prefix_from_evpn_prefix(struct prefix_evpn *evp,
					      struct prefix *ip)
{
	if (evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE)
		ip_prefix_from_type2_prefix(evp, ip);
	else if (evp->prefix.route_type == BGP_EVPN_IP_PREFIX_ROUTE)
		ip_prefix_from_type5_prefix(evp, ip);
}

static inline void build_evpn_type2_prefix(struct prefix_evpn *p,
					   struct ethaddr *mac,
					   struct ipaddr *ip)
{
	memset(p, 0, sizeof(struct prefix_evpn));
	p->family = AF_EVPN;
	p->prefixlen = EVPN_ROUTE_PREFIXLEN;
	p->prefix.route_type = BGP_EVPN_MAC_IP_ROUTE;
	memcpy(&p->prefix.macip_addr.mac.octet, mac->octet, ETH_ALEN);
	p->prefix.macip_addr.ip.ipa_type = IPADDR_NONE;
	if (ip)
		memcpy(&p->prefix.macip_addr.ip, ip, sizeof(*ip));
}

static inline void build_type5_prefix_from_ip_prefix(struct prefix_evpn *evp,
						     struct prefix *ip_prefix)
{
	struct ipaddr ip;

	memset(&ip, 0, sizeof(struct ipaddr));
	if (ip_prefix->family == AF_INET) {
		ip.ipa_type = IPADDR_V4;
		memcpy(&ip.ipaddr_v4, &ip_prefix->u.prefix4,
		       sizeof(struct in_addr));
	} else {
		ip.ipa_type = IPADDR_V6;
		memcpy(&ip.ipaddr_v6, &ip_prefix->u.prefix6,
		       sizeof(struct in6_addr));
	}

	memset(evp, 0, sizeof(struct prefix_evpn));
	evp->family = AF_EVPN;
	evp->prefixlen = EVPN_ROUTE_PREFIXLEN;
	evp->prefix.route_type = BGP_EVPN_IP_PREFIX_ROUTE;
	evp->prefix.prefix_addr.ip_prefix_length = ip_prefix->prefixlen;
	evp->prefix.prefix_addr.ip.ipa_type = ip.ipa_type;
	memcpy(&evp->prefix.prefix_addr.ip, &ip, sizeof(struct ipaddr));
}

static inline void build_evpn_type3_prefix(struct prefix_evpn *p,
					   struct in_addr originator_ip)
{
	memset(p, 0, sizeof(struct prefix_evpn));
	p->family = AF_EVPN;
	p->prefixlen = EVPN_ROUTE_PREFIXLEN;
	p->prefix.route_type = BGP_EVPN_IMET_ROUTE;
	p->prefix.imet_addr.ip.ipa_type = IPADDR_V4;
	p->prefix.imet_addr.ip.ipaddr_v4 = originator_ip;
}

static inline void build_evpn_type4_prefix(struct prefix_evpn *p,
					   esi_t *esi,
					   struct in_addr originator_ip)
{
	memset(p, 0, sizeof(struct prefix_evpn));
	p->family = AF_EVPN;
	p->prefixlen = EVPN_ROUTE_PREFIXLEN;
	p->prefix.route_type = BGP_EVPN_ES_ROUTE;
	p->prefix.es_addr.ip_prefix_length = IPV4_MAX_BITLEN;
	p->prefix.es_addr.ip.ipa_type = IPADDR_V4;
	p->prefix.es_addr.ip.ipaddr_v4 = originator_ip;
	memcpy(&p->prefix.es_addr.esi, esi, sizeof(esi_t));
}

static inline int evpn_default_originate_set(struct bgp *bgp, afi_t afi,
					     safi_t safi)
{
	if (afi == AFI_IP &&
	    CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
		       BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4))
		return 1;
	else if (afi == AFI_IP6 &&
		 CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
			    BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6))
		return 1;
	return 0;
}

static inline void es_get_system_mac(esi_t *esi,
				     struct ethaddr *mac)
{
	/*
	 * for type-1 and type-3 ESIs,
	 * the system mac starts at val[1]
	 */
	memcpy(mac, &esi->val[1], ETH_ALEN);
}

static inline int is_es_local(struct evpnes *es)
{
	return CHECK_FLAG(es->flags, EVPNES_LOCAL) ? 1 : 0;
}

extern void bgp_evpn_install_uninstall_default_route(struct bgp *bgp_vrf,
						     afi_t afi, safi_t safi,
						     bool add);
extern void evpn_rt_delete_auto(struct bgp *, vni_t, struct list *);
extern void bgp_evpn_configure_export_rt_for_vrf(struct bgp *bgp_vrf,
						 struct ecommunity *ecomadd);
extern void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp *bgp_vrf,
						   struct ecommunity *ecomdel);
extern void bgp_evpn_configure_import_rt_for_vrf(struct bgp *bgp_vrf,
						 struct ecommunity *ecomadd);
extern void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp *bgp_vrf,
						   struct ecommunity *ecomdel);
extern int bgp_evpn_handle_export_rt_change(struct bgp *bgp,
					    struct bgpevpn *vpn);
extern void bgp_evpn_handle_autort_change(struct bgp *bgp);
extern void bgp_evpn_handle_vrf_rd_change(struct bgp *bgp_vrf, int withdraw);
extern void bgp_evpn_handle_rd_change(struct bgp *bgp, struct bgpevpn *vpn,
				      int withdraw);
extern int bgp_evpn_install_routes(struct bgp *bgp, struct bgpevpn *vpn);
extern int bgp_evpn_uninstall_routes(struct bgp *bgp, struct bgpevpn *vpn);
extern void bgp_evpn_map_vrf_to_its_rts(struct bgp *bgp_vrf);
extern void bgp_evpn_unmap_vrf_from_its_rts(struct bgp *bgp_vrf);
extern void bgp_evpn_map_vni_to_its_rts(struct bgp *bgp, struct bgpevpn *vpn);
extern void bgp_evpn_unmap_vni_from_its_rts(struct bgp *bgp,
					    struct bgpevpn *vpn);
extern void bgp_evpn_derive_auto_rt_import(struct bgp *bgp,
					   struct bgpevpn *vpn);
extern void bgp_evpn_derive_auto_rt_export(struct bgp *bgp,
					   struct bgpevpn *vpn);
extern void bgp_evpn_derive_auto_rd(struct bgp *bgp, struct bgpevpn *vpn);
extern void bgp_evpn_derive_auto_rd_for_vrf(struct bgp *bgp);
extern struct bgpevpn *bgp_evpn_lookup_vni(struct bgp *bgp, vni_t vni);
extern struct bgpevpn *bgp_evpn_new(struct bgp *bgp, vni_t vni,
		struct in_addr originator_ip,
		vrf_id_t tenant_vrf_id,
		struct in_addr mcast_grp);
extern void bgp_evpn_free(struct bgp *bgp, struct bgpevpn *vpn);
extern struct evpnes *bgp_evpn_lookup_es(struct bgp *bgp, esi_t *esi);
extern struct evpnes *bgp_evpn_es_new(struct bgp *bgp, esi_t *esi,
				      struct ipaddr *originator_ip);
extern void bgp_evpn_es_free(struct bgp *bgp, struct evpnes *es);
extern bool bgp_evpn_lookup_l3vni_l2vni_table(vni_t vni);
#endif /* _BGP_EVPN_PRIVATE_H */
Commit	Line	Data
a4168ebc	1	/* BGP EVPN internal definitions
	2	* Copyright (C) 2017 Cumulus Networks, Inc.
	3	*
	4	* This file is part of FRR.
	5	*
	6	* FRR is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2, or (at your option) any
	9	* later version.
	10	*
	11	* FRR is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with FRR; see the file COPYING. If not, write to the Free
	18	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	19	* 02111-1307, USA.
	20	*/
	21
	22	#ifndef _BGP_EVPN_PRIVATE_H
	23	#define _BGP_EVPN_PRIVATE_H
	24
	25	#include "vxlan.h"
	26	#include "zebra.h"
	27
	28	#include "bgpd/bgpd.h"
	29	#include "bgpd/bgp_ecommunity.h"
	30
60466a63	31	#define RT_ADDRSTRLEN 28
9c92b5f7	32
2f04c4f0 AK	33	/* EVPN prefix lengths. This represents the sizeof struct evpn_addr
	34	* in bits */
	35	#define EVPN_ROUTE_PREFIXLEN (sizeof(struct evpn_addr) * 8)
a4168ebc	36
a4168ebc	37	/* EVPN route types. */
d62a17ae	38	typedef enum {
	39	BGP_EVPN_AD_ROUTE = 1, /* Ethernet Auto-Discovery (A-D) route */
	40	BGP_EVPN_MAC_IP_ROUTE, /* MAC/IP Advertisement route */
	41	BGP_EVPN_IMET_ROUTE, /* Inclusive Multicast Ethernet Tag route */
	42	BGP_EVPN_ES_ROUTE, /* Ethernet Segment route */
	43	BGP_EVPN_IP_PREFIX_ROUTE, /* IP Prefix route */
a4168ebc	44	} bgp_evpn_route_type;
	45
	46	/*
	47	* Hash table of EVIs. Right now, the only type of EVI supported is with
	48	* VxLAN encapsulation, hence each EVI corresponds to a L2 VNI.
	49	* The VNIs are not "created" through BGP but through some other interface
	50	* on the system. This table stores VNIs that BGP comes to know as present
	51	* on the system (through interaction with zebra) as well as pre-configured
	52	* VNIs (which need to be defined in the system to become "live").
	53	*/
d62a17ae	54	struct bgpevpn {
d62a17ae	55	vni_t vni;
29c53922	56	vrf_id_t tenant_vrf_id;
d7c0a89a	57	uint32_t flags;
a4168ebc	58	#define VNI_FLAG_CFGD 0x1 /* VNI is user configured */
	59	#define VNI_FLAG_LIVE 0x2 /* VNI is "live" */
	60	#define VNI_FLAG_RD_CFGD 0x4 /* RD is user configured. */
	61	#define VNI_FLAG_IMPRT_CFGD 0x8 /* Import RT is user configured */
	62	#define VNI_FLAG_EXPRT_CFGD 0x10 /* Export RT is user configured */
c48d9f5f MK	63	#define VNI_FLAG_USE_TWO_LABELS 0x20 /* Attach both L2-VNI and L3-VNI if
c48d9f5f MK	64	needed for this VPN */
a4168ebc	65
bc4606bd MK	66	struct bgp bgp_vrf; / back pointer to the vrf instance */
bc4606bd MK	67
996c9314 LB	68	/* Flag to indicate if we are
	69	* advertising the g/w mac ip for
	70	* this VNI*/
d7c0a89a	71	uint8_t advertise_gw_macip;
1a98c087	72
d7c0a89a QY	73	/* Flag to indicate if we are
	74	* advertising subnet for this VNI */
	75	uint8_t advertise_subnet;
31310b25	76
24864e44 CS	77	/* Flag to indicate if we are advertising the svi mac ip for this VNI*/
	78	uint8_t advertise_svi_macip;
	79
d7c0a89a QY	80	/* Id for deriving the RD
	81	* automatically for this VNI */
	82	uint16_t rd_id;
a4168ebc	83
d7c0a89a QY	84	/* RD for this VNI. */
d7c0a89a QY	85	struct prefix_rd prd;
a4168ebc	86
d7c0a89a QY	87	/* Route type 3 field */
d7c0a89a QY	88	struct in_addr originator_ip;
a4168ebc	89
76d07c7a AK	90	/* PIM-SM MDT group for BUM flooding */
	91	struct in_addr mcast_grp;
	92
d7c0a89a QY	93	/* Import and Export RTs. */
	94	struct list *import_rtl;
	95	struct list *export_rtl;
a4168ebc	96
d7c0a89a QY	97	/* Route table for EVPN routes for
	98	* this VNI. */
	99	struct bgp_table *route_table;
a4168ebc	100
d7c0a89a	101	QOBJ_FIELDS
a4168ebc	102	};
	103
	104	DECLARE_QOBJ_TYPE(bgpevpn)
	105
50f74cf1	106	struct evpnes {
	107
	108	/* Ethernet Segment Identifier */
	109	esi_t esi;
	110
	111	/* es flags */
	112	uint16_t flags;
	113	#define EVPNES_LOCAL 0x01
	114	#define EVPNES_REMOTE 0x02
	115
2bb9eff4 DS	116	/*
	117	* Id for deriving the RD
	118	* automatically for this ESI
	119	*/
50f74cf1	120	uint16_t rd_id;
	121
	122	/* RD for this VNI. */
	123	struct prefix_rd prd;
	124
	125	/* originator ip address */
	126	struct ipaddr originator_ip;
	127
	128	/* list of VTEPs in the same site */
	129	struct list *vtep_list;
	130
2bb9eff4 DS	131	/*
	132	* Route table for EVPN routes for
	133	* this ESI. - type4 routes
	134	*/
50f74cf1	135	struct bgp_table *route_table;
	136
	137	QOBJ_FIELDS
	138	};
	139
	140	DECLARE_QOBJ_TYPE(evpnes)
	141
a4168ebc	142	/* Mapping of Import RT to VNIs.
	143	* The Import RTs of all VNIs are maintained in a hash table with each
	144	* RT linking to all VNIs that will import routes matching this RT.
	145	*/
d62a17ae	146	struct irt_node {
	147	/* RT */
	148	struct ecommunity_val rt;
a4168ebc	149
d62a17ae	150	/* List of VNIs importing routes matching this RT. */
d62a17ae	151	struct list *vnis;
a4168ebc	152	};
a4168ebc	153
10ebe1ab MK	154	/* Mapping of Import RT to VRFs.
	155	* The Import RTs of all VRFss are maintained in a hash table with each
	156	* RT linking to all VRFs that will import routes matching this RT.
	157	*/
	158	struct vrf_irt_node {
	159	/* RT */
	160	struct ecommunity_val rt;
	161
	162	/* List of VNIs importing routes matching this RT. */
	163	struct list *vrfs;
	164	};
	165
	166
128ea8ab	167	#define RT_TYPE_IMPORT 1
	168	#define RT_TYPE_EXPORT 2
	169	#define RT_TYPE_BOTH 3
	170
85c8d83b CS	171	#define EVPN_DAD_DEFAULT_TIME 180 /* secs */
	172	#define EVPN_DAD_DEFAULT_MAX_MOVES 5 /* default from RFC 7432 */
	173	#define EVPN_DAD_DEFAULT_AUTO_RECOVERY_TIME 1800 /* secs */
	174
	175	struct bgp_evpn_info {
	176	/* enable disable dup detect */
	177	bool dup_addr_detect;
	178
	179	/* Detection time(M) */
	180	int dad_time;
	181	/* Detection max moves(N) */
	182	uint32_t dad_max_moves;
	183	/* Permanent freeze */
	184	bool dad_freeze;
	185	/* Recovery time */
	186	uint32_t dad_freeze_time;
24864e44 CS	187
	188	/* EVPN enable - advertise svi macip routes */
	189	int advertise_svi_macip;
	190
85c8d83b CS	191	};
85c8d83b CS	192
676f83b9	193	static inline int is_vrf_rd_configured(struct bgp *bgp_vrf)
676f83b9	194	{
996c9314	195	return (CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_RD_CFGD));
676f83b9	196	}
	197
	198	static inline int bgp_evpn_vrf_rd_matches_existing(struct bgp *bgp_vrf,
	199	struct prefix_rd *prd)
	200	{
	201	return (memcmp(&bgp_vrf->vrf_prd.val, prd->val, ECOMMUNITY_SIZE) == 0);
	202	}
	203
6d8c58b7 MK	204	static inline vni_t bgpevpn_get_l3vni(struct bgpevpn *vpn)
6d8c58b7 MK	205	{
bc4606bd	206	return vpn->bgp_vrf ? vpn->bgp_vrf->l3vni : 0;
6d8c58b7 MK	207	}
	208
	209	static inline void bgpevpn_get_rmac(struct bgpevpn vpn, struct ethaddr rmac)
	210	{
6d8c58b7	211	memset(rmac, 0, sizeof(struct ethaddr));
bc4606bd	212	if (!vpn->bgp_vrf)
6d8c58b7	213	return;
bc4606bd	214	memcpy(rmac, &vpn->bgp_vrf->rmac, sizeof(struct ethaddr));
6d8c58b7 MK	215	}
	216
	217	static inline struct list bgpevpn_get_vrf_export_rtl(struct bgpevpn vpn)
	218	{
bc4606bd	219	if (!vpn->bgp_vrf)
6d8c58b7 MK	220	return NULL;
6d8c58b7 MK	221
bc4606bd	222	return vpn->bgp_vrf->vrf_export_rtl;
6d8c58b7 MK	223	}
	224
	225	static inline struct list bgpevpn_get_vrf_import_rtl(struct bgpevpn vpn)
	226	{
bc4606bd	227	if (!vpn->bgp_vrf)
6d8c58b7 MK	228	return NULL;
6d8c58b7 MK	229
bc4606bd	230	return vpn->bgp_vrf->vrf_import_rtl;
6d8c58b7 MK	231	}
6d8c58b7 MK	232
6a8657d0 MK	233	static inline void bgpevpn_unlink_from_l3vni(struct bgpevpn *vpn)
6a8657d0 MK	234	{
bc4606bd MK	235	/* bail if vpn is not associated to bgp_vrf */
bc4606bd MK	236	if (!vpn->bgp_vrf)
6a8657d0	237	return;
996c9314	238
c48d9f5f	239	UNSET_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS);
bc4606bd	240	listnode_delete(vpn->bgp_vrf->l2vnis, vpn);
996c9314	241
bc4606bd	242	/* remove the backpointer to the vrf instance */
0c68e088	243	bgp_unlock(vpn->bgp_vrf);
bc4606bd	244	vpn->bgp_vrf = NULL;
6a8657d0 MK	245	}
	246
	247	static inline void bgpevpn_link_to_l3vni(struct bgpevpn *vpn)
	248	{
	249	struct bgp *bgp_vrf = NULL;
	250
bc4606bd MK	251	/* bail if vpn is already associated to vrf */
	252	if (vpn->bgp_vrf)
	253	return;
	254
6a8657d0	255	bgp_vrf = bgp_lookup_by_vrf_id(vpn->tenant_vrf_id);
c48d9f5f	256	if (!bgp_vrf)
6a8657d0	257	return;
c48d9f5f	258
bc4606bd	259	/* associate the vpn to the bgp_vrf instance */
0c68e088	260	vpn->bgp_vrf = bgp_lock(bgp_vrf);
6a8657d0	261	listnode_add_sort(bgp_vrf->l2vnis, vpn);
83ea2eb0	262
c48d9f5f	263	/* check if we are advertising two labels for this vpn */
996c9314	264	if (!CHECK_FLAG(bgp_vrf->vrf_flags, BGP_VRF_L3VNI_PREFIX_ROUTES_ONLY))
c48d9f5f	265	SET_FLAG(vpn->flags, VNI_FLAG_USE_TWO_LABELS);
6a8657d0 MK	266	}
6a8657d0 MK	267
d62a17ae	268	static inline int is_vni_configured(struct bgpevpn *vpn)
128ea8ab	269	{
d62a17ae	270	return (CHECK_FLAG(vpn->flags, VNI_FLAG_CFGD));
128ea8ab	271	}
128ea8ab	272
d62a17ae	273	static inline int is_vni_live(struct bgpevpn *vpn)
128ea8ab	274	{
d62a17ae	275	return (CHECK_FLAG(vpn->flags, VNI_FLAG_LIVE));
128ea8ab	276	}
128ea8ab	277
d62a17ae	278	static inline int is_rd_configured(struct bgpevpn *vpn)
128ea8ab	279	{
d62a17ae	280	return (CHECK_FLAG(vpn->flags, VNI_FLAG_RD_CFGD));
128ea8ab	281	}
128ea8ab	282
d62a17ae	283	static inline int bgp_evpn_rd_matches_existing(struct bgpevpn *vpn,
d62a17ae	284	struct prefix_rd *prd)
128ea8ab	285	{
d62a17ae	286	return (memcmp(&vpn->prd.val, prd->val, ECOMMUNITY_SIZE) == 0);
128ea8ab	287	}
128ea8ab	288
d62a17ae	289	static inline int is_import_rt_configured(struct bgpevpn *vpn)
128ea8ab	290	{
d62a17ae	291	return (CHECK_FLAG(vpn->flags, VNI_FLAG_IMPRT_CFGD));
128ea8ab	292	}
128ea8ab	293
d62a17ae	294	static inline int is_export_rt_configured(struct bgpevpn *vpn)
128ea8ab	295	{
d62a17ae	296	return (CHECK_FLAG(vpn->flags, VNI_FLAG_EXPRT_CFGD));
128ea8ab	297	}
128ea8ab	298
d62a17ae	299	static inline int is_vni_param_configured(struct bgpevpn *vpn)
128ea8ab	300	{
d62a17ae	301	return (is_rd_configured(vpn) \|\| is_import_rt_configured(vpn)
d62a17ae	302	\|\| is_export_rt_configured(vpn));
128ea8ab	303	}
128ea8ab	304
50f74cf1	305	static inline void encode_es_rt_extcomm(struct ecommunity_val *eval,
	306	struct ethaddr *mac)
	307	{
	308	memset(eval, 0, sizeof(struct ecommunity_val));
	309	eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
	310	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_ES_IMPORT_RT;
	311	memcpy(&eval->val[2], mac, ETH_ALEN);
	312	}
	313
bc59a672 MK	314	static inline void encode_rmac_extcomm(struct ecommunity_val *eval,
	315	struct ethaddr *rmac)
	316	{
	317	memset(eval, 0, sizeof(*eval));
	318	eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
	319	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_ROUTERMAC;
	320	memcpy(&eval->val[2], rmac, ETH_ALEN);
	321	}
	322
ead40654 MK	323	static inline void encode_default_gw_extcomm(struct ecommunity_val *eval)
	324	{
	325	memset(eval, 0, sizeof(*eval));
	326	eval->val[0] = ECOMMUNITY_ENCODE_OPAQUE;
	327	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_DEF_GW;
	328	}
	329
d7c0a89a	330	static inline void encode_mac_mobility_extcomm(int static_mac, uint32_t seq,
d62a17ae	331	struct ecommunity_val *eval)
128ea8ab	332	{
d62a17ae	333	memset(eval, 0, sizeof(*eval));
	334	eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
	335	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY;
	336	if (static_mac)
	337	eval->val[2] = ECOMMUNITY_EVPN_SUBTYPE_MACMOBILITY_FLAG_STICKY;
	338	eval->val[4] = (seq >> 24) & 0xff;
	339	eval->val[5] = (seq >> 16) & 0xff;
	340	eval->val[6] = (seq >> 8) & 0xff;
	341	eval->val[7] = seq & 0xff;
128ea8ab	342	}
128ea8ab	343
68e33151 CS	344	static inline void encode_na_flag_extcomm(struct ecommunity_val *eval,
	345	uint8_t na_flag)
	346	{
	347	memset(eval, 0, sizeof(*eval));
	348	eval->val[0] = ECOMMUNITY_ENCODE_EVPN;
	349	eval->val[1] = ECOMMUNITY_EVPN_SUBTYPE_ND;
	350	if (na_flag)
	351	eval->val[2] \|= ECOMMUNITY_EVPN_SUBTYPE_ND_ROUTER_FLAG;
	352	}
	353
90264d64 MK	354	static inline void ip_prefix_from_type5_prefix(struct prefix_evpn *evp,
	355	struct prefix *ip)
	356	{
	357	memset(ip, 0, sizeof(struct prefix));
3714a385	358	if (is_evpn_prefix_ipaddr_v4(evp)) {
90264d64	359	ip->family = AF_INET;
3714a385	360	ip->prefixlen = evp->prefix.prefix_addr.ip_prefix_length;
3714a385	361	memcpy(&(ip->u.prefix4), &(evp->prefix.prefix_addr.ip.ip),
90264d64	362	IPV4_MAX_BYTELEN);
3714a385	363	} else if (is_evpn_prefix_ipaddr_v6(evp)) {
90264d64	364	ip->family = AF_INET6;
3714a385	365	ip->prefixlen = evp->prefix.prefix_addr.ip_prefix_length;
3714a385	366	memcpy(&(ip->u.prefix6), &(evp->prefix.prefix_addr.ip.ip),
90264d64 MK	367	IPV6_MAX_BYTELEN);
	368	}
	369	}
	370
123214ef	371	static inline int is_evpn_prefix_default(const struct prefix *evp)
6fb219da MK	372	{
	373	if (evp->family != AF_EVPN)
	374	return 0;
	375
3714a385	376	return ((evp->u.prefix_evpn.prefix_addr.ip_prefix_length == 0) ?
3714a385	377	1 : 0);
6fb219da MK	378	}
6fb219da MK	379
d3135ba3	380	static inline void ip_prefix_from_type2_prefix(struct prefix_evpn *evp,
	381	struct prefix *ip)
	382	{
	383	memset(ip, 0, sizeof(struct prefix));
3714a385	384	if (is_evpn_prefix_ipaddr_v4(evp)) {
d3135ba3	385	ip->family = AF_INET;
d3135ba3	386	ip->prefixlen = IPV4_MAX_BITLEN;
3714a385	387	memcpy(&(ip->u.prefix4), &(evp->prefix.macip_addr.ip.ip),
d3135ba3	388	IPV4_MAX_BYTELEN);
3714a385	389	} else if (is_evpn_prefix_ipaddr_v6(evp)) {
d3135ba3	390	ip->family = AF_INET6;
d3135ba3	391	ip->prefixlen = IPV6_MAX_BITLEN;
3714a385	392	memcpy(&(ip->u.prefix6), &(evp->prefix.macip_addr.ip.ip),
d3135ba3	393	IPV6_MAX_BYTELEN);
	394	}
	395	}
	396
3714a385	397	static inline void ip_prefix_from_evpn_prefix(struct prefix_evpn *evp,
	398	struct prefix *ip)
	399	{
	400	if (evp->prefix.route_type == BGP_EVPN_MAC_IP_ROUTE)
	401	ip_prefix_from_type2_prefix(evp, ip);
	402	else if (evp->prefix.route_type == BGP_EVPN_IP_PREFIX_ROUTE)
	403	ip_prefix_from_type5_prefix(evp, ip);
	404	}
	405
d62a17ae	406	static inline void build_evpn_type2_prefix(struct prefix_evpn *p,
	407	struct ethaddr *mac,
	408	struct ipaddr *ip)
128ea8ab	409	{
d62a17ae	410	memset(p, 0, sizeof(struct prefix_evpn));
b03b8898	411	p->family = AF_EVPN;
50f74cf1	412	p->prefixlen = EVPN_ROUTE_PREFIXLEN;
d62a17ae	413	p->prefix.route_type = BGP_EVPN_MAC_IP_ROUTE;
3714a385	414	memcpy(&p->prefix.macip_addr.mac.octet, mac->octet, ETH_ALEN);
3714a385	415	p->prefix.macip_addr.ip.ipa_type = IPADDR_NONE;
d62a17ae	416	if (ip)
3714a385	417	memcpy(&p->prefix.macip_addr.ip, ip, sizeof(*ip));
128ea8ab	418	}
128ea8ab	419
342dd0c6	420	static inline void build_type5_prefix_from_ip_prefix(struct prefix_evpn *evp,
	421	struct prefix *ip_prefix)
	422	{
	423	struct ipaddr ip;
	424
	425	memset(&ip, 0, sizeof(struct ipaddr));
	426	if (ip_prefix->family == AF_INET) {
	427	ip.ipa_type = IPADDR_V4;
	428	memcpy(&ip.ipaddr_v4, &ip_prefix->u.prefix4,
	429	sizeof(struct in_addr));
	430	} else {
	431	ip.ipa_type = IPADDR_V6;
	432	memcpy(&ip.ipaddr_v6, &ip_prefix->u.prefix6,
	433	sizeof(struct in6_addr));
	434	}
	435
	436	memset(evp, 0, sizeof(struct prefix_evpn));
	437	evp->family = AF_EVPN;
50f74cf1	438	evp->prefixlen = EVPN_ROUTE_PREFIXLEN;
342dd0c6	439	evp->prefix.route_type = BGP_EVPN_IP_PREFIX_ROUTE;
3714a385	440	evp->prefix.prefix_addr.ip_prefix_length = ip_prefix->prefixlen;
	441	evp->prefix.prefix_addr.ip.ipa_type = ip.ipa_type;
	442	memcpy(&evp->prefix.prefix_addr.ip, &ip, sizeof(struct ipaddr));
342dd0c6	443	}
342dd0c6	444
d62a17ae	445	static inline void build_evpn_type3_prefix(struct prefix_evpn *p,
d62a17ae	446	struct in_addr originator_ip)
128ea8ab	447	{
d62a17ae	448	memset(p, 0, sizeof(struct prefix_evpn));
b03b8898	449	p->family = AF_EVPN;
50f74cf1	450	p->prefixlen = EVPN_ROUTE_PREFIXLEN;
d62a17ae	451	p->prefix.route_type = BGP_EVPN_IMET_ROUTE;
3714a385	452	p->prefix.imet_addr.ip.ipa_type = IPADDR_V4;
3714a385	453	p->prefix.imet_addr.ip.ipaddr_v4 = originator_ip;
128ea8ab	454	}
128ea8ab	455
50f74cf1	456	static inline void build_evpn_type4_prefix(struct prefix_evpn *p,
	457	esi_t *esi,
	458	struct in_addr originator_ip)
	459	{
	460	memset(p, 0, sizeof(struct prefix_evpn));
	461	p->family = AF_EVPN;
	462	p->prefixlen = EVPN_ROUTE_PREFIXLEN;
	463	p->prefix.route_type = BGP_EVPN_ES_ROUTE;
	464	p->prefix.es_addr.ip_prefix_length = IPV4_MAX_BITLEN;
	465	p->prefix.es_addr.ip.ipa_type = IPADDR_V4;
	466	p->prefix.es_addr.ip.ipaddr_v4 = originator_ip;
	467	memcpy(&p->prefix.es_addr.esi, esi, sizeof(esi_t));
	468	}
	469
486456ca MK	470	static inline int evpn_default_originate_set(struct bgp *bgp, afi_t afi,
	471	safi_t safi)
	472	{
	473	if (afi == AFI_IP &&
	474	CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
	475	BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV4))
	476	return 1;
	477	else if (afi == AFI_IP6 &&
	478	CHECK_FLAG(bgp->af_flags[AFI_L2VPN][SAFI_EVPN],
	479	BGP_L2VPN_EVPN_DEFAULT_ORIGINATE_IPV6))
	480	return 1;
	481	return 0;
	482	}
	483
50f74cf1	484	static inline void es_get_system_mac(esi_t *esi,
	485	struct ethaddr *mac)
	486	{
2bb9eff4 DS	487	/*
	488	* for type-1 and type-3 ESIs,
	489	* the system mac starts at val[1]
50f74cf1	490	*/
	491	memcpy(mac, &esi->val[1], ETH_ALEN);
	492	}
	493
	494	static inline int is_es_local(struct evpnes *es)
	495	{
	496	return CHECK_FLAG(es->flags, EVPNES_LOCAL) ? 1 : 0;
	497	}
	498
5fd9c12b KA	499	extern void bgp_evpn_install_uninstall_default_route(struct bgp *bgp_vrf,
	500	afi_t afi, safi_t safi,
	501	bool add);
996c9314	502	extern void evpn_rt_delete_auto(struct bgp , vni_t, struct list );
523cafc4	503	extern void bgp_evpn_configure_export_rt_for_vrf(struct bgp *bgp_vrf,
	504	struct ecommunity *ecomadd);
	505	extern void bgp_evpn_unconfigure_export_rt_for_vrf(struct bgp *bgp_vrf,
	506	struct ecommunity *ecomdel);
	507	extern void bgp_evpn_configure_import_rt_for_vrf(struct bgp *bgp_vrf,
	508	struct ecommunity *ecomadd);
	509	extern void bgp_evpn_unconfigure_import_rt_for_vrf(struct bgp *bgp_vrf,
	510	struct ecommunity *ecomdel);
d62a17ae	511	extern int bgp_evpn_handle_export_rt_change(struct bgp *bgp,
d62a17ae	512	struct bgpevpn *vpn);
bf1061d8	513	extern void bgp_evpn_handle_autort_change(struct bgp *bgp);
676f83b9	514	extern void bgp_evpn_handle_vrf_rd_change(struct bgp *bgp_vrf, int withdraw);
d62a17ae	515	extern void bgp_evpn_handle_rd_change(struct bgp bgp, struct bgpevpn vpn,
	516	int withdraw);
	517	extern int bgp_evpn_install_routes(struct bgp bgp, struct bgpevpn vpn);
	518	extern int bgp_evpn_uninstall_routes(struct bgp bgp, struct bgpevpn vpn);
523cafc4	519	extern void bgp_evpn_map_vrf_to_its_rts(struct bgp *bgp_vrf);
523cafc4	520	extern void bgp_evpn_unmap_vrf_from_its_rts(struct bgp *bgp_vrf);
d62a17ae	521	extern void bgp_evpn_map_vni_to_its_rts(struct bgp bgp, struct bgpevpn vpn);
	522	extern void bgp_evpn_unmap_vni_from_its_rts(struct bgp *bgp,
	523	struct bgpevpn *vpn);
	524	extern void bgp_evpn_derive_auto_rt_import(struct bgp *bgp,
	525	struct bgpevpn *vpn);
	526	extern void bgp_evpn_derive_auto_rt_export(struct bgp *bgp,
	527	struct bgpevpn *vpn);
	528	extern void bgp_evpn_derive_auto_rd(struct bgp bgp, struct bgpevpn vpn);
676f83b9	529	extern void bgp_evpn_derive_auto_rd_for_vrf(struct bgp *bgp);
d62a17ae	530	extern struct bgpevpn bgp_evpn_lookup_vni(struct bgp bgp, vni_t vni);
d62a17ae	531	extern struct bgpevpn bgp_evpn_new(struct bgp bgp, vni_t vni,
76d07c7a AK	532	struct in_addr originator_ip,
	533	vrf_id_t tenant_vrf_id,
	534	struct in_addr mcast_grp);
d62a17ae	535	extern void bgp_evpn_free(struct bgp bgp, struct bgpevpn vpn);
50f74cf1	536	extern struct evpnes bgp_evpn_lookup_es(struct bgp bgp, esi_t *esi);
	537	extern struct evpnes bgp_evpn_es_new(struct bgp bgp, esi_t *esi,
	538	struct ipaddr *originator_ip);
	539	extern void bgp_evpn_es_free(struct bgp bgp, struct evpnes es);
7df407ed	540	extern bool bgp_evpn_lookup_l3vni_l2vni_table(vni_t vni);
a4168ebc	541	#endif /* _BGP_EVPN_PRIVATE_H */