[mirror_frr.git] / zebra / zebra_vxlan_private.h

/*
 * Zebra VxLAN (EVPN) Data structures and definitions
 * These are "internal" to this function.
 * Copyright (C) 2016, 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 _ZEBRA_VXLAN_PRIVATE_H
#define _ZEBRA_VXLAN_PRIVATE_H

#include <zebra.h>

#include <zebra.h>

#include "if.h"
#include "linklist.h"
#include "zebra_vxlan.h"

#define ERR_STR_SZ 256

/* definitions */
typedef struct zebra_vni_t_ zebra_vni_t;
typedef struct zebra_vtep_t_ zebra_vtep_t;
typedef struct zebra_mac_t_ zebra_mac_t;
typedef struct zebra_neigh_t_ zebra_neigh_t;
typedef struct zebra_l3vni_t_ zebra_l3vni_t;

/*
 * VTEP info
 *
 * Right now, this just has each remote VTEP's IP address.
 */
struct zebra_vtep_t_ {
	/* Remote IP. */
	/* NOTE: Can only be IPv4 right now. */
	struct in_addr vtep_ip;

	/* Links. */
	struct zebra_vtep_t_ *next;
	struct zebra_vtep_t_ *prev;
};


/*
 * VNI hash table
 *
 * Contains information pertaining to a VNI:
 * - the list of remote VTEPs (with this VNI)
 */
struct zebra_vni_t_ {
	/* VNI - key */
	vni_t vni;

	/* Flag for advertising gw macip */
	uint8_t advertise_gw_macip;

	/* Flag for advertising gw macip */
	uint8_t advertise_subnet;

	/* Corresponding VxLAN interface. */
	struct interface *vxlan_if;

	/* List of remote VTEPs */
	zebra_vtep_t *vteps;

	/* Local IP */
	struct in_addr local_vtep_ip;

	/* tenant VRF, if any */
	vrf_id_t vrf_id;

	/* List of local or remote MAC */
	struct hash *mac_table;

	/* List of local or remote neighbors (MAC+IP) */
	struct hash *neigh_table;
};

/* L3 VNI hash table */
struct zebra_l3vni_t_ {

	/* VNI key */
	vni_t vni;

	/* vrf_id */
	vrf_id_t vrf_id;

	uint32_t filter;
#define PREFIX_ROUTES_ONLY	(1 << 0) /* l3-vni used for prefix routes only */

	/* Local IP */
	struct in_addr local_vtep_ip;

	/* kernel interface for l3vni */
	struct interface *vxlan_if;

	/* SVI interface corresponding to the l3vni */
	struct interface *svi_if;

	/* list of L2 VNIs associated with the L3 VNI */
	struct list *l2vnis;

	/* list of remote router-macs */
	struct hash *rmac_table;

	/* list of remote vtep-ip neigh */
	struct hash *nh_table;
};

/* get the vx-intf name for l3vni */
static inline const char *zl3vni_vxlan_if_name(zebra_l3vni_t *zl3vni)
{
	return zl3vni->vxlan_if ? zl3vni->vxlan_if->name : "None";
}

/* get the svi intf name for l3vni */
static inline const char *zl3vni_svi_if_name(zebra_l3vni_t *zl3vni)
{
	return zl3vni->svi_if ? zl3vni->svi_if->name : "None";
}

/* get the vrf name for l3vni */
static inline const char *zl3vni_vrf_name(zebra_l3vni_t *zl3vni)
{
	return vrf_id_to_name(zl3vni->vrf_id);
}

