[mirror_frr.git] / nhrpd / nhrpd.h

// SPDX-License-Identifier: GPL-2.0-or-later
/* NHRP daemon internal structures and function prototypes
 * Copyright (c) 2014-2015 Timo Teräs
 */

#ifndef NHRPD_H
#define NHRPD_H

#include "zbuf.h"
#include "zclient.h"
#include "debug.h"
#include "memory.h"
#include "resolver.h"

DECLARE_MGROUP(NHRPD);

#define NHRPD_DEFAULT_HOLDTIME	7200

#define NHRP_VTY_PORT		2610
#define NHRP_DEFAULT_CONFIG	"nhrpd.conf"

extern struct thread_master *master;

enum { NHRP_OK = 0,
       NHRP_ERR_FAIL,
       NHRP_ERR_NO_MEMORY,
       NHRP_ERR_UNSUPPORTED_INTERFACE,
       NHRP_ERR_NHRP_NOT_ENABLED,
       NHRP_ERR_ENTRY_EXISTS,
       NHRP_ERR_ENTRY_NOT_FOUND,
       NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH,
       __NHRP_ERR_MAX };
#define NHRP_ERR_MAX		(__NHRP_ERR_MAX - 1)

struct notifier_block;

typedef void (*notifier_fn_t)(struct notifier_block *, unsigned long);

PREDECL_DLIST(notifier_list);

struct notifier_block {
	struct notifier_list_item notifier_entry;
	notifier_fn_t action;
};

DECLARE_DLIST(notifier_list, struct notifier_block, notifier_entry);

struct notifier_list {
	struct notifier_list_head head;
};

#define NOTIFIER_LIST_INITIALIZER(l)                                           \
	{                                                                      \
		.head = INIT_DLIST((l)->head)                                  \
	}

static inline void notifier_init(struct notifier_list *l)
{
	notifier_list_init(&l->head);
}

static inline void notifier_add(struct notifier_block *n,
				struct notifier_list *l, notifier_fn_t action)
{
	n->action = action;
	notifier_list_add_tail(&l->head, n);
}

static inline void notifier_del(struct notifier_block *n,
				struct notifier_list *l)
{
	notifier_list_del(&l->head, n);
}

static inline void notifier_call(struct notifier_list *l, int cmd)
{
	struct notifier_block *n;

	frr_each_safe (notifier_list, &l->head, n)
		n->action(n, cmd);
}

static inline int notifier_active(struct notifier_list *l)
{
	return notifier_list_count(&l->head) > 0;
}

extern struct hash *nhrp_gre_list;

void nhrp_zebra_init(void);
void nhrp_zebra_terminate(void);
void nhrp_send_zebra_configure_arp(struct interface *ifp, int family);
void nhrp_send_zebra_nbr(union sockunion *in,
			 union sockunion *out,
			 struct interface *ifp);

void nhrp_send_zebra_gre_source_set(struct interface *ifp,
				    unsigned int link_idx,
				    vrf_id_t link_vrf_id);

extern int nhrp_send_zebra_gre_request(struct interface *ifp);
extern struct nhrp_gre_info *nhrp_gre_info_alloc(struct nhrp_gre_info *p);

struct zbuf;
struct nhrp_vc;
struct nhrp_cache;
struct nhrp_nhs;
struct nhrp_interface;

#define MAX_ID_LENGTH			64
#define MAX_CERT_LENGTH			2048

enum nhrp_notify_type {
	NOTIFY_INTERFACE_UP,
	NOTIFY_INTERFACE_DOWN,
	NOTIFY_INTERFACE_CHANGED,
	NOTIFY_INTERFACE_ADDRESS_CHANGED,
	NOTIFY_INTERFACE_NBMA_CHANGED,
	NOTIFY_INTERFACE_MTU_CHANGED,
	NOTIFY_INTERFACE_IPSEC_CHANGED,

	NOTIFY_VC_IPSEC_CHANGED,
	NOTIFY_VC_IPSEC_UPDATE_NBMA,

	NOTIFY_PEER_UP,
	NOTIFY_PEER_DOWN,
	NOTIFY_PEER_IFCONFIG_CHANGED,
	NOTIFY_PEER_MTU_CHANGED,
	NOTIFY_PEER_NBMA_CHANGING,

	NOTIFY_CACHE_UP,
	NOTIFY_CACHE_DOWN,
	NOTIFY_CACHE_DELETE,
	NOTIFY_CACHE_USED,
	NOTIFY_CACHE_BINDING_CHANGE,
};

struct nhrp_vc {
	struct notifier_list notifier_list;
	uint32_t ipsec;
	uint32_t ike_uniqueid;
	uint8_t updating;
	uint8_t abort_migration;

	struct nhrp_vc_peer {
		union sockunion nbma;
		char id[MAX_ID_LENGTH];
		uint16_t certlen;
		uint8_t cert[MAX_CERT_LENGTH];
	} local, remote;
};

enum nhrp_route_type {
	NHRP_ROUTE_BLACKHOLE,
	NHRP_ROUTE_LOCAL,
	NHRP_ROUTE_NBMA_NEXTHOP,
	NHRP_ROUTE_OFF_NBMA,
};

struct nhrp_peer {
	unsigned int ref;
	unsigned online : 1;
	unsigned requested : 1;
	unsigned fallback_requested : 1;
	unsigned prio : 1;
	struct notifier_list notifier_list;
	struct interface *ifp;
	struct nhrp_vc *vc;
	struct thread *t_fallback;
	struct notifier_block vc_notifier, ifp_notifier;
	struct thread *t_timer;
};

struct nhrp_packet_parser {
	struct interface *ifp;
	struct nhrp_afi_data *if_ad;
	struct nhrp_peer *peer;
	struct zbuf *pkt;
	struct zbuf payload;
	struct zbuf extensions;
	struct nhrp_packet_header *hdr;
	enum nhrp_route_type route_type;
	struct prefix route_prefix;
	union sockunion src_nbma, src_proto, dst_proto;
};

struct nhrp_reqid_pool {
	struct hash *reqid_hash;
	uint32_t next_request_id;
};

struct nhrp_reqid {
	uint32_t request_id;
	void (*cb)(struct nhrp_reqid *, void *);
};

extern struct nhrp_reqid_pool nhrp_packet_reqid;
extern struct nhrp_reqid_pool nhrp_event_reqid;

enum nhrp_cache_type {
	NHRP_CACHE_INVALID = 0,
	NHRP_CACHE_INCOMPLETE,
	NHRP_CACHE_NEGATIVE,
	NHRP_CACHE_CACHED,
	NHRP_CACHE_DYNAMIC,
	NHRP_CACHE_NHS,
	NHRP_CACHE_STATIC,
	NHRP_CACHE_LOCAL,
	NHRP_CACHE_NUM_TYPES
};

extern const char *const nhrp_cache_type_str[];
extern unsigned long nhrp_cache_counts[NHRP_CACHE_NUM_TYPES];

struct nhrp_cache_config {
	struct interface *ifp;
	union sockunion remote_addr;
	enum nhrp_cache_type type;
	union sockunion nbma;
};

struct nhrp_cache {
	struct interface *ifp;
	union sockunion remote_addr;

	unsigned map : 1;
	unsigned used : 1;
	unsigned route_installed : 1;
	unsigned nhrp_route_installed : 1;

	struct notifier_block peer_notifier;
	struct notifier_block newpeer_notifier;
	struct notifier_list notifier_list;
	struct nhrp_reqid eventid;
	struct thread *t_timeout;
	struct thread *t_auth;

	struct {
		enum nhrp_cache_type type;
		union sockunion remote_nbma_natoa;
		union sockunion remote_nbma_claimed;
		struct nhrp_peer *peer;
		time_t expires;
		uint32_t mtu;
		int holding_time;
	} cur, new;
};

struct nhrp_shortcut {
	struct prefix *p;
	union sockunion addr;

	struct nhrp_reqid reqid;
	struct thread *t_timer;

	enum nhrp_cache_type type;
	unsigned int holding_time;
	unsigned route_installed : 1;
	unsigned expiring : 1;

	struct nhrp_cache *cache;
	struct notifier_block cache_notifier;
};

PREDECL_DLIST(nhrp_nhslist);
PREDECL_DLIST(nhrp_mcastlist);
PREDECL_DLIST(nhrp_reglist);

struct nhrp_nhs {
	struct interface *ifp;
	struct nhrp_nhslist_item nhslist_entry;

	unsigned hub : 1;
	afi_t afi;
	union sockunion proto_addr;
	const char *nbma_fqdn; /* IP-address or FQDN */

	struct thread *t_resolve;
	struct resolver_query dns_resolve;
	struct nhrp_reglist_head reglist_head;
};

DECLARE_DLIST(nhrp_nhslist, struct nhrp_nhs, nhslist_entry);

struct nhrp_multicast {
	struct interface *ifp;
	struct nhrp_mcastlist_item mcastlist_entry;
	afi_t afi;
	union sockunion nbma_addr; /* IP-address */
};

DECLARE_DLIST(nhrp_mcastlist, struct nhrp_multicast, mcastlist_entry);

struct nhrp_registration {
	struct nhrp_reglist_item reglist_entry;
	struct thread *t_register;
	struct nhrp_nhs *nhs;
	struct nhrp_reqid reqid;
	unsigned int timeout;
	unsigned mark : 1;
	union sockunion proto_addr;
	struct nhrp_peer *peer;
	struct notifier_block peer_notifier;
};

DECLARE_DLIST(nhrp_reglist, struct nhrp_registration, reglist_entry);

#define NHRP_IFF_SHORTCUT		0x0001
#define NHRP_IFF_REDIRECT		0x0002
#define NHRP_IFF_REG_NO_UNIQUE		0x0100

struct nhrp_interface {
	struct interface *ifp;

	unsigned enabled : 1;

	char *ipsec_profile, *ipsec_fallback_profile, *source;
	union sockunion nbma;
	union sockunion nat_nbma;
	unsigned int link_idx;
	unsigned int link_vrf_id;
	uint32_t i_grekey;
	uint32_t o_grekey;

	struct hash *peer_hash;
	struct hash *cache_config_hash;
	struct hash *cache_hash;

	struct notifier_list notifier_list;

	struct interface *nbmaifp;
	struct notifier_block nbmanifp_notifier;

	struct nhrp_afi_data {
		unsigned flags;
		unsigned short configured : 1;
		union sockunion addr;
		uint32_t network_id;
		short configured_mtu;
		unsigned short mtu;
		unsigned int holdtime;
		struct nhrp_nhslist_head nhslist_head;
		struct nhrp_mcastlist_head mcastlist_head;
	} afi[AFI_MAX];
};

struct nhrp_gre_info {
	ifindex_t ifindex;
	struct in_addr vtep_ip; /* IFLA_GRE_LOCAL */
	struct in_addr vtep_ip_remote; /* IFLA_GRE_REMOTE */
	uint32_t ikey;
	uint32_t okey;
	ifindex_t ifindex_link; /* Interface index of interface
				 * linked with GRE
				 */
	vrf_id_t vrfid_link;
};

extern struct zebra_privs_t nhrpd_privs;

int sock_open_unix(const char *path);

void nhrp_interface_init(void);
void nhrp_interface_update(struct interface *ifp);
void nhrp_interface_update_mtu(struct interface *ifp, afi_t afi);
void nhrp_interface_update_nbma(struct interface *ifp,
				struct nhrp_gre_info *gre_info);

int nhrp_interface_add(ZAPI_CALLBACK_ARGS);
int nhrp_interface_delete(ZAPI_CALLBACK_ARGS);
int nhrp_interface_up(ZAPI_CALLBACK_ARGS);
int nhrp_interface_down(ZAPI_CALLBACK_ARGS);
int nhrp_interface_address_add(ZAPI_CALLBACK_ARGS);
int nhrp_interface_address_delete(ZAPI_CALLBACK_ARGS);
int nhrp_neighbor_operation(ZAPI_CALLBACK_ARGS);
int nhrp_gre_update(ZAPI_CALLBACK_ARGS);

void nhrp_interface_notify_add(struct interface *ifp, struct notifier_block *n,
			       notifier_fn_t fn);
void nhrp_interface_notify_del(struct interface *ifp, struct notifier_block *n);
void nhrp_interface_set_protection(struct interface *ifp, const char *profile,
				   const char *fallback_profile);
void nhrp_interface_set_source(struct interface *ifp, const char *ifname);
extern int nhrp_ifp_create(struct interface *ifp);
extern int nhrp_ifp_up(struct interface *ifp);
extern int nhrp_ifp_down(struct interface *ifp);
extern int nhrp_ifp_destroy(struct interface *ifp);

int nhrp_nhs_add(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
		 const char *nbma_fqdn);
int nhrp_nhs_del(struct interface *ifp, afi_t afi, union sockunion *proto_addr,
		 const char *nbma_fqdn);
int nhrp_nhs_free(struct nhrp_interface *nifp, afi_t afi, struct nhrp_nhs *nhs);
void nhrp_nhs_terminate(void);
void nhrp_nhs_foreach(struct interface *ifp, afi_t afi,
		      void (*cb)(struct nhrp_nhs *, struct nhrp_registration *,
				 void *),
		      void *ctx);
void nhrp_nhs_interface_del(struct interface *ifp);

int nhrp_multicast_add(struct interface *ifp, afi_t afi,
		       union sockunion *nbma_addr);
int nhrp_multicast_del(struct interface *ifp, afi_t afi,
		       union sockunion *nbma_addr);
void nhrp_multicast_interface_del(struct interface *ifp);
void nhrp_multicast_foreach(struct interface *ifp, afi_t afi,
			    void (*cb)(struct nhrp_multicast *, void *),
			    void *ctx);
void netlink_mcast_set_nflog_group(int nlgroup);

void nhrp_route_update_nhrp(const struct prefix *p, struct interface *ifp);
void nhrp_route_announce(int add, enum nhrp_cache_type type,
			 const struct prefix *p, struct interface *ifp,
			 const union sockunion *nexthop, uint32_t mtu);
int nhrp_route_read(ZAPI_CALLBACK_ARGS);
int nhrp_route_get_nexthop(const union sockunion *addr, struct prefix *p,
			   union sockunion *via, struct interface **ifp);
enum nhrp_route_type nhrp_route_address(struct interface *in_ifp,
					union sockunion *addr, struct prefix *p,
					struct nhrp_peer **peer);

void nhrp_config_init(void);

void nhrp_shortcut_init(void);
void nhrp_shortcut_terminate(void);
void nhrp_shortcut_initiate(union sockunion *addr);
void nhrp_shortcut_foreach(afi_t afi,
			   void (*cb)(struct nhrp_shortcut *, void *),
			   void *ctx);
void nhrp_shortcut_purge(struct nhrp_shortcut *s, int force);
void nhrp_shortcut_prefix_change(const struct prefix *p, int deleted);

void nhrp_cache_interface_del(struct interface *ifp);
void nhrp_cache_config_free(struct nhrp_cache_config *c);
struct nhrp_cache_config *nhrp_cache_config_get(struct interface *ifp,
						union sockunion *remote_addr,
						int create);
struct nhrp_cache *nhrp_cache_get(struct interface *ifp,
				  union sockunion *remote_addr, int create);
void nhrp_cache_foreach(struct interface *ifp,
			void (*cb)(struct nhrp_cache *, void *), void *ctx);
void nhrp_cache_config_foreach(struct interface *ifp,
			       void (*cb)(struct nhrp_cache_config *, void *), void *ctx);
void nhrp_cache_set_used(struct nhrp_cache *, int);
int nhrp_cache_update_binding(struct nhrp_cache *, enum nhrp_cache_type type,
			      int holding_time, struct nhrp_peer *p,
			      uint32_t mtu, union sockunion *nbma_natoa,
			      union sockunion *claimed_nbma);
void nhrp_cache_notify_add(struct nhrp_cache *c, struct notifier_block *,
			   notifier_fn_t);
void nhrp_cache_notify_del(struct nhrp_cache *c, struct notifier_block *);

void nhrp_vc_init(void);
void nhrp_vc_terminate(void);
struct nhrp_vc *nhrp_vc_get(const union sockunion *src,
			    const union sockunion *dst, int create);
int nhrp_vc_ipsec_updown(uint32_t child_id, struct nhrp_vc *vc);
void nhrp_vc_notify_add(struct nhrp_vc *, struct notifier_block *,
			notifier_fn_t);
void nhrp_vc_notify_del(struct nhrp_vc *, struct notifier_block *);
void nhrp_vc_foreach(void (*cb)(struct nhrp_vc *, void *), void *ctx);
void nhrp_vc_reset(void);

void vici_init(void);
void vici_terminate(void);
void vici_terminate_vc_by_profile_name(char *profile_name);
void vici_terminate_vc_by_ike_id(unsigned int ike_id);
void vici_request_vc(const char *profile, union sockunion *src,
		     union sockunion *dst, int prio);

extern const char *nhrp_event_socket_path;

void evmgr_init(void);
void evmgr_terminate(void);
void evmgr_set_socket(const char *socket);
void evmgr_notify(const char *name, struct nhrp_cache *c,
		  void (*cb)(struct nhrp_reqid *, void *));

struct nhrp_packet_header *nhrp_packet_push(struct zbuf *zb, uint8_t type,
					    const union sockunion *src_nbma,
					    const union sockunion *src_proto,
					    const union sockunion *dst_proto);
void nhrp_packet_complete(struct zbuf *zb, struct nhrp_packet_header *hdr);
uint16_t nhrp_packet_calculate_checksum(const uint8_t *pdu, uint16_t len);

struct nhrp_packet_header *nhrp_packet_pull(struct zbuf *zb,
					    union sockunion *src_nbma,
					    union sockunion *src_proto,
					    union sockunion *dst_proto);

struct nhrp_cie_header *nhrp_cie_push(struct zbuf *zb, uint8_t code,
				      const union sockunion *nbma,
				      const union sockunion *proto);
struct nhrp_cie_header *nhrp_cie_pull(struct zbuf *zb,
				      struct nhrp_packet_header *hdr,
				      union sockunion *nbma,
				      union sockunion *proto);

struct nhrp_extension_header *
nhrp_ext_push(struct zbuf *zb, struct nhrp_packet_header *hdr, uint16_t type);
void nhrp_ext_complete(struct zbuf *zb, struct nhrp_extension_header *ext);
struct nhrp_extension_header *nhrp_ext_pull(struct zbuf *zb,
					    struct zbuf *payload);
void nhrp_ext_request(struct zbuf *zb, struct nhrp_packet_header *hdr,
		      struct interface *);
int nhrp_ext_reply(struct zbuf *zb, struct nhrp_packet_header *hdr,
		   struct interface *ifp, struct nhrp_extension_header *ext,
		   struct zbuf *extpayload);

uint32_t nhrp_reqid_alloc(struct nhrp_reqid_pool *, struct nhrp_reqid *r,
			  void (*cb)(struct nhrp_reqid *, void *));
void nhrp_reqid_free(struct nhrp_reqid_pool *, struct nhrp_reqid *r);
struct nhrp_reqid *nhrp_reqid_lookup(struct nhrp_reqid_pool *, uint32_t reqid);

int nhrp_packet_init(void);

void nhrp_peer_interface_del(struct interface *ifp);
struct nhrp_peer *nhrp_peer_get(struct interface *ifp,
				const union sockunion *remote_nbma);
struct nhrp_peer *nhrp_peer_ref(struct nhrp_peer *p);
void nhrp_peer_unref(struct nhrp_peer *p);
int nhrp_peer_check(struct nhrp_peer *p, int establish);
void nhrp_peer_notify_add(struct nhrp_peer *p, struct notifier_block *,
			  notifier_fn_t);
void nhrp_peer_notify_del(struct nhrp_peer *p, struct notifier_block *);
void nhrp_peer_recv(struct nhrp_peer *p, struct zbuf *zb);
void nhrp_peer_send(struct nhrp_peer *p, struct zbuf *zb);
void nhrp_peer_send_indication(struct interface *ifp, uint16_t, struct zbuf *);

int nhrp_nhs_match_ip(union sockunion *in_ip, struct nhrp_interface *nifp);

#endif
Commit	Line	Data
acddc0ed	1	// SPDX-License-Identifier: GPL-2.0-or-later
2fb975da TT	2	/* NHRP daemon internal structures and function prototypes
2fb975da TT	3	* Copyright (c) 2014-2015 Timo Teräs
2fb975da TT	4	*/
	5
	6	#ifndef NHRPD_H
	7	#define NHRPD_H
	8
2fb975da TT	9	#include "zbuf.h"
	10	#include "zclient.h"
	11	#include "debug.h"
819dc8bb	12	#include "memory.h"
fe9e7b71	13	#include "resolver.h"
819dc8bb	14
bf8d3d6a	15	DECLARE_MGROUP(NHRPD);
2fb975da TT	16
	17	#define NHRPD_DEFAULT_HOLDTIME 7200
	18
442deed8	19	#define NHRP_VTY_PORT 2610
2fb975da TT	20	#define NHRP_DEFAULT_CONFIG "nhrpd.conf"
	21
	22	extern struct thread_master *master;
	23
996c9314 LB	24	enum { NHRP_OK = 0,
	25	NHRP_ERR_FAIL,
	26	NHRP_ERR_NO_MEMORY,
	27	NHRP_ERR_UNSUPPORTED_INTERFACE,
	28	NHRP_ERR_NHRP_NOT_ENABLED,
	29	NHRP_ERR_ENTRY_EXISTS,
	30	NHRP_ERR_ENTRY_NOT_FOUND,
	31	NHRP_ERR_PROTOCOL_ADDRESS_MISMATCH,
	32	__NHRP_ERR_MAX };
6c8ca260	33	#define NHRP_ERR_MAX (__NHRP_ERR_MAX - 1)
2fb975da TT	34
	35	struct notifier_block;
	36
	37	typedef void (notifier_fn_t)(struct notifier_block , unsigned long);
	38
865bf787 DL	39	PREDECL_DLIST(notifier_list);
865bf787 DL	40
2fb975da	41	struct notifier_block {
865bf787	42	struct notifier_list_item notifier_entry;
2fb975da TT	43	notifier_fn_t action;
	44	};
	45
865bf787 DL	46	DECLARE_DLIST(notifier_list, struct notifier_block, notifier_entry);
865bf787 DL	47
2fb975da	48	struct notifier_list {
865bf787	49	struct notifier_list_head head;
2fb975da TT	50	};
2fb975da TT	51
996c9314 LB	52	#define NOTIFIER_LIST_INITIALIZER(l) \
996c9314 LB	53	{ \
865bf787	54	.head = INIT_DLIST((l)->head) \
996c9314	55	}
2fb975da TT	56
	57	static inline void notifier_init(struct notifier_list *l)
	58	{
865bf787	59	notifier_list_init(&l->head);
2fb975da TT	60	}
2fb975da TT	61
996c9314 LB	62	static inline void notifier_add(struct notifier_block *n,
996c9314 LB	63	struct notifier_list *l, notifier_fn_t action)
2fb975da TT	64	{
2fb975da TT	65	n->action = action;
865bf787	66	notifier_list_add_tail(&l->head, n);
2fb975da TT	67	}
2fb975da TT	68
865bf787 DL	69	static inline void notifier_del(struct notifier_block *n,
865bf787 DL	70	struct notifier_list *l)
2fb975da	71	{
865bf787	72	notifier_list_del(&l->head, n);
2fb975da TT	73	}
	74
	75	static inline void notifier_call(struct notifier_list *l, int cmd)
	76	{
865bf787 DL	77	struct notifier_block *n;
	78
	79	frr_each_safe (notifier_list, &l->head, n)
123ea351	80	n->action(n, cmd);
2fb975da TT	81	}
	82
	83	static inline int notifier_active(struct notifier_list *l)
	84	{
865bf787	85	return notifier_list_count(&l->head) > 0;
2fb975da TT	86	}
2fb975da TT	87
7f48cfa5 PG	88	extern struct hash *nhrp_gre_list;
7f48cfa5 PG	89
2fb975da TT	90	void nhrp_zebra_init(void);
2fb975da TT	91	void nhrp_zebra_terminate(void);
f468a45a	92	void nhrp_send_zebra_configure_arp(struct interface *ifp, int family);
05657ec2 PG	93	void nhrp_send_zebra_nbr(union sockunion *in,
	94	union sockunion *out,
	95	struct interface *ifp);
7f48cfa5 PG	96
	97	void nhrp_send_zebra_gre_source_set(struct interface *ifp,
	98	unsigned int link_idx,
	99	vrf_id_t link_vrf_id);
	100
	101	extern int nhrp_send_zebra_gre_request(struct interface *ifp);
	102	extern struct nhrp_gre_info nhrp_gre_info_alloc(struct nhrp_gre_info p);
	103
2fb975da TT	104	struct zbuf;
	105	struct nhrp_vc;
	106	struct nhrp_cache;
	107	struct nhrp_nhs;
	108	struct nhrp_interface;
	109
	110	#define MAX_ID_LENGTH 64
	111	#define MAX_CERT_LENGTH 2048
	112
	113	enum nhrp_notify_type {
	114	NOTIFY_INTERFACE_UP,
	115	NOTIFY_INTERFACE_DOWN,
	116	NOTIFY_INTERFACE_CHANGED,
	117	NOTIFY_INTERFACE_ADDRESS_CHANGED,
	118	NOTIFY_INTERFACE_NBMA_CHANGED,
	119	NOTIFY_INTERFACE_MTU_CHANGED,
58ef1668	120	NOTIFY_INTERFACE_IPSEC_CHANGED,
2fb975da TT	121
	122	NOTIFY_VC_IPSEC_CHANGED,
	123	NOTIFY_VC_IPSEC_UPDATE_NBMA,
	124
	125	NOTIFY_PEER_UP,
	126	NOTIFY_PEER_DOWN,
	127	NOTIFY_PEER_IFCONFIG_CHANGED,
	128	NOTIFY_PEER_MTU_CHANGED,
	129	NOTIFY_PEER_NBMA_CHANGING,
	130
	131	NOTIFY_CACHE_UP,
	132	NOTIFY_CACHE_DOWN,
	133	NOTIFY_CACHE_DELETE,
	134	NOTIFY_CACHE_USED,
	135	NOTIFY_CACHE_BINDING_CHANGE,
	136	};
	137
	138	struct nhrp_vc {
	139	struct notifier_list notifier_list;
6cfd90f3	140	uint32_t ipsec;
4cbaf956	141	uint32_t ike_uniqueid;
2fb975da TT	142	uint8_t updating;
	143	uint8_t abort_migration;
	144
	145	struct nhrp_vc_peer {
	146	union sockunion nbma;
	147	char id[MAX_ID_LENGTH];
	148	uint16_t certlen;
	149	uint8_t cert[MAX_CERT_LENGTH];
	150	} local, remote;
	151	};
	152
	153	enum nhrp_route_type {
	154	NHRP_ROUTE_BLACKHOLE,
	155	NHRP_ROUTE_LOCAL,
	156	NHRP_ROUTE_NBMA_NEXTHOP,
	157	NHRP_ROUTE_OFF_NBMA,
	158	};
	159
	160	struct nhrp_peer {
	161	unsigned int ref;
	162	unsigned online : 1;
	163	unsigned requested : 1;
	164	unsigned fallback_requested : 1;
	165	unsigned prio : 1;
	166	struct notifier_list notifier_list;
	167	struct interface *ifp;
	168	struct nhrp_vc *vc;
	169	struct thread *t_fallback;
	170	struct notifier_block vc_notifier, ifp_notifier;
bb58f442	171	struct thread *t_timer;
2fb975da TT	172	};
	173
	174	struct nhrp_packet_parser {
	175	struct interface *ifp;
	176	struct nhrp_afi_data *if_ad;
	177	struct nhrp_peer *peer;
	178	struct zbuf *pkt;
	179	struct zbuf payload;
	180	struct zbuf extensions;
	181	struct nhrp_packet_header *hdr;
	182	enum nhrp_route_type route_type;
	183	struct prefix route_prefix;
	184	union sockunion src_nbma, src_proto, dst_proto;
	185	};
	186
	187	struct nhrp_reqid_pool {
	188	struct hash *reqid_hash;
	189	uint32_t next_request_id;
	190	};
	191
	192	struct nhrp_reqid {
	193	uint32_t request_id;
	194	void (cb)(struct nhrp_reqid , void *);
	195	};
	196
	197	extern struct nhrp_reqid_pool nhrp_packet_reqid;
	198	extern struct nhrp_reqid_pool nhrp_event_reqid;
	199
	200	enum nhrp_cache_type {
	201	NHRP_CACHE_INVALID = 0,
	202	NHRP_CACHE_INCOMPLETE,
	203	NHRP_CACHE_NEGATIVE,
	204	NHRP_CACHE_CACHED,
	205	NHRP_CACHE_DYNAMIC,
	206	NHRP_CACHE_NHS,
	207	NHRP_CACHE_STATIC,
	208	NHRP_CACHE_LOCAL,
	209	NHRP_CACHE_NUM_TYPES
	210	};
	211
996c9314	212	extern const char *const nhrp_cache_type_str[];
2fb975da TT	213	extern unsigned long nhrp_cache_counts[NHRP_CACHE_NUM_TYPES];
2fb975da TT	214
fef2ed13 PG	215	struct nhrp_cache_config {
	216	struct interface *ifp;
	217	union sockunion remote_addr;
	218	enum nhrp_cache_type type;
	219	union sockunion nbma;
	220	};
	221
2fb975da TT	222	struct nhrp_cache {
	223	struct interface *ifp;
	224	union sockunion remote_addr;
	225
	226	unsigned map : 1;
	227	unsigned used : 1;
	228	unsigned route_installed : 1;
	229	unsigned nhrp_route_installed : 1;
	230
	231	struct notifier_block peer_notifier;
	232	struct notifier_block newpeer_notifier;
	233	struct notifier_list notifier_list;
	234	struct nhrp_reqid eventid;
	235	struct thread *t_timeout;
	236	struct thread *t_auth;
	237
	238	struct {
	239	enum nhrp_cache_type type;
	240	union sockunion remote_nbma_natoa;
85365e51	241	union sockunion remote_nbma_claimed;
2fb975da TT	242	struct nhrp_peer *peer;
	243	time_t expires;
	244	uint32_t mtu;
bb58f442	245	int holding_time;
2fb975da TT	246	} cur, new;
	247	};
	248
	249	struct nhrp_shortcut {
	250	struct prefix *p;
	251	union sockunion addr;
	252
	253	struct nhrp_reqid reqid;
	254	struct thread *t_timer;
	255
	256	enum nhrp_cache_type type;
	257	unsigned int holding_time;
	258	unsigned route_installed : 1;
	259	unsigned expiring : 1;
	260
	261	struct nhrp_cache *cache;
	262	struct notifier_block cache_notifier;
	263	};
	264
2ab2a761	265	PREDECL_DLIST(nhrp_nhslist);
db4db2bb	266	PREDECL_DLIST(nhrp_mcastlist);
811de44f	267	PREDECL_DLIST(nhrp_reglist);
2ab2a761	268
2fb975da TT	269	struct nhrp_nhs {
2fb975da TT	270	struct interface *ifp;
2ab2a761	271	struct nhrp_nhslist_item nhslist_entry;
2fb975da TT	272
	273	unsigned hub : 1;
	274	afi_t afi;
	275	union sockunion proto_addr;
996c9314	276	const char nbma_fqdn; / IP-address or FQDN */
2fb975da TT	277
	278	struct thread *t_resolve;
	279	struct resolver_query dns_resolve;
811de44f	280	struct nhrp_reglist_head reglist_head;
2fb975da TT	281	};
2fb975da TT	282
2ab2a761 DL	283	DECLARE_DLIST(nhrp_nhslist, struct nhrp_nhs, nhslist_entry);
2ab2a761 DL	284
fa31fcf2 AL	285	struct nhrp_multicast {
fa31fcf2 AL	286	struct interface *ifp;
db4db2bb	287	struct nhrp_mcastlist_item mcastlist_entry;
fa31fcf2 AL	288	afi_t afi;
	289	union sockunion nbma_addr; /* IP-address */
	290	};
	291
db4db2bb DL	292	DECLARE_DLIST(nhrp_mcastlist, struct nhrp_multicast, mcastlist_entry);
db4db2bb DL	293
0ca036b4	294	struct nhrp_registration {
811de44f	295	struct nhrp_reglist_item reglist_entry;
0ca036b4 TT	296	struct thread *t_register;
	297	struct nhrp_nhs *nhs;
	298	struct nhrp_reqid reqid;
	299	unsigned int timeout;
	300	unsigned mark : 1;
	301	union sockunion proto_addr;
	302	struct nhrp_peer *peer;
	303	struct notifier_block peer_notifier;
	304	};
	305
811de44f DL	306	DECLARE_DLIST(nhrp_reglist, struct nhrp_registration, reglist_entry);
811de44f DL	307
2fb975da TT	308	#define NHRP_IFF_SHORTCUT 0x0001
	309	#define NHRP_IFF_REDIRECT 0x0002
	310	#define NHRP_IFF_REG_NO_UNIQUE 0x0100
	311
	312	struct nhrp_interface {
	313	struct interface *ifp;
	314
	315	unsigned enabled : 1;
	316
	317	char ipsec_profile, ipsec_fallback_profile, *source;
	318	union sockunion nbma;
	319	union sockunion nat_nbma;
7f48cfa5 PG	320	unsigned int link_idx;
	321	unsigned int link_vrf_id;
	322	uint32_t i_grekey;
	323	uint32_t o_grekey;
2fb975da TT	324
2fb975da TT	325	struct hash *peer_hash;
fef2ed13	326	struct hash *cache_config_hash;
2fb975da TT	327	struct hash *cache_hash;
	328
	329	struct notifier_list notifier_list;
	330
	331	struct interface *nbmaifp;
	332	struct notifier_block nbmanifp_notifier;
	333
	334	struct nhrp_afi_data {
	335	unsigned flags;
	336	unsigned short configured : 1;
	337	union sockunion addr;
	338	uint32_t network_id;
	339	short configured_mtu;
	340	unsigned short mtu;
	341	unsigned int holdtime;
2ab2a761	342	struct nhrp_nhslist_head nhslist_head;
db4db2bb	343	struct nhrp_mcastlist_head mcastlist_head;
2fb975da TT	344	} afi[AFI_MAX];
	345	};
	346
7f48cfa5 PG	347	struct nhrp_gre_info {
	348	ifindex_t ifindex;
	349	struct in_addr vtep_ip; /* IFLA_GRE_LOCAL */
	350	struct in_addr vtep_ip_remote; /* IFLA_GRE_REMOTE */
	351	uint32_t ikey;
	352	uint32_t okey;
	353	ifindex_t ifindex_link; /* Interface index of interface
	354	* linked with GRE
	355	*/
	356	vrf_id_t vrfid_link;
	357	};
	358
26efbc7b DS	359	extern struct zebra_privs_t nhrpd_privs;
26efbc7b DS	360
2fb975da TT	361	int sock_open_unix(const char *path);
	362
	363	void nhrp_interface_init(void);
	364	void nhrp_interface_update(struct interface *ifp);
	365	void nhrp_interface_update_mtu(struct interface *ifp, afi_t afi);
7f48cfa5 PG	366	void nhrp_interface_update_nbma(struct interface *ifp,
7f48cfa5 PG	367	struct nhrp_gre_info *gre_info);
2fb975da	368
121f9dee QY	369	int nhrp_interface_add(ZAPI_CALLBACK_ARGS);
	370	int nhrp_interface_delete(ZAPI_CALLBACK_ARGS);
	371	int nhrp_interface_up(ZAPI_CALLBACK_ARGS);
	372	int nhrp_interface_down(ZAPI_CALLBACK_ARGS);
	373	int nhrp_interface_address_add(ZAPI_CALLBACK_ARGS);
	374	int nhrp_interface_address_delete(ZAPI_CALLBACK_ARGS);
a243d1db DL	375	int nhrp_neighbor_operation(ZAPI_CALLBACK_ARGS);
a243d1db DL	376	int nhrp_gre_update(ZAPI_CALLBACK_ARGS);
996c9314 LB	377
	378	void nhrp_interface_notify_add(struct interface ifp, struct notifier_block n,
	379	notifier_fn_t fn);
2fb975da	380	void nhrp_interface_notify_del(struct interface ifp, struct notifier_block n);
996c9314 LB	381	void nhrp_interface_set_protection(struct interface ifp, const char profile,
996c9314 LB	382	const char *fallback_profile);
2fb975da	383	void nhrp_interface_set_source(struct interface ifp, const char ifname);
138c5a74 DS	384	extern int nhrp_ifp_create(struct interface *ifp);
	385	extern int nhrp_ifp_up(struct interface *ifp);
	386	extern int nhrp_ifp_down(struct interface *ifp);
	387	extern int nhrp_ifp_destroy(struct interface *ifp);
2fb975da	388
996c9314 LB	389	int nhrp_nhs_add(struct interface ifp, afi_t afi, union sockunion proto_addr,
	390	const char *nbma_fqdn);
	391	int nhrp_nhs_del(struct interface ifp, afi_t afi, union sockunion proto_addr,
	392	const char *nbma_fqdn);
2ab2a761	393	int nhrp_nhs_free(struct nhrp_interface nifp, afi_t afi, struct nhrp_nhs nhs);
2fb975da	394	void nhrp_nhs_terminate(void);
996c9314 LB	395	void nhrp_nhs_foreach(struct interface *ifp, afi_t afi,
	396	void (cb)(struct nhrp_nhs , struct nhrp_registration *,
	397	void *),
	398	void *ctx);
ee72f0a0	399	void nhrp_nhs_interface_del(struct interface *ifp);
2fb975da	400
0f8595a9 RD	401	int nhrp_multicast_add(struct interface *ifp, afi_t afi,
	402	union sockunion *nbma_addr);
	403	int nhrp_multicast_del(struct interface *ifp, afi_t afi,
	404	union sockunion *nbma_addr);
fa31fcf2 AL	405	void nhrp_multicast_interface_del(struct interface *ifp);
fa31fcf2 AL	406	void nhrp_multicast_foreach(struct interface *ifp, afi_t afi,
0f8595a9 RD	407	void (cb)(struct nhrp_multicast , void *),
0f8595a9 RD	408	void *ctx);
9084e209	409	void netlink_mcast_set_nflog_group(int nlgroup);
fa31fcf2	410
2fb975da	411	void nhrp_route_update_nhrp(const struct prefix p, struct interface ifp);
996c9314 LB	412	void nhrp_route_announce(int add, enum nhrp_cache_type type,
	413	const struct prefix p, struct interface ifp,
	414	const union sockunion *nexthop, uint32_t mtu);
121f9dee	415	int nhrp_route_read(ZAPI_CALLBACK_ARGS);
996c9314 LB	416	int nhrp_route_get_nexthop(const union sockunion addr, struct prefix p,
	417	union sockunion via, struct interface *ifp);
	418	enum nhrp_route_type nhrp_route_address(struct interface *in_ifp,
	419	union sockunion addr, struct prefix p,
	420	struct nhrp_peer **peer);
2fb975da TT	421
	422	void nhrp_config_init(void);
	423
	424	void nhrp_shortcut_init(void);
	425	void nhrp_shortcut_terminate(void);
	426	void nhrp_shortcut_initiate(union sockunion *addr);
996c9314 LB	427	void nhrp_shortcut_foreach(afi_t afi,
	428	void (cb)(struct nhrp_shortcut , void *),
	429	void *ctx);
2fb975da TT	430	void nhrp_shortcut_purge(struct nhrp_shortcut *s, int force);
	431	void nhrp_shortcut_prefix_change(const struct prefix *p, int deleted);
	432
ee72f0a0	433	void nhrp_cache_interface_del(struct interface *ifp);
fef2ed13 PG	434	void nhrp_cache_config_free(struct nhrp_cache_config *c);
	435	struct nhrp_cache_config nhrp_cache_config_get(struct interface ifp,
	436	union sockunion *remote_addr,
	437	int create);
996c9314 LB	438	struct nhrp_cache nhrp_cache_get(struct interface ifp,
	439	union sockunion *remote_addr, int create);
	440	void nhrp_cache_foreach(struct interface *ifp,
	441	void (cb)(struct nhrp_cache , void ), void ctx);
fef2ed13 PG	442	void nhrp_cache_config_foreach(struct interface *ifp,
fef2ed13 PG	443	void (cb)(struct nhrp_cache_config , void ), void ctx);
2fb975da	444	void nhrp_cache_set_used(struct nhrp_cache *, int);
996c9314 LB	445	int nhrp_cache_update_binding(struct nhrp_cache *, enum nhrp_cache_type type,
996c9314 LB	446	int holding_time, struct nhrp_peer *p,
85365e51 AL	447	uint32_t mtu, union sockunion *nbma_natoa,
85365e51 AL	448	union sockunion *claimed_nbma);
996c9314 LB	449	void nhrp_cache_notify_add(struct nhrp_cache c, struct notifier_block ,
996c9314 LB	450	notifier_fn_t);
2fb975da TT	451	void nhrp_cache_notify_del(struct nhrp_cache c, struct notifier_block );
	452
	453	void nhrp_vc_init(void);
	454	void nhrp_vc_terminate(void);
996c9314 LB	455	struct nhrp_vc nhrp_vc_get(const union sockunion src,
996c9314 LB	456	const union sockunion *dst, int create);
2fb975da	457	int nhrp_vc_ipsec_updown(uint32_t child_id, struct nhrp_vc *vc);
996c9314 LB	458	void nhrp_vc_notify_add(struct nhrp_vc , struct notifier_block ,
996c9314 LB	459	notifier_fn_t);
2fb975da TT	460	void nhrp_vc_notify_del(struct nhrp_vc , struct notifier_block );
	461	void nhrp_vc_foreach(void (cb)(struct nhrp_vc , void ), void ctx);
	462	void nhrp_vc_reset(void);
	463
	464	void vici_init(void);
	465	void vici_terminate(void);
083bbfae GG	466	void vici_terminate_vc_by_profile_name(char *profile_name);
083bbfae GG	467	void vici_terminate_vc_by_ike_id(unsigned int ike_id);
996c9314 LB	468	void vici_request_vc(const char profile, union sockunion src,
996c9314 LB	469	union sockunion *dst, int prio);
2fb975da TT	470
	471	extern const char *nhrp_event_socket_path;
	472
	473	void evmgr_init(void);
	474	void evmgr_terminate(void);
	475	void evmgr_set_socket(const char *socket);
996c9314 LB	476	void evmgr_notify(const char name, struct nhrp_cache c,
996c9314 LB	477	void (cb)(struct nhrp_reqid , void *));
2fb975da	478
996c9314 LB	479	struct nhrp_packet_header nhrp_packet_push(struct zbuf zb, uint8_t type,
	480	const union sockunion *src_nbma,
	481	const union sockunion *src_proto,
	482	const union sockunion *dst_proto);
2fb975da TT	483	void nhrp_packet_complete(struct zbuf zb, struct nhrp_packet_header hdr);
	484	uint16_t nhrp_packet_calculate_checksum(const uint8_t *pdu, uint16_t len);
	485
996c9314 LB	486	struct nhrp_packet_header nhrp_packet_pull(struct zbuf zb,
	487	union sockunion *src_nbma,
	488	union sockunion *src_proto,
	489	union sockunion *dst_proto);
	490
	491	struct nhrp_cie_header nhrp_cie_push(struct zbuf zb, uint8_t code,
	492	const union sockunion *nbma,
	493	const union sockunion *proto);
	494	struct nhrp_cie_header nhrp_cie_pull(struct zbuf zb,
	495	struct nhrp_packet_header *hdr,
	496	union sockunion *nbma,
	497	union sockunion *proto);
	498
	499	struct nhrp_extension_header *
	500	nhrp_ext_push(struct zbuf zb, struct nhrp_packet_header hdr, uint16_t type);
2fb975da	501	void nhrp_ext_complete(struct zbuf zb, struct nhrp_extension_header ext);
996c9314 LB	502	struct nhrp_extension_header nhrp_ext_pull(struct zbuf zb,
	503	struct zbuf *payload);
	504	void nhrp_ext_request(struct zbuf zb, struct nhrp_packet_header hdr,
	505	struct interface *);
	506	int nhrp_ext_reply(struct zbuf zb, struct nhrp_packet_header hdr,
	507	struct interface ifp, struct nhrp_extension_header ext,
	508	struct zbuf *extpayload);
	509
	510	uint32_t nhrp_reqid_alloc(struct nhrp_reqid_pool , struct nhrp_reqid r,
	511	void (cb)(struct nhrp_reqid , void *));
2fb975da TT	512	void nhrp_reqid_free(struct nhrp_reqid_pool , struct nhrp_reqid r);
	513	struct nhrp_reqid nhrp_reqid_lookup(struct nhrp_reqid_pool , uint32_t reqid);
	514
	515	int nhrp_packet_init(void);
	516
ee72f0a0	517	void nhrp_peer_interface_del(struct interface *ifp);
996c9314 LB	518	struct nhrp_peer nhrp_peer_get(struct interface ifp,
996c9314 LB	519	const union sockunion *remote_nbma);
2fb975da TT	520	struct nhrp_peer nhrp_peer_ref(struct nhrp_peer p);
	521	void nhrp_peer_unref(struct nhrp_peer *p);
	522	int nhrp_peer_check(struct nhrp_peer *p, int establish);
996c9314 LB	523	void nhrp_peer_notify_add(struct nhrp_peer p, struct notifier_block ,
996c9314 LB	524	notifier_fn_t);
2fb975da TT	525	void nhrp_peer_notify_del(struct nhrp_peer p, struct notifier_block );
	526	void nhrp_peer_recv(struct nhrp_peer p, struct zbuf zb);
	527	void nhrp_peer_send(struct nhrp_peer p, struct zbuf zb);
	528	void nhrp_peer_send_indication(struct interface ifp, uint16_t, struct zbuf );
	529
bb58f442 GG	530	int nhrp_nhs_match_ip(union sockunion in_ip, struct nhrp_interface nifp);
bb58f442 GG	531
2fb975da	532	#endif