[mirror_frr.git] / bfdd / bfd.h

/*********************************************************************
 * Copyright 2014,2015,2016,2017 Cumulus Networks, Inc.  All rights reserved.
 *
 * This program 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 of the License, or (at your option)
 * any later version.
 *
 * This program 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 this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * bfd.h: implements the BFD protocol.
 */

#ifndef _BFD_H_
#define _BFD_H_

#include <netinet/in.h>

#include <stdbool.h>
#include <stdarg.h>
#include <stdint.h>

#include "lib/hash.h"
#include "lib/libfrr.h"
#include "lib/qobj.h"
#include "lib/queue.h"
#include "lib/vrf.h"

#include "bfdctl.h"

#ifdef BFD_DEBUG
#define BFDD_JSON_CONV_OPTIONS (JSON_C_TO_STRING_PRETTY)
#else
#define BFDD_JSON_CONV_OPTIONS (0)
#endif

DECLARE_MGROUP(BFDD)
DECLARE_MTYPE(BFDD_CONTROL)
DECLARE_MTYPE(BFDD_NOTIFICATION)

struct bfd_timers {
	uint32_t desired_min_tx;
	uint32_t required_min_rx;
	uint32_t required_min_echo;
};

struct bfd_discrs {
	uint32_t my_discr;
	uint32_t remote_discr;
};

/*
 * Format of control packet.  From section 4)
 */
struct bfd_pkt {
	union {
		uint32_t byteFields;
		struct {
			uint8_t diag;
			uint8_t flags;
			uint8_t detect_mult;
			uint8_t len;
		};
	};
	struct bfd_discrs discrs;
	struct bfd_timers timers;
};

/*
 * Format of Echo packet.
 */
struct bfd_echo_pkt {
	union {
		uint32_t byteFields;
		struct {
			uint8_t ver;
			uint8_t len;
			uint16_t reserved;
		};
	};
	uint32_t my_discr;
	uint8_t pad[16];
};


/* Macros for manipulating control packets */
#define BFD_VERMASK 0x03
#define BFD_DIAGMASK 0x1F
#define BFD_GETVER(diag) ((diag >> 5) & BFD_VERMASK)
#define BFD_SETVER(diag, val) ((diag) |= (val & BFD_VERMASK) << 5)
#define BFD_VERSION 1
#define BFD_PBIT 0x20
#define BFD_FBIT 0x10
#define BFD_CBIT 0x08
#define BFD_ABIT 0x04
#define BFD_DEMANDBIT 0x02
#define BFD_SETDEMANDBIT(flags, val)                                           \
	{                                                                      \
		if ((val))                                                     \
			flags |= BFD_DEMANDBIT;                                \
	}
#define BFD_SETPBIT(flags, val)                                                \
	{                                                                      \
		if ((val))                                                     \
			flags |= BFD_PBIT;                                     \
	}
#define BFD_GETPBIT(flags) (flags & BFD_PBIT)
#define BFD_SETFBIT(flags, val)                                                \
	{                                                                      \
		if ((val))                                                     \
			flags |= BFD_FBIT;                                     \
	}
#define BFD_GETFBIT(flags) (flags & BFD_FBIT)
#define BFD_SETSTATE(flags, val)                                               \
	{                                                                      \
		if ((val))                                                     \
			flags |= (val & 0x3) << 6;                             \
	}
#define BFD_GETSTATE(flags) ((flags >> 6) & 0x3)
#define BFD_SETCBIT(flags, val)                                                \
	{                                                                      \
		if ((val))                                                     \
			flags |= val;                                          \
	}
#define BFD_GETCBIT(flags) (flags & BFD_FBIT)
#define BFD_ECHO_VERSION 1
#define BFD_ECHO_PKT_LEN sizeof(struct bfd_echo_pkt)

enum bfd_diagnosticis {
	BD_OK = 0,
	/* Control Detection Time Expired. */
	BD_CONTROL_EXPIRED = 1,
	/* Echo Function Failed. */
	BD_ECHO_FAILED = 2,
	/* Neighbor Signaled Session Down. */
	BD_NEIGHBOR_DOWN = 3,
	/* Forwarding Plane Reset. */
	BD_FORWARDING_RESET = 4,
	/* Path Down. */
	BD_PATH_DOWN = 5,
	/* Concatenated Path Down. */
	BD_CONCATPATH_DOWN = 6,
	/* Administratively Down. */
	BD_ADMIN_DOWN = 7,
	/* Reverse Concatenated Path Down. */
	BD_REVCONCATPATH_DOWN = 8,
	/* 9..31: reserved. */
};

/* BFD session flags */
enum bfd_session_flags {
	BFD_SESS_FLAG_NONE = 0,
	BFD_SESS_FLAG_ECHO = 1 << 0,	/* BFD Echo functionality */
	BFD_SESS_FLAG_ECHO_ACTIVE = 1 << 1, /* BFD Echo Packets are being sent
					     * actively
					     */
	BFD_SESS_FLAG_MH = 1 << 2,	  /* BFD Multi-hop session */
	BFD_SESS_FLAG_IPV6 = 1 << 4,	/* BFD IPv6 session */
	BFD_SESS_FLAG_SEND_EVT_ACTIVE = 1 << 5, /* send event timer active */
	BFD_SESS_FLAG_SEND_EVT_IGNORE = 1 << 6, /* ignore send event when timer
						 * expires
						 */
	BFD_SESS_FLAG_SHUTDOWN = 1 << 7,	/* disable BGP peer function */
	BFD_SESS_FLAG_CONFIG = 1 << 8,	/* Session configured with bfd NB API */
	BFD_SESS_FLAG_CBIT = 1 << 9,	/* CBIT is set */
};

#define BFD_SET_FLAG(field, flag) (field |= flag)
#define BFD_UNSET_FLAG(field, flag) (field &= ~flag)
#define BFD_CHECK_FLAG(field, flag) (field & flag)

/* BFD session hash keys */
struct bfd_key {
	uint16_t family;
	uint8_t mhop;
	struct in6_addr peer;
	struct in6_addr local;
	char ifname[MAXNAMELEN];
	char vrfname[MAXNAMELEN];
};

struct bfd_session_stats {
	uint64_t rx_ctrl_pkt;
	uint64_t tx_ctrl_pkt;
	uint64_t rx_echo_pkt;
	uint64_t tx_echo_pkt;
	uint64_t session_up;
	uint64_t session_down;
	uint64_t znotification;
};

/* bfd_session shortcut label forwarding. */
struct peer_label;

/*
 * Session state information
 */
struct bfd_session {

	/* protocol state per RFC 5880*/
	uint8_t ses_state;
	struct bfd_discrs discrs;
	uint8_t local_diag;
	uint8_t demand_mode;
	uint8_t detect_mult;
	uint8_t remote_detect_mult;
	uint8_t mh_ttl;
	uint8_t remote_cbit;

	/* Timers */
	struct bfd_timers timers;
	struct bfd_timers cur_timers;
	uint64_t detect_TO;
	struct thread *echo_recvtimer_ev;
	struct thread *recvtimer_ev;
	uint64_t xmt_TO;
	uint64_t echo_xmt_TO;
	struct thread *xmttimer_ev;
	struct thread *echo_xmttimer_ev;
	uint64_t echo_detect_TO;

	/* software object state */
	uint8_t polling;

	/* This and the localDiscr are the keys to state info */
	struct bfd_key key;
	struct peer_label *pl;

	struct sockaddr_any local_address;
	struct interface *ifp;
	struct vrf *vrf;

	int sock;

	/* BFD session flags */
	enum bfd_session_flags flags;

	struct bfd_session_stats stats;

	struct timeval uptime;   /* last up time */
	struct timeval downtime; /* last down time */

	/* Remote peer data (for debugging mostly) */
	uint8_t remote_diag;
	struct bfd_timers remote_timers;

	uint64_t refcount; /* number of pointers referencing this. */
};

struct peer_label {
	TAILQ_ENTRY(peer_label) pl_entry;

	struct bfd_session *pl_bs;
	char pl_label[MAXNAMELEN];
};
TAILQ_HEAD(pllist, peer_label);

struct bfd_diag_str_list {
	const char *str;
	int type;
};

struct bfd_state_str_list {
	const char *str;
	int type;
};

struct bfd_session_observer {
	struct bfd_session *bso_bs;
	bool bso_isinterface;
	bool bso_isaddress;
	union {
		char bso_entryname[MAXNAMELEN];
		struct prefix bso_addr;
	};

	TAILQ_ENTRY(bfd_session_observer) bso_entry;
};
TAILQ_HEAD(obslist, bfd_session_observer);


/* States defined per 4.1 */
#define PTM_BFD_ADM_DOWN 0
#define PTM_BFD_DOWN 1
#define PTM_BFD_INIT 2
#define PTM_BFD_UP 3


/* Various constants */
/* Retrieved from ptm_timer.h from Cumulus PTM sources. */
#define BFD_DEF_DEMAND 0
#define BFD_DEFDETECTMULT 3
#define BFD_DEFDESIREDMINTX (300 * 1000) /* microseconds. */
#define BFD_DEFREQUIREDMINRX (300 * 1000) /* microseconds. */
#define BFD_DEF_REQ_MIN_ECHO (50 * 1000) /* microseconds. */
#define BFD_DEF_SLOWTX (1000 * 1000) /* microseconds. */
#define BFD_DEF_MHOP_TTL 5
#define BFD_PKT_LEN 24 /* Length of control packet */
#define BFD_TTL_VAL 255
#define BFD_RCV_TTL_VAL 1
#define BFD_TOS_VAL 0xC0
#define BFD_PKT_INFO_VAL 1
#define BFD_IPV6_PKT_INFO_VAL 1
#define BFD_IPV6_ONLY_VAL 1
#define BFD_SRCPORTINIT 49152
#define BFD_SRCPORTMAX 65535
#define BFD_DEFDESTPORT 3784
#define BFD_DEF_ECHO_PORT 3785
#define BFD_DEF_MHOP_DEST_PORT 4784

/*
 * control.c
 *
 * Daemon control code to speak with local consumers.
 */

/* See 'bfdctrl.h' for client protocol definitions. */

struct bfd_control_buffer {
	size_t bcb_left;
	size_t bcb_pos;
	union {
		struct bfd_control_msg *bcb_bcm;
		uint8_t *bcb_buf;
	};
};

struct bfd_control_queue {
	TAILQ_ENTRY(bfd_control_queue) bcq_entry;

	struct bfd_control_buffer bcq_bcb;
};
TAILQ_HEAD(bcqueue, bfd_control_queue);

struct bfd_notify_peer {
	TAILQ_ENTRY(bfd_notify_peer) bnp_entry;

	struct bfd_session *bnp_bs;
};
TAILQ_HEAD(bnplist, bfd_notify_peer);

struct bfd_control_socket {
	TAILQ_ENTRY(bfd_control_socket) bcs_entry;

	int bcs_sd;
	struct thread *bcs_ev;
	struct thread *bcs_outev;
	struct bcqueue bcs_bcqueue;

	/* Notification data */
	uint64_t bcs_notify;
	struct bnplist bcs_bnplist;

	enum bc_msg_version bcs_version;
	enum bc_msg_type bcs_type;

	/* Message buffering */
	struct bfd_control_buffer bcs_bin;
	struct bfd_control_buffer *bcs_bout;
};
TAILQ_HEAD(bcslist, bfd_control_socket);

int control_init(const char *path);
void control_shutdown(void);
int control_notify(struct bfd_session *bs);
int control_notify_config(const char *op, struct bfd_session *bs);
int control_accept(struct thread *t);


/*
 * bfdd.c
 *
 * Daemon specific code.
 */
struct bfd_vrf_global {
	int bg_shop;
	int bg_mhop;
	int bg_shop6;
	int bg_mhop6;
	int bg_echo;
	int bg_echov6;
	struct vrf *vrf;

	struct thread *bg_ev[6];
};

struct bfd_global {
	int bg_csock;
	struct thread *bg_csockev;
	struct bcslist bg_bcslist;

	struct pllist bg_pllist;

	struct obslist bg_obslist;

	struct zebra_privs_t bfdd_privs;
};
extern struct bfd_global bglobal;
extern struct bfd_diag_str_list diag_list[];
extern struct bfd_state_str_list state_list[];

void socket_close(int *s);


/*
 * config.c
 *
 * Contains the code related with loading/reloading configuration.
 */
int parse_config(const char *fname);
int config_request_add(const char *jsonstr);
int config_request_del(const char *jsonstr);
char *config_response(const char *status, const char *error);
char *config_notify(struct bfd_session *bs);
char *config_notify_config(const char *op, struct bfd_session *bs);

typedef int (*bpc_handle)(struct bfd_peer_cfg *, void *arg);
int config_notify_request(struct bfd_control_socket *bcs, const char *jsonstr,
			  bpc_handle bh);

struct peer_label *pl_new(const char *label, struct bfd_session *bs);
struct peer_label *pl_find(const char *label);
void pl_free(struct peer_label *pl);


/*
 * log.c
 *
 * Contains code that does the logging procedures. Might implement multiple
 * backends (e.g. zebra log, syslog or other logging lib).
 */
enum blog_level {
	/* level vs syslog equivalent */
	BLOG_DEBUG = 0,   /* LOG_DEBUG */
	BLOG_INFO = 1,    /* LOG_INFO */
	BLOG_WARNING = 2, /* LOG_WARNING */
	BLOG_ERROR = 3,   /* LOG_ERR */
	BLOG_FATAL = 4,   /* LOG_CRIT */
};

void log_init(int foreground, enum blog_level level,
	      struct frr_daemon_info *fdi);
void log_info(const char *fmt, ...);
void log_debug(const char *fmt, ...);
void log_warning(const char *fmt, ...);
void log_error(const char *fmt, ...);
void log_fatal(const char *fmt, ...);


/*
 * bfd_packet.c
 *
 * Contains the code related with receiving/seding, packing/unpacking BFD data.
 */
int bp_set_ttlv6(int sd, uint8_t value);
int bp_set_ttl(int sd, uint8_t value);
int bp_set_tosv6(int sd, uint8_t value);
int bp_set_tos(int sd, uint8_t value);
int bp_bind_dev(int sd, const char *dev);

int bp_udp_shop(vrf_id_t vrf_id);
int bp_udp_mhop(vrf_id_t vrf_id);
int bp_udp6_shop(vrf_id_t vrf_id);
int bp_udp6_mhop(vrf_id_t vrf_id);
int bp_peer_socket(const struct bfd_session *bs);
int bp_peer_socketv6(const struct bfd_session *bs);
int bp_echo_socket(vrf_id_t vrf_id);
int bp_echov6_socket(vrf_id_t vrf_id);

void ptm_bfd_snd(struct bfd_session *bfd, int fbit);
void ptm_bfd_echo_snd(struct bfd_session *bfd);

int bfd_recv_cb(struct thread *t);


/*
 * event.c
 *
 * Contains the code related with event loop.
 */
typedef void (*bfd_ev_cb)(struct thread *t);

void bfd_recvtimer_update(struct bfd_session *bs);
void bfd_echo_recvtimer_update(struct bfd_session *bs);
void bfd_xmttimer_update(struct bfd_session *bs, uint64_t jitter);
void bfd_echo_xmttimer_update(struct bfd_session *bs, uint64_t jitter);

void bfd_xmttimer_delete(struct bfd_session *bs);
void bfd_echo_xmttimer_delete(struct bfd_session *bs);
void bfd_recvtimer_delete(struct bfd_session *bs);
void bfd_echo_recvtimer_delete(struct bfd_session *bs);

void bfd_recvtimer_assign(struct bfd_session *bs, bfd_ev_cb cb, int sd);
void bfd_echo_recvtimer_assign(struct bfd_session *bs, bfd_ev_cb cb, int sd);
void bfd_xmttimer_assign(struct bfd_session *bs, bfd_ev_cb cb);
void bfd_echo_xmttimer_assign(struct bfd_session *bs, bfd_ev_cb cb);


/*
 * bfd.c
 *
 * BFD protocol specific code.
 */
int bfd_session_enable(struct bfd_session *bs);
void bfd_session_disable(struct bfd_session *bs);
struct bfd_session *ptm_bfd_sess_new(struct bfd_peer_cfg *bpc);
int ptm_bfd_sess_del(struct bfd_peer_cfg *bpc);
void ptm_bfd_sess_dn(struct bfd_session *bfd, uint8_t diag);
void ptm_bfd_sess_up(struct bfd_session *bfd);
void ptm_bfd_echo_stop(struct bfd_session *bfd);
void ptm_bfd_echo_start(struct bfd_session *bfd);
void ptm_bfd_xmt_TO(struct bfd_session *bfd, int fbit);
void ptm_bfd_start_xmt_timer(struct bfd_session *bfd, bool is_echo);
struct bfd_session *ptm_bfd_sess_find(struct bfd_pkt *cp,
				      struct sockaddr_any *peer,
				      struct sockaddr_any *local,
				      ifindex_t ifindex, vrf_id_t vrfid,
				      bool is_mhop);

struct bfd_session *bs_peer_find(struct bfd_peer_cfg *bpc);
int bfd_session_update_label(struct bfd_session *bs, const char *nlabel);
void bfd_set_polling(struct bfd_session *bs);
void bs_state_handler(struct bfd_session *bs, int nstate);
void bs_echo_timer_handler(struct bfd_session *bs);
void bs_final_handler(struct bfd_session *bs);
void bs_set_slow_timers(struct bfd_session *bs);
const char *satostr(struct sockaddr_any *sa);
const char *diag2str(uint8_t diag);
int strtosa(const char *addr, struct sockaddr_any *sa);
void integer2timestr(uint64_t time, char *buf, size_t buflen);
const char *bs_to_string(const struct bfd_session *bs);

int bs_observer_add(struct bfd_session *bs);
void bs_observer_del(struct bfd_session_observer *bso);

void bs_to_bpc(struct bfd_session *bs, struct bfd_peer_cfg *bpc);

void gen_bfd_key(struct bfd_key *key, struct sockaddr_any *peer,
		 struct sockaddr_any *local, bool mhop, const char *ifname,
		 const char *vrfname);
struct bfd_session *bfd_session_new(void);
struct bfd_session *bs_registrate(struct bfd_session *bs);
void bfd_session_free(struct bfd_session *bs);
const struct bfd_session *bfd_session_next(const struct bfd_session *bs,
					   bool mhop);
void bfd_sessions_remove_manual(void);

/* BFD hash data structures interface */
void bfd_initialize(void);
void bfd_shutdown(void);
void bfd_vrf_init(void);
void bfd_vrf_terminate(void);
struct bfd_vrf_global *bfd_vrf_look_by_session(struct bfd_session *bfd);
struct bfd_session *bfd_id_lookup(uint32_t id);
struct bfd_session *bfd_key_lookup(struct bfd_key key);

struct bfd_session *bfd_id_delete(uint32_t id);
struct bfd_session *bfd_key_delete(struct bfd_key key);

bool bfd_id_insert(struct bfd_session *bs);
bool bfd_key_insert(struct bfd_session *bs);

typedef void (*hash_iter_func)(struct hash_bucket *hb, void *arg);
void bfd_id_iterate(hash_iter_func hif, void *arg);
void bfd_key_iterate(hash_iter_func hif, void *arg);

/* Export callback functions for `event.c`. */
extern struct thread_master *master;

int bfd_recvtimer_cb(struct thread *t);
int bfd_echo_recvtimer_cb(struct thread *t);
int bfd_xmt_cb(struct thread *t);
int bfd_echo_xmt_cb(struct thread *t);

extern struct in6_addr zero_addr;


/*
 * bfdd_vty.c
 *
 * BFD daemon vty shell commands.
 */
void bfdd_vty_init(void);


/*
 * bfdd_cli.c
 *
 * BFD daemon CLI implementation.
 */
void bfdd_cli_init(void);

void bfd_cli_show_header(struct vty *vty, struct lyd_node *dnode,
			 bool show_defaults);
void bfd_cli_show_header_end(struct vty *vty, struct lyd_node *dnode);
void bfd_cli_show_single_hop_peer(struct vty *vty,
				  struct lyd_node *dnode,
				  bool show_defaults);
void bfd_cli_show_multi_hop_peer(struct vty *vty,
				 struct lyd_node *dnode,
				 bool show_defaults);
void bfd_cli_show_peer_end(struct vty *vty, struct lyd_node *dnode);
void bfd_cli_show_mult(struct vty *vty, struct lyd_node *dnode,
		       bool show_defaults);
void bfd_cli_show_tx(struct vty *vty, struct lyd_node *dnode,
		     bool show_defaults);
void bfd_cli_show_rx(struct vty *vty, struct lyd_node *dnode,
		     bool show_defaults);
void bfd_cli_show_shutdown(struct vty *vty, struct lyd_node *dnode,
			   bool show_defaults);
void bfd_cli_show_echo(struct vty *vty, struct lyd_node *dnode,
			   bool show_defaults);
void bfd_cli_show_echo_interval(struct vty *vty, struct lyd_node *dnode,
				bool show_defaults);


/*
 * ptm_adapter.c
 */
void bfdd_zclient_init(struct zebra_privs_t *bfdd_priv);
void bfdd_zclient_stop(void);
void bfdd_zclient_unregister(vrf_id_t vrf_id);
void bfdd_zclient_register(vrf_id_t vrf_id);
void bfdd_sessions_enable_vrf(struct vrf *vrf);
void bfdd_sessions_disable_vrf(struct vrf *vrf);
void bfd_session_update_vrf_name(struct bfd_session *bs, struct vrf *vrf);

int ptm_bfd_notify(struct bfd_session *bs);


/*
 * bfdd_northbound.c
 *
 * BFD northbound callbacks.
 */
extern const struct frr_yang_module_info frr_bfdd_info;

#endif /* _BFD_H_ */
Commit	Line	Data
e9e2c950 RZ	1	/*********************************************************************
	2	* Copyright 2014,2015,2016,2017 Cumulus Networks, Inc. All rights reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or modify it
	5	* under the terms of the GNU General Public License as published by the Free
	6	* Software Foundation; either version 2 of the License, or (at your option)
	7	* any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful, but WITHOUT
	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	12	* more details.
	13	*
	14	* You should have received a copy of the GNU General Public License along
	15	* with this program; see the file COPYING; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	17	*
	18	* bfd.h: implements the BFD protocol.
	19	*/
	20
	21	#ifndef _BFD_H_
	22	#define _BFD_H_
	23
	24	#include <netinet/in.h>
	25
	26	#include <stdbool.h>
	27	#include <stdarg.h>
	28	#include <stdint.h>
	29
	30	#include "lib/hash.h"
	31	#include "lib/libfrr.h"
	32	#include "lib/qobj.h"
	33	#include "lib/queue.h"
80edb675	34	#include "lib/vrf.h"
e9e2c950 RZ	35
	36	#include "bfdctl.h"
	37
e9e2c950 RZ	38	#ifdef BFD_DEBUG
	39	#define BFDD_JSON_CONV_OPTIONS (JSON_C_TO_STRING_PRETTY)
	40	#else
	41	#define BFDD_JSON_CONV_OPTIONS (0)
	42	#endif
	43
1b88c3cb DL	44	DECLARE_MGROUP(BFDD)
	45	DECLARE_MTYPE(BFDD_CONTROL)
	46	DECLARE_MTYPE(BFDD_NOTIFICATION)
e9e2c950 RZ	47
	48	struct bfd_timers {
	49	uint32_t desired_min_tx;
	50	uint32_t required_min_rx;
	51	uint32_t required_min_echo;
	52	};
	53
	54	struct bfd_discrs {
	55	uint32_t my_discr;
	56	uint32_t remote_discr;
	57	};
	58
	59	/*
	60	* Format of control packet. From section 4)
	61	*/
	62	struct bfd_pkt {
	63	union {
	64	uint32_t byteFields;
	65	struct {
	66	uint8_t diag;
	67	uint8_t flags;
	68	uint8_t detect_mult;
	69	uint8_t len;
	70	};
	71	};
	72	struct bfd_discrs discrs;
	73	struct bfd_timers timers;
	74	};
	75
	76	/*
	77	* Format of Echo packet.
	78	*/
	79	struct bfd_echo_pkt {
	80	union {
	81	uint32_t byteFields;
	82	struct {
	83	uint8_t ver;
	84	uint8_t len;
	85	uint16_t reserved;
	86	};
	87	};
	88	uint32_t my_discr;
	89	uint8_t pad[16];
	90	};
	91
	92
	93	/* Macros for manipulating control packets */
	94	#define BFD_VERMASK 0x03
	95	#define BFD_DIAGMASK 0x1F
	96	#define BFD_GETVER(diag) ((diag >> 5) & BFD_VERMASK)
	97	#define BFD_SETVER(diag, val) ((diag) \|= (val & BFD_VERMASK) << 5)
	98	#define BFD_VERSION 1
	99	#define BFD_PBIT 0x20
	100	#define BFD_FBIT 0x10
	101	#define BFD_CBIT 0x08
	102	#define BFD_ABIT 0x04
	103	#define BFD_DEMANDBIT 0x02
e9e2c950 RZ	104	#define BFD_SETDEMANDBIT(flags, val) \
	105	{ \
	106	if ((val)) \
	107	flags \|= BFD_DEMANDBIT; \
	108	}
	109	#define BFD_SETPBIT(flags, val) \
	110	{ \
	111	if ((val)) \
	112	flags \|= BFD_PBIT; \
	113	}
	114	#define BFD_GETPBIT(flags) (flags & BFD_PBIT)
	115	#define BFD_SETFBIT(flags, val) \
	116	{ \
	117	if ((val)) \
	118	flags \|= BFD_FBIT; \
	119	}
	120	#define BFD_GETFBIT(flags) (flags & BFD_FBIT)
	121	#define BFD_SETSTATE(flags, val) \
	122	{ \
	123	if ((val)) \
	124	flags \|= (val & 0x3) << 6; \
	125	}
	126	#define BFD_GETSTATE(flags) ((flags >> 6) & 0x3)
9beff0bd PG	127	#define BFD_SETCBIT(flags, val) \
	128	{ \
	129	if ((val)) \
	130	flags \|= val; \
	131	}
	132	#define BFD_GETCBIT(flags) (flags & BFD_FBIT)
e9e2c950 RZ	133	#define BFD_ECHO_VERSION 1
e9e2c950 RZ	134	#define BFD_ECHO_PKT_LEN sizeof(struct bfd_echo_pkt)
e9e2c950	135
40675ea9 RZ	136	enum bfd_diagnosticis {
	137	BD_OK = 0,
	138	/* Control Detection Time Expired. */
	139	BD_CONTROL_EXPIRED = 1,
	140	/* Echo Function Failed. */
	141	BD_ECHO_FAILED = 2,
	142	/* Neighbor Signaled Session Down. */
	143	BD_NEIGHBOR_DOWN = 3,
	144	/* Forwarding Plane Reset. */
	145	BD_FORWARDING_RESET = 4,
	146	/* Path Down. */
	147	BD_PATH_DOWN = 5,
	148	/* Concatenated Path Down. */
	149	BD_CONCATPATH_DOWN = 6,
	150	/* Administratively Down. */
	151	BD_ADMIN_DOWN = 7,
	152	/* Reverse Concatenated Path Down. */
	153	BD_REVCONCATPATH_DOWN = 8,
	154	/* 9..31: reserved. */
	155	};
	156
e9e2c950 RZ	157	/* BFD session flags */
	158	enum bfd_session_flags {
	159	BFD_SESS_FLAG_NONE = 0,
	160	BFD_SESS_FLAG_ECHO = 1 << 0, /* BFD Echo functionality */
	161	BFD_SESS_FLAG_ECHO_ACTIVE = 1 << 1, /* BFD Echo Packets are being sent
	162	* actively
	163	*/
	164	BFD_SESS_FLAG_MH = 1 << 2, /* BFD Multi-hop session */
e9e2c950 RZ	165	BFD_SESS_FLAG_IPV6 = 1 << 4, /* BFD IPv6 session */
	166	BFD_SESS_FLAG_SEND_EVT_ACTIVE = 1 << 5, /* send event timer active */
	167	BFD_SESS_FLAG_SEND_EVT_IGNORE = 1 << 6, /* ignore send event when timer
	168	* expires
	169	*/
	170	BFD_SESS_FLAG_SHUTDOWN = 1 << 7, /* disable BGP peer function */
6bdb4a42	171	BFD_SESS_FLAG_CONFIG = 1 << 8, /* Session configured with bfd NB API */
9beff0bd	172	BFD_SESS_FLAG_CBIT = 1 << 9, /* CBIT is set */
e9e2c950 RZ	173	};
	174
	175	#define BFD_SET_FLAG(field, flag) (field \|= flag)
	176	#define BFD_UNSET_FLAG(field, flag) (field &= ~flag)
	177	#define BFD_CHECK_FLAG(field, flag) (field & flag)
	178
	179	/* BFD session hash keys */
79b4a6fc RZ	180	struct bfd_key {
	181	uint16_t family;
	182	uint8_t mhop;
	183	struct in6_addr peer;
	184	struct in6_addr local;
	185	char ifname[MAXNAMELEN];
	186	char vrfname[MAXNAMELEN];
e9e2c950 RZ	187	};
	188
	189	struct bfd_session_stats {
	190	uint64_t rx_ctrl_pkt;
	191	uint64_t tx_ctrl_pkt;
	192	uint64_t rx_echo_pkt;
	193	uint64_t tx_echo_pkt;
0684c9b1 RZ	194	uint64_t session_up;
	195	uint64_t session_down;
	196	uint64_t znotification;
e9e2c950 RZ	197	};
e9e2c950 RZ	198
e9e2c950 RZ	199	/* bfd_session shortcut label forwarding. */
	200	struct peer_label;
	201
	202	/*
	203	* Session state information
	204	*/
	205	struct bfd_session {
	206
	207	/* protocol state per RFC 5880*/
	208	uint8_t ses_state;
	209	struct bfd_discrs discrs;
	210	uint8_t local_diag;
	211	uint8_t demand_mode;
	212	uint8_t detect_mult;
	213	uint8_t remote_detect_mult;
	214	uint8_t mh_ttl;
9beff0bd	215	uint8_t remote_cbit;
e9e2c950 RZ	216
	217	/* Timers */
	218	struct bfd_timers timers;
f43b9368	219	struct bfd_timers cur_timers;
e9e2c950 RZ	220	uint64_t detect_TO;
	221	struct thread *echo_recvtimer_ev;
	222	struct thread *recvtimer_ev;
	223	uint64_t xmt_TO;
	224	uint64_t echo_xmt_TO;
	225	struct thread *xmttimer_ev;
	226	struct thread *echo_xmttimer_ev;
	227	uint64_t echo_detect_TO;
	228
	229	/* software object state */
	230	uint8_t polling;
	231
	232	/* This and the localDiscr are the keys to state info */
79b4a6fc	233	struct bfd_key key;
e9e2c950	234	struct peer_label *pl;
e9e2c950 RZ	235
e9e2c950 RZ	236	struct sockaddr_any local_address;
80edb675	237	struct interface *ifp;
b333abc2	238	struct vrf *vrf;
79b4a6fc RZ	239
79b4a6fc RZ	240	int sock;
e9e2c950 RZ	241
	242	/* BFD session flags */
	243	enum bfd_session_flags flags;
	244
e9e2c950	245	struct bfd_session_stats stats;
e9e2c950 RZ	246
	247	struct timeval uptime; /* last up time */
	248	struct timeval downtime; /* last down time */
	249
	250	/* Remote peer data (for debugging mostly) */
	251	uint8_t remote_diag;
	252	struct bfd_timers remote_timers;
	253
	254	uint64_t refcount; /* number of pointers referencing this. */
e9e2c950	255	};
e9e2c950 RZ	256
	257	struct peer_label {
	258	TAILQ_ENTRY(peer_label) pl_entry;
	259
	260	struct bfd_session *pl_bs;
	261	char pl_label[MAXNAMELEN];
	262	};
	263	TAILQ_HEAD(pllist, peer_label);
	264
	265	struct bfd_diag_str_list {
	266	const char *str;
	267	int type;
	268	};
	269
	270	struct bfd_state_str_list {
	271	const char *str;
	272	int type;
	273	};
	274
d245e522 RZ	275	struct bfd_session_observer {
	276	struct bfd_session *bso_bs;
	277	bool bso_isinterface;
261e0ba9 RZ	278	bool bso_isaddress;
	279	union {
	280	char bso_entryname[MAXNAMELEN];
	281	struct prefix bso_addr;
	282	};
d245e522 RZ	283
	284	TAILQ_ENTRY(bfd_session_observer) bso_entry;
	285	};
	286	TAILQ_HEAD(obslist, bfd_session_observer);
	287
e9e2c950 RZ	288
	289	/* States defined per 4.1 */
	290	#define PTM_BFD_ADM_DOWN 0
	291	#define PTM_BFD_DOWN 1
	292	#define PTM_BFD_INIT 2
	293	#define PTM_BFD_UP 3
	294
	295
	296	/* Various constants */
	297	/* Retrieved from ptm_timer.h from Cumulus PTM sources. */
e9e2c950 RZ	298	#define BFD_DEF_DEMAND 0
e9e2c950 RZ	299	#define BFD_DEFDETECTMULT 3
33400b46 RZ	300	#define BFD_DEFDESIREDMINTX (300 * 1000) /* microseconds. */
	301	#define BFD_DEFREQUIREDMINRX (300 * 1000) /* microseconds. */
	302	#define BFD_DEF_REQ_MIN_ECHO (50 * 1000) /* microseconds. */
	303	#define BFD_DEF_SLOWTX (1000 * 1000) /* microseconds. */
e9e2c950 RZ	304	#define BFD_DEF_MHOP_TTL 5
	305	#define BFD_PKT_LEN 24 /* Length of control packet */
	306	#define BFD_TTL_VAL 255
	307	#define BFD_RCV_TTL_VAL 1
	308	#define BFD_TOS_VAL 0xC0
	309	#define BFD_PKT_INFO_VAL 1
	310	#define BFD_IPV6_PKT_INFO_VAL 1
	311	#define BFD_IPV6_ONLY_VAL 1
545d3f70 RZ	312	#define BFD_SRCPORTINIT 49152
545d3f70 RZ	313	#define BFD_SRCPORTMAX 65535
e9e2c950 RZ	314	#define BFD_DEFDESTPORT 3784
	315	#define BFD_DEF_ECHO_PORT 3785
	316	#define BFD_DEF_MHOP_DEST_PORT 4784
e9e2c950 RZ	317
	318	/*
	319	* control.c
	320	*
	321	* Daemon control code to speak with local consumers.
	322	*/
	323
	324	/* See 'bfdctrl.h' for client protocol definitions. */
	325
	326	struct bfd_control_buffer {
	327	size_t bcb_left;
	328	size_t bcb_pos;
	329	union {
	330	struct bfd_control_msg *bcb_bcm;
	331	uint8_t *bcb_buf;
	332	};
	333	};
	334
	335	struct bfd_control_queue {
	336	TAILQ_ENTRY(bfd_control_queue) bcq_entry;
	337
	338	struct bfd_control_buffer bcq_bcb;
	339	};
	340	TAILQ_HEAD(bcqueue, bfd_control_queue);
	341
	342	struct bfd_notify_peer {
	343	TAILQ_ENTRY(bfd_notify_peer) bnp_entry;
	344
	345	struct bfd_session *bnp_bs;
	346	};
	347	TAILQ_HEAD(bnplist, bfd_notify_peer);
	348
	349	struct bfd_control_socket {
	350	TAILQ_ENTRY(bfd_control_socket) bcs_entry;
	351
	352	int bcs_sd;
	353	struct thread *bcs_ev;
	354	struct thread *bcs_outev;
	355	struct bcqueue bcs_bcqueue;
	356
	357	/* Notification data */
	358	uint64_t bcs_notify;
	359	struct bnplist bcs_bnplist;
	360
	361	enum bc_msg_version bcs_version;
	362	enum bc_msg_type bcs_type;
	363
	364	/* Message buffering */
	365	struct bfd_control_buffer bcs_bin;
	366	struct bfd_control_buffer *bcs_bout;
	367	};
	368	TAILQ_HEAD(bcslist, bfd_control_socket);
	369
	370	int control_init(const char *path);
	371	void control_shutdown(void);
	372	int control_notify(struct bfd_session *bs);
	373	int control_notify_config(const char op, struct bfd_session bs);
	374	int control_accept(struct thread *t);
	375
	376
	377	/*
	378	* bfdd.c
	379	*
	380	* Daemon specific code.
381	*/
7bcadbae	382	struct bfd_vrf_global {
e9e2c950 RZ	383	int bg_shop;
	384	int bg_mhop;
	385	int bg_shop6;
	386	int bg_mhop6;
	387	int bg_echo;
2f11c53f	388	int bg_echov6;
7bcadbae PG	389	struct vrf *vrf;
7bcadbae PG	390
e9e2c950	391	struct thread *bg_ev[6];
7bcadbae	392	};
e9e2c950	393
7bcadbae	394	struct bfd_global {
e9e2c950 RZ	395	int bg_csock;
	396	struct thread *bg_csockev;
	397	struct bcslist bg_bcslist;
	398
	399	struct pllist bg_pllist;
d245e522 RZ	400
d245e522 RZ	401	struct obslist bg_obslist;
f21536d2 PG	402
f21536d2 PG	403	struct zebra_privs_t bfdd_privs;
e9e2c950 RZ	404	};
	405	extern struct bfd_global bglobal;
	406	extern struct bfd_diag_str_list diag_list[];
	407	extern struct bfd_state_str_list state_list[];
	408
	409	void socket_close(int *s);
	410
	411
	412	/*
	413	* config.c
	414	*
	415	* Contains the code related with loading/reloading configuration.
	416	*/
	417	int parse_config(const char *fname);
	418	int config_request_add(const char *jsonstr);
	419	int config_request_del(const char *jsonstr);
	420	char config_response(const char status, const char *error);
	421	char config_notify(struct bfd_session bs);
	422	char config_notify_config(const char op, struct bfd_session *bs);
	423
	424	typedef int (bpc_handle)(struct bfd_peer_cfg , void *arg);
	425	int config_notify_request(struct bfd_control_socket bcs, const char jsonstr,
	426	bpc_handle bh);
	427
	428	struct peer_label pl_new(const char label, struct bfd_session *bs);
	429	struct peer_label pl_find(const char label);
	430	void pl_free(struct peer_label *pl);
	431
	432
	433	/*
	434	* log.c
	435	*
	436	* Contains code that does the logging procedures. Might implement multiple
	437	* backends (e.g. zebra log, syslog or other logging lib).
	438	*/
	439	enum blog_level {
	440	/* level vs syslog equivalent */
	441	BLOG_DEBUG = 0, /* LOG_DEBUG */
	442	BLOG_INFO = 1, /* LOG_INFO */
	443	BLOG_WARNING = 2, /* LOG_WARNING */
	444	BLOG_ERROR = 3, /* LOG_ERR */
	445	BLOG_FATAL = 4, /* LOG_CRIT */
	446	};
	447
	448	void log_init(int foreground, enum blog_level level,
	449	struct frr_daemon_info *fdi);
	450	void log_info(const char *fmt, ...);
	451	void log_debug(const char *fmt, ...);
	452	void log_warning(const char *fmt, ...);
	453	void log_error(const char *fmt, ...);
	454	void log_fatal(const char *fmt, ...);
	455
e9e2c950 RZ	456
	457	/*
	458	* bfd_packet.c
	459	*
	460	* Contains the code related with receiving/seding, packing/unpacking BFD data.
	461	*/
6e01e275 RZ	462	int bp_set_ttlv6(int sd, uint8_t value);
	463	int bp_set_ttl(int sd, uint8_t value);
	464	int bp_set_tosv6(int sd, uint8_t value);
	465	int bp_set_tos(int sd, uint8_t value);
e9e2c950 RZ	466	int bp_bind_dev(int sd, const char *dev);
e9e2c950 RZ	467
7bcadbae PG	468	int bp_udp_shop(vrf_id_t vrf_id);
	469	int bp_udp_mhop(vrf_id_t vrf_id);
	470	int bp_udp6_shop(vrf_id_t vrf_id);
	471	int bp_udp6_mhop(vrf_id_t vrf_id);
9f37770f RZ	472	int bp_peer_socket(const struct bfd_session *bs);
9f37770f RZ	473	int bp_peer_socketv6(const struct bfd_session *bs);
7bcadbae PG	474	int bp_echo_socket(vrf_id_t vrf_id);
7bcadbae PG	475	int bp_echov6_socket(vrf_id_t vrf_id);
e9e2c950 RZ	476
	477	void ptm_bfd_snd(struct bfd_session *bfd, int fbit);
	478	void ptm_bfd_echo_snd(struct bfd_session *bfd);
	479
	480	int bfd_recv_cb(struct thread *t);
	481
e9e2c950 RZ	482
	483	/*
	484	* event.c
	485	*
	486	* Contains the code related with event loop.
	487	*/
	488	typedef void (bfd_ev_cb)(struct thread t);
	489
	490	void bfd_recvtimer_update(struct bfd_session *bs);
	491	void bfd_echo_recvtimer_update(struct bfd_session *bs);
	492	void bfd_xmttimer_update(struct bfd_session *bs, uint64_t jitter);
	493	void bfd_echo_xmttimer_update(struct bfd_session *bs, uint64_t jitter);
	494
	495	void bfd_xmttimer_delete(struct bfd_session *bs);
	496	void bfd_echo_xmttimer_delete(struct bfd_session *bs);
	497	void bfd_recvtimer_delete(struct bfd_session *bs);
	498	void bfd_echo_recvtimer_delete(struct bfd_session *bs);
	499
	500	void bfd_recvtimer_assign(struct bfd_session *bs, bfd_ev_cb cb, int sd);
	501	void bfd_echo_recvtimer_assign(struct bfd_session *bs, bfd_ev_cb cb, int sd);
	502	void bfd_xmttimer_assign(struct bfd_session *bs, bfd_ev_cb cb);
	503	void bfd_echo_xmttimer_assign(struct bfd_session *bs, bfd_ev_cb cb);
	504
	505
	506	/*
	507	* bfd.c
	508	*
	509	* BFD protocol specific code.
	510	*/
9f37770f RZ	511	int bfd_session_enable(struct bfd_session *bs);
9f37770f RZ	512	void bfd_session_disable(struct bfd_session *bs);
e9e2c950	513	struct bfd_session ptm_bfd_sess_new(struct bfd_peer_cfg bpc);
bc50bcc8 PG	514	int ptm_bfd_sess_del(struct bfd_peer_cfg *bpc);
	515	void ptm_bfd_sess_dn(struct bfd_session *bfd, uint8_t diag);
	516	void ptm_bfd_sess_up(struct bfd_session *bfd);
8bd859f6	517	void ptm_bfd_echo_stop(struct bfd_session *bfd);
e9e2c950 RZ	518	void ptm_bfd_echo_start(struct bfd_session *bfd);
	519	void ptm_bfd_xmt_TO(struct bfd_session *bfd, int fbit);
	520	void ptm_bfd_start_xmt_timer(struct bfd_session *bfd, bool is_echo);
9f37770f RZ	521	struct bfd_session ptm_bfd_sess_find(struct bfd_pkt cp,
	522	struct sockaddr_any *peer,
	523	struct sockaddr_any *local,
	524	ifindex_t ifindex, vrf_id_t vrfid,
	525	bool is_mhop);
e9e2c950 RZ	526
	527	struct bfd_session bs_peer_find(struct bfd_peer_cfg bpc);
	528	int bfd_session_update_label(struct bfd_session bs, const char nlabel);
d3f3a2c4	529	void bfd_set_polling(struct bfd_session *bs);
9f37770f RZ	530	void bs_state_handler(struct bfd_session *bs, int nstate);
	531	void bs_echo_timer_handler(struct bfd_session *bs);
	532	void bs_final_handler(struct bfd_session *bs);
b912b189	533	void bs_set_slow_timers(struct bfd_session *bs);
e9e2c950 RZ	534	const char satostr(struct sockaddr_any sa);
	535	const char *diag2str(uint8_t diag);
	536	int strtosa(const char addr, struct sockaddr_any sa);
	537	void integer2timestr(uint64_t time, char *buf, size_t buflen);
79b4a6fc	538	const char bs_to_string(const struct bfd_session bs);
e9e2c950	539
9f37770f RZ	540	int bs_observer_add(struct bfd_session *bs);
9f37770f RZ	541	void bs_observer_del(struct bfd_session_observer *bso);
d245e522	542
79b4a6fc RZ	543	void bs_to_bpc(struct bfd_session bs, struct bfd_peer_cfg bpc);
79b4a6fc RZ	544
014cab13 RZ	545	void gen_bfd_key(struct bfd_key key, struct sockaddr_any peer,
	546	struct sockaddr_any local, bool mhop, const char ifname,
	547	const char *vrfname);
	548	struct bfd_session *bfd_session_new(void);
	549	struct bfd_session bs_registrate(struct bfd_session bs);
	550	void bfd_session_free(struct bfd_session *bs);
adc26455 RZ	551	const struct bfd_session bfd_session_next(const struct bfd_session bs,
adc26455 RZ	552	bool mhop);
2a573ff6	553	void bfd_sessions_remove_manual(void);
adc26455	554
e9e2c950 RZ	555	/* BFD hash data structures interface */
	556	void bfd_initialize(void);
	557	void bfd_shutdown(void);
9fc0bc5c	558	void bfd_vrf_init(void);
7bcadbae PG	559	void bfd_vrf_terminate(void);
7bcadbae PG	560	struct bfd_vrf_global bfd_vrf_look_by_session(struct bfd_session bfd);
e9e2c950	561	struct bfd_session *bfd_id_lookup(uint32_t id);
79b4a6fc	562	struct bfd_session *bfd_key_lookup(struct bfd_key key);
e9e2c950 RZ	563
e9e2c950 RZ	564	struct bfd_session *bfd_id_delete(uint32_t id);
79b4a6fc	565	struct bfd_session *bfd_key_delete(struct bfd_key key);
e9e2c950 RZ	566
e9e2c950 RZ	567	bool bfd_id_insert(struct bfd_session *bs);
79b4a6fc	568	bool bfd_key_insert(struct bfd_session *bs);
e9e2c950	569
e3b78da8	570	typedef void (hash_iter_func)(struct hash_bucket hb, void *arg);
e9e2c950	571	void bfd_id_iterate(hash_iter_func hif, void *arg);
79b4a6fc	572	void bfd_key_iterate(hash_iter_func hif, void *arg);
e9e2c950 RZ	573
	574	/* Export callback functions for `event.c`. */
	575	extern struct thread_master *master;
	576
	577	int bfd_recvtimer_cb(struct thread *t);
	578	int bfd_echo_recvtimer_cb(struct thread *t);
	579	int bfd_xmt_cb(struct thread *t);
	580	int bfd_echo_xmt_cb(struct thread *t);
	581
79b4a6fc RZ	582	extern struct in6_addr zero_addr;
79b4a6fc RZ	583
e9e2c950	584
c2f29cf3 RZ	585	/*
	586	* bfdd_vty.c
	587	*
	588	* BFD daemon vty shell commands.
	589	*/
	590	void bfdd_vty_init(void);
	591
	592
adc26455 RZ	593	/*
	594	* bfdd_cli.c
	595	*
	596	* BFD daemon CLI implementation.
	597	*/
	598	void bfdd_cli_init(void);
	599
0287a64a RZ	600	void bfd_cli_show_header(struct vty vty, struct lyd_node dnode,
	601	bool show_defaults);
	602	void bfd_cli_show_header_end(struct vty vty, struct lyd_node dnode);
	603	void bfd_cli_show_single_hop_peer(struct vty *vty,
	604	struct lyd_node *dnode,
	605	bool show_defaults);
	606	void bfd_cli_show_multi_hop_peer(struct vty *vty,
	607	struct lyd_node *dnode,
	608	bool show_defaults);
	609	void bfd_cli_show_peer_end(struct vty vty, struct lyd_node dnode);
	610	void bfd_cli_show_mult(struct vty vty, struct lyd_node dnode,
	611	bool show_defaults);
	612	void bfd_cli_show_tx(struct vty vty, struct lyd_node dnode,
	613	bool show_defaults);
	614	void bfd_cli_show_rx(struct vty vty, struct lyd_node dnode,
	615	bool show_defaults);
	616	void bfd_cli_show_shutdown(struct vty vty, struct lyd_node dnode,
	617	bool show_defaults);
	618	void bfd_cli_show_echo(struct vty vty, struct lyd_node dnode,
	619	bool show_defaults);
	620	void bfd_cli_show_echo_interval(struct vty vty, struct lyd_node dnode,
	621	bool show_defaults);
	622
adc26455	623
d3af6147 RZ	624	/*
	625	* ptm_adapter.c
	626	*/
	627	void bfdd_zclient_init(struct zebra_privs_t *bfdd_priv);
	628	void bfdd_zclient_stop(void);
54aadda1 PG	629	void bfdd_zclient_unregister(vrf_id_t vrf_id);
54aadda1 PG	630	void bfdd_zclient_register(vrf_id_t vrf_id);
d24af713 PG	631	void bfdd_sessions_enable_vrf(struct vrf *vrf);
d24af713 PG	632	void bfdd_sessions_disable_vrf(struct vrf *vrf);
f06e248c	633	void bfd_session_update_vrf_name(struct bfd_session bs, struct vrf vrf);
d3af6147 RZ	634
	635	int ptm_bfd_notify(struct bfd_session *bs);
	636
adc26455 RZ	637
	638	/*
	639	* bfdd_northbound.c
	640	*
	641	* BFD northbound callbacks.
	642	*/
	643	extern const struct frr_yang_module_info frr_bfdd_info;
	644
e9e2c950	645	#endif /* _BFD_H_ */