/* get the rmac string */
static inline const char *zl3vni_rmac2str(zebra_l3vni_t *zl3vni, char *buf,
					  int size)
{
	char *ptr;

	if (!buf)
		ptr = (char *)XMALLOC(MTYPE_TMP,
				      ETHER_ADDR_STRLEN * sizeof(char));
	else {
		assert(size >= ETHER_ADDR_STRLEN);
		ptr = buf;
	}

	if (zl3vni->svi_if)
		snprintf(ptr, (ETHER_ADDR_STRLEN),
			 "%02x:%02x:%02x:%02x:%02x:%02x",
			 (uint8_t)zl3vni->svi_if->hw_addr[0],
			 (uint8_t)zl3vni->svi_if->hw_addr[1],
			 (uint8_t)zl3vni->svi_if->hw_addr[2],
			 (uint8_t)zl3vni->svi_if->hw_addr[3],
			 (uint8_t)zl3vni->svi_if->hw_addr[4],
			 (uint8_t)zl3vni->svi_if->hw_addr[5]);
	else
		snprintf(ptr, ETHER_ADDR_STRLEN, "None");

	return ptr;
}

/*
 * l3-vni is oper up when:
 * 0. if EVPN is enabled (advertise-all-vni cfged)
 * 1. it is associated to a vxlan-intf
 * 2. Associated vxlan-intf is oper up
 * 3. it is associated to an SVI
 * 4. associated SVI is oper up
 */
static inline int is_l3vni_oper_up(zebra_l3vni_t *zl3vni)
{
	return (is_evpn_enabled() && zl3vni && (zl3vni->vrf_id != VRF_UNKNOWN)
		&& zl3vni->vxlan_if && if_is_operative(zl3vni->vxlan_if)
		&& zl3vni->svi_if && if_is_operative(zl3vni->svi_if));
}

static inline const char *zl3vni_state2str(zebra_l3vni_t *zl3vni)
{
	if (!zl3vni)
		return NULL;

	if (is_l3vni_oper_up(zl3vni))
		return "Up";
	else
		return "Down";

	return NULL;
}

static inline vrf_id_t zl3vni_vrf_id(zebra_l3vni_t *zl3vni)
{
	return zl3vni->vrf_id;
}

static inline void zl3vni_get_rmac(zebra_l3vni_t *zl3vni, struct ethaddr *rmac)
{
	if (!zl3vni)
		return;

	if (!is_l3vni_oper_up(zl3vni))
		return;

	if (zl3vni->svi_if && if_is_operative(zl3vni->svi_if))
		memcpy(rmac->octet, zl3vni->svi_if->hw_addr, ETH_ALEN);
}

/*
 * MAC hash table.
 *
 * This table contains the MAC addresses pertaining to this VNI.
 * This includes local MACs learnt on an attached VLAN that maps
 * to this VNI as well as remote MACs learnt and installed by BGP.
 * Local MACs will be known either on a VLAN sub-interface or
 * on (port, VLAN); however, it is sufficient for zebra to maintain
 * against the VNI i.e., it does not need to retain the local "port"
 * information. The correct VNI will be obtained as zebra maintains
 * the mapping (of VLAN to VNI).
 */
struct zebra_mac_t_ {
	/* MAC address. */
	struct ethaddr macaddr;

	uint32_t flags;
#define ZEBRA_MAC_LOCAL   0x01
#define ZEBRA_MAC_REMOTE  0x02
#define ZEBRA_MAC_AUTO    0x04  /* Auto created for neighbor. */
#define ZEBRA_MAC_STICKY  0x08  /* Static MAC */
#define ZEBRA_MAC_REMOTE_RMAC  0x10  /* remote router mac */
#define ZEBRA_MAC_DEF_GW  0x20

	/* Local or remote info. */
	union {
		struct {
			ifindex_t ifindex;
			vlanid_t vid;
		} local;

		struct in_addr r_vtep_ip;
	} fwd_info;

	/* List of neigh associated with this mac */
	struct list *neigh_list;

	/* list of hosts pointing to this remote RMAC */
	struct list *host_list;
};

/*
 * Context for MAC hash walk - used by callbacks.
 */
struct mac_walk_ctx {
	zebra_vni_t *zvni;      /* VNI hash */
	struct zebra_vrf *zvrf; /* VRF - for client notification. */
	int uninstall;		/* uninstall from kernel? */
	int upd_client;		/* uninstall from client? */

	uint32_t flags;
#define DEL_LOCAL_MAC                0x1
#define DEL_REMOTE_MAC               0x2
#define DEL_ALL_MAC                  (DEL_LOCAL_MAC | DEL_REMOTE_MAC)
#define DEL_REMOTE_MAC_FROM_VTEP     0x4
#define SHOW_REMOTE_MAC_FROM_VTEP    0x8

	struct in_addr r_vtep_ip; /* To walk MACs from specific VTEP */

	struct vty *vty;	  /* Used by VTY handlers */
	uint32_t count;		  /* Used by VTY handlers */
	struct json_object *json; /* Used for JSON Output */
};

struct rmac_walk_ctx {
	struct vty *vty;
	struct json_object *json;
};

enum zebra_neigh_state { ZEBRA_NEIGH_INACTIVE = 0, ZEBRA_NEIGH_ACTIVE = 1 };

#define IS_ZEBRA_NEIGH_ACTIVE(n) n->state == ZEBRA_NEIGH_ACTIVE

#define IS_ZEBRA_NEIGH_INACTIVE(n) n->state == ZEBRA_NEIGH_INACTIVE

#define ZEBRA_NEIGH_SET_ACTIVE(n) n->state = ZEBRA_NEIGH_ACTIVE

#define ZEBRA_NEIGH_SET_INACTIVE(n) n->state = ZEBRA_NEIGH_INACTIVE

/*
 * Neighbor hash table.
 *
 * This table contains the neighbors (IP to MAC bindings) pertaining to
 * this VNI. This includes local neighbors learnt on the attached VLAN
 * device that maps to this VNI as well as remote neighbors learnt and
 * installed by BGP.
 * Local neighbors will be known against the VLAN device (SVI); however,
 * it is sufficient for zebra to maintain against the VNI. The correct
 * VNI will be obtained as zebra maintains the mapping (of VLAN to VNI).
 */
struct zebra_neigh_t_ {
	/* IP address. */
	struct ipaddr ip;

	/* MAC address. */
	struct ethaddr emac;

	/* Underlying interface. */
	ifindex_t ifindex;

	uint32_t flags;
#define ZEBRA_NEIGH_LOCAL     0x01
#define ZEBRA_NEIGH_REMOTE    0x02
#define ZEBRA_NEIGH_REMOTE_NH    0x04 /* neigh entry for remote vtep */
#define ZEBRA_NEIGH_DEF_GW    0x08

	enum zebra_neigh_state state;

	/* Remote VTEP IP - applicable only for remote neighbors. */
	struct in_addr r_vtep_ip;

	/* list of hosts pointing to this remote NH entry */
	struct list *host_list;
};

/*
 * Context for neighbor hash walk - used by callbacks.
 */
struct neigh_walk_ctx {
	zebra_vni_t *zvni;      /* VNI hash */
	struct zebra_vrf *zvrf; /* VRF - for client notification. */
	int uninstall;		/* uninstall from kernel? */
	int upd_client;		/* uninstall from client? */

	uint32_t flags;
#define DEL_LOCAL_NEIGH              0x1
#define DEL_REMOTE_NEIGH             0x2
#define DEL_ALL_NEIGH                (DEL_LOCAL_NEIGH | DEL_REMOTE_NEIGH)
#define DEL_REMOTE_NEIGH_FROM_VTEP   0x4
#define SHOW_REMOTE_NEIGH_FROM_VTEP  0x8

	struct in_addr r_vtep_ip; /* To walk neighbors from specific VTEP */

	struct vty *vty;	  /* Used by VTY handlers */
	uint32_t count;		  /* Used by VTY handlers */
	uint8_t addr_width;       /* Used by VTY handlers */
	struct json_object *json; /* Used for JSON Output */
};

/* context for neigh hash walk - update l3vni and rmac */
struct neigh_l3info_walk_ctx {

	zebra_vni_t *zvni;
	zebra_l3vni_t *zl3vni;
	int add;
};

struct nh_walk_ctx {

	struct vty *vty;
	struct json_object *json;
};

#endif /* _ZEBRA_VXLAN_PRIVATE_H */
Commit	Line	Data
18a7a601	1	/*
	2	* Zebra VxLAN (EVPN) Data structures and definitions
	3	* These are "internal" to this function.
	4	* Copyright (C) 2016, 2017 Cumulus Networks, Inc.
	5	*
	6	* This file is part of FRR.
	7	*
	8	* FRR is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2, or (at your option) any
	11	* later version.
	12	*
	13	* FRR is distributed in the hope that it will be useful, but
	14	* WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with FRR; see the file COPYING. If not, write to the Free
	20	* Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
	21	* 02111-1307, USA.
	22	*/
	23
	24	#ifndef _ZEBRA_VXLAN_PRIVATE_H
	25	#define _ZEBRA_VXLAN_PRIVATE_H
	26
	27	#include <zebra.h>
	28
	29	#include <zebra.h>
	30
	31	#include "if.h"
	32	#include "linklist.h"
655b04d1	33	#include "zebra_vxlan.h"
18a7a601	34
b7cfce93 MK	35	#define ERR_STR_SZ 256
b7cfce93 MK	36
18a7a601	37	/* definitions */
	38	typedef struct zebra_vni_t_ zebra_vni_t;
	39	typedef struct zebra_vtep_t_ zebra_vtep_t;
4122e252	40	typedef struct zebra_mac_t_ zebra_mac_t;
4122e252	41	typedef struct zebra_neigh_t_ zebra_neigh_t;
b7cfce93	42	typedef struct zebra_l3vni_t_ zebra_l3vni_t;
18a7a601	43
	44	/*
	45	* VTEP info
	46	*
	47	* Right now, this just has each remote VTEP's IP address.
	48	*/
d62a17ae	49	struct zebra_vtep_t_ {
	50	/* Remote IP. */
	51	/* NOTE: Can only be IPv4 right now. */
	52	struct in_addr vtep_ip;
	53
	54	/* Links. */
	55	struct zebra_vtep_t_ *next;
	56	struct zebra_vtep_t_ *prev;
18a7a601	57	};
	58
	59
	60	/*
	61	* VNI hash table
	62	*
	63	* Contains information pertaining to a VNI:
	64	* - the list of remote VTEPs (with this VNI)
	65	*/
d62a17ae	66	struct zebra_vni_t_ {
	67	/* VNI - key */
	68	vni_t vni;
18a7a601	69
1a98c087	70	/* Flag for advertising gw macip */
d7c0a89a	71	uint8_t advertise_gw_macip;
1a98c087	72
31310b25	73	/* Flag for advertising gw macip */
d7c0a89a	74	uint8_t advertise_subnet;
31310b25	75
d62a17ae	76	/* Corresponding VxLAN interface. */
d62a17ae	77	struct interface *vxlan_if;
18a7a601	78
d62a17ae	79	/* List of remote VTEPs */
d62a17ae	80	zebra_vtep_t *vteps;
18a7a601	81
d62a17ae	82	/* Local IP */
d62a17ae	83	struct in_addr local_vtep_ip;
4122e252	84
b7cfce93 MK	85	/* tenant VRF, if any */
	86	vrf_id_t vrf_id;
	87
d62a17ae	88	/* List of local or remote MAC */
d62a17ae	89	struct hash *mac_table;
4122e252	90
d62a17ae	91	/* List of local or remote neighbors (MAC+IP) */
d62a17ae	92	struct hash *neigh_table;
4122e252	93	};
4122e252	94
b7cfce93 MK	95	/* L3 VNI hash table */
	96	struct zebra_l3vni_t_ {
	97
	98	/* VNI key */
	99	vni_t vni;
	100
	101	/* vrf_id */
	102	vrf_id_t vrf_id;
	103
c48d9f5f MK	104	uint32_t filter;
	105	#define PREFIX_ROUTES_ONLY (1 << 0) /* l3-vni used for prefix routes only */
	106
b67a60d2	107	/* Local IP */
	108	struct in_addr local_vtep_ip;
	109
b7cfce93 MK	110	/* kernel interface for l3vni */
	111	struct interface *vxlan_if;
	112
	113	/* SVI interface corresponding to the l3vni */
	114	struct interface *svi_if;
	115
	116	/* list of L2 VNIs associated with the L3 VNI */
	117	struct list *l2vnis;
	118
	119	/* list of remote router-macs */
	120	struct hash *rmac_table;
	121
	122	/* list of remote vtep-ip neigh */
	123	struct hash *nh_table;
	124	};
	125
	126	/* get the vx-intf name for l3vni */
	127	static inline const char zl3vni_vxlan_if_name(zebra_l3vni_t zl3vni)
	128	{
	129	return zl3vni->vxlan_if ? zl3vni->vxlan_if->name : "None";
	130	}
	131
	132	/* get the svi intf name for l3vni */
	133	static inline const char zl3vni_svi_if_name(zebra_l3vni_t zl3vni)
	134	{
	135	return zl3vni->svi_if ? zl3vni->svi_if->name : "None";
	136	}
	137
	138	/* get the vrf name for l3vni */
	139	static inline const char zl3vni_vrf_name(zebra_l3vni_t zl3vni)
	140	{
	141	return vrf_id_to_name(zl3vni->vrf_id);
	142	}
	143
	144	/* get the rmac string */
	145	static inline const char zl3vni_rmac2str(zebra_l3vni_t zl3vni, char *buf,
	146	int size)
	147	{
	148	char *ptr;
	149
	150	if (!buf)
	151	ptr = (char *)XMALLOC(MTYPE_TMP,
	152	ETHER_ADDR_STRLEN * sizeof(char));
	153	else {
	154	assert(size >= ETHER_ADDR_STRLEN);
	155	ptr = buf;
	156	}
	157
	158	if (zl3vni->svi_if)
	159	snprintf(ptr, (ETHER_ADDR_STRLEN),
	160	"%02x:%02x:%02x:%02x:%02x:%02x",
	161	(uint8_t)zl3vni->svi_if->hw_addr[0],
	162	(uint8_t)zl3vni->svi_if->hw_addr[1],
	163	(uint8_t)zl3vni->svi_if->hw_addr[2],
	164	(uint8_t)zl3vni->svi_if->hw_addr[3],
	165	(uint8_t)zl3vni->svi_if->hw_addr[4],
	166	(uint8_t)zl3vni->svi_if->hw_addr[5]);
	167	else
	168	snprintf(ptr, ETHER_ADDR_STRLEN, "None");
	169
	170	return ptr;
	171	}
	172
	173	/*
174	* l3-vni is oper up when:
655b04d1	175	* 0. if EVPN is enabled (advertise-all-vni cfged)
b7cfce93 MK	176	* 1. it is associated to a vxlan-intf
	177	* 2. Associated vxlan-intf is oper up
	178	* 3. it is associated to an SVI
	179	* 4. associated SVI is oper up
	180	*/
	181	static inline int is_l3vni_oper_up(zebra_l3vni_t *zl3vni)
	182	{
996c9314 LB	183	return (is_evpn_enabled() && zl3vni && (zl3vni->vrf_id != VRF_UNKNOWN)
	184	&& zl3vni->vxlan_if && if_is_operative(zl3vni->vxlan_if)
	185	&& zl3vni->svi_if && if_is_operative(zl3vni->svi_if));
b7cfce93 MK	186	}
	187
	188	static inline const char zl3vni_state2str(zebra_l3vni_t zl3vni)
	189	{
	190	if (!zl3vni)
	191	return NULL;
	192
	193	if (is_l3vni_oper_up(zl3vni))
	194	return "Up";
	195	else
	196	return "Down";
	197
	198	return NULL;
	199	}
	200
	201	static inline vrf_id_t zl3vni_vrf_id(zebra_l3vni_t *zl3vni)
	202	{
	203	return zl3vni->vrf_id;
	204	}
	205
996c9314	206	static inline void zl3vni_get_rmac(zebra_l3vni_t zl3vni, struct ethaddr rmac)
b7cfce93 MK	207	{
	208	if (!zl3vni)
	209	return;
	210
	211	if (!is_l3vni_oper_up(zl3vni))
	212	return;
	213
	214	if (zl3vni->svi_if && if_is_operative(zl3vni->svi_if))
	215	memcpy(rmac->octet, zl3vni->svi_if->hw_addr, ETH_ALEN);
	216	}
	217
4122e252	218	/*
	219	* MAC hash table.
	220	*
	221	* This table contains the MAC addresses pertaining to this VNI.
	222	* This includes local MACs learnt on an attached VLAN that maps
	223	* to this VNI as well as remote MACs learnt and installed by BGP.
	224	* Local MACs will be known either on a VLAN sub-interface or
	225	* on (port, VLAN); however, it is sufficient for zebra to maintain
	226	* against the VNI i.e., it does not need to retain the local "port"
	227	* information. The correct VNI will be obtained as zebra maintains
	228	* the mapping (of VLAN to VNI).
	229	*/
d62a17ae	230	struct zebra_mac_t_ {
	231	/* MAC address. */
	232	struct ethaddr macaddr;
4122e252	233
d7c0a89a	234	uint32_t flags;
4122e252	235	#define ZEBRA_MAC_LOCAL 0x01
	236	#define ZEBRA_MAC_REMOTE 0x02
	237	#define ZEBRA_MAC_AUTO 0x04 /* Auto created for neighbor. */
c85c03c7	238	#define ZEBRA_MAC_STICKY 0x08 /* Static MAC */
b7cfce93	239	#define ZEBRA_MAC_REMOTE_RMAC 0x10 /* remote router mac */
ead40654	240	#define ZEBRA_MAC_DEF_GW 0x20
4122e252	241
d62a17ae	242	/* Local or remote info. */
	243	union {
	244	struct {
	245	ifindex_t ifindex;
	246	vlanid_t vid;
	247	} local;
4122e252	248
d62a17ae	249	struct in_addr r_vtep_ip;
d62a17ae	250	} fwd_info;
4122e252	251
b6938a74 MK	252	/* List of neigh associated with this mac */
b6938a74 MK	253	struct list *neigh_list;
b7cfce93	254
6134fd82	255	/* list of hosts pointing to this remote RMAC */
6134fd82	256	struct list *host_list;
4122e252	257	};
	258
	259	/*
	260	* Context for MAC hash walk - used by callbacks.
	261	*/
d62a17ae	262	struct mac_walk_ctx {
	263	zebra_vni_t zvni; / VNI hash */
	264	struct zebra_vrf zvrf; / VRF - for client notification. */
	265	int uninstall; /* uninstall from kernel? */
	266	int upd_client; /* uninstall from client? */
	267
d7c0a89a	268	uint32_t flags;
4122e252	269	#define DEL_LOCAL_MAC 0x1
	270	#define DEL_REMOTE_MAC 0x2
	271	#define DEL_ALL_MAC (DEL_LOCAL_MAC \| DEL_REMOTE_MAC)
	272	#define DEL_REMOTE_MAC_FROM_VTEP 0x4
	273	#define SHOW_REMOTE_MAC_FROM_VTEP 0x8
	274
d62a17ae	275	struct in_addr r_vtep_ip; /* To walk MACs from specific VTEP */
4122e252	276
cd233079	277	struct vty vty; / Used by VTY handlers */
d7c0a89a	278	uint32_t count; /* Used by VTY handlers */
cd233079	279	struct json_object json; / Used for JSON Output */
4122e252	280	};
4122e252	281
b7cfce93 MK	282	struct rmac_walk_ctx {
	283	struct vty *vty;
	284	struct json_object *json;
	285	};
	286
b6938a74 MK	287	enum zebra_neigh_state { ZEBRA_NEIGH_INACTIVE = 0, ZEBRA_NEIGH_ACTIVE = 1 };
	288
	289	#define IS_ZEBRA_NEIGH_ACTIVE(n) n->state == ZEBRA_NEIGH_ACTIVE
	290
	291	#define IS_ZEBRA_NEIGH_INACTIVE(n) n->state == ZEBRA_NEIGH_INACTIVE
	292
	293	#define ZEBRA_NEIGH_SET_ACTIVE(n) n->state = ZEBRA_NEIGH_ACTIVE
	294
	295	#define ZEBRA_NEIGH_SET_INACTIVE(n) n->state = ZEBRA_NEIGH_INACTIVE
	296
4122e252	297	/*
	298	* Neighbor hash table.
	299	*
	300	* This table contains the neighbors (IP to MAC bindings) pertaining to
	301	* this VNI. This includes local neighbors learnt on the attached VLAN
	302	* device that maps to this VNI as well as remote neighbors learnt and
	303	* installed by BGP.
	304	* Local neighbors will be known against the VLAN device (SVI); however,
	305	* it is sufficient for zebra to maintain against the VNI. The correct
	306	* VNI will be obtained as zebra maintains the mapping (of VLAN to VNI).
	307	*/
d62a17ae	308	struct zebra_neigh_t_ {
	309	/* IP address. */
	310	struct ipaddr ip;
4122e252	311
d62a17ae	312	/* MAC address. */
d62a17ae	313	struct ethaddr emac;
4122e252	314
d62a17ae	315	/* Underlying interface. */
d62a17ae	316	ifindex_t ifindex;
4122e252	317
d7c0a89a	318	uint32_t flags;
b6938a74 MK	319	#define ZEBRA_NEIGH_LOCAL 0x01
b6938a74 MK	320	#define ZEBRA_NEIGH_REMOTE 0x02
b7cfce93	321	#define ZEBRA_NEIGH_REMOTE_NH 0x04 /* neigh entry for remote vtep */
ead40654	322	#define ZEBRA_NEIGH_DEF_GW 0x08
b6938a74 MK	323
b6938a74 MK	324	enum zebra_neigh_state state;
4122e252	325
d62a17ae	326	/* Remote VTEP IP - applicable only for remote neighbors. */
d62a17ae	327	struct in_addr r_vtep_ip;
b7cfce93	328
6134fd82	329	/* list of hosts pointing to this remote NH entry */
6134fd82	330	struct list *host_list;
4122e252	331	};
	332
	333	/*
	334	* Context for neighbor hash walk - used by callbacks.
	335	*/
d62a17ae	336	struct neigh_walk_ctx {
	337	zebra_vni_t zvni; / VNI hash */
	338	struct zebra_vrf zvrf; / VRF - for client notification. */
	339	int uninstall; /* uninstall from kernel? */
	340	int upd_client; /* uninstall from client? */
	341
d7c0a89a	342	uint32_t flags;
4122e252	343	#define DEL_LOCAL_NEIGH 0x1
	344	#define DEL_REMOTE_NEIGH 0x2
	345	#define DEL_ALL_NEIGH (DEL_LOCAL_NEIGH \| DEL_REMOTE_NEIGH)
	346	#define DEL_REMOTE_NEIGH_FROM_VTEP 0x4
	347	#define SHOW_REMOTE_NEIGH_FROM_VTEP 0x8
	348
d62a17ae	349	struct in_addr r_vtep_ip; /* To walk neighbors from specific VTEP */
4122e252	350
cd233079	351	struct vty vty; / Used by VTY handlers */
d7c0a89a QY	352	uint32_t count; /* Used by VTY handlers */
d7c0a89a QY	353	uint8_t addr_width; /* Used by VTY handlers */
cd233079	354	struct json_object json; / Used for JSON Output */
18a7a601	355	};
18a7a601	356
b7cfce93 MK	357	/* context for neigh hash walk - update l3vni and rmac */
	358	struct neigh_l3info_walk_ctx {
	359
	360	zebra_vni_t *zvni;
	361	zebra_l3vni_t *zl3vni;
	362	int add;
	363	};
	364
	365	struct nh_walk_ctx {
	366
	367	struct vty *vty;
	368	struct json_object *json;
	369	};
	370
18a7a601	371	#endif /* _ZEBRA_VXLAN_PRIVATE_H */