[mirror_frr.git] / ospf6d / ospf6_bfd.c

/**
 * ospf6_bfd.c: IPv6 OSPF BFD handling routines
 *
 * @copyright Copyright (C) 2015 Cumulus Networks, Inc.
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra 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.
 *
 * GNU Zebra 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
 */

#include <zebra.h>

#include "command.h"
#include "linklist.h"
#include "memory.h"
#include "prefix.h"
#include "thread.h"
#include "buffer.h"
#include "stream.h"
#include "zclient.h"
#include "vty.h"
#include "table.h"
#include "bfd.h"
#include "if.h"
#include "ospf6d.h"
#include "ospf6_message.h"
#include "ospf6_neighbor.h"
#include "ospf6_interface.h"
#include "ospf6_route.h"
#include "ospf6_zebra.h"
#include "ospf6_bfd.h"

extern struct zclient *zclient;

/*
 * ospf6_bfd_info_free - Free BFD info structure
 */
void ospf6_bfd_info_free(void **bfd_info)
{
	bfd_info_free((struct bfd_info **)bfd_info);
}

/*
 * ospf6_bfd_show_info - Show BFD info structure
 */
void ospf6_bfd_show_info(struct vty *vty, void *bfd_info, int param_only)
{
	if (param_only)
		bfd_show_param(vty, bfd_info, 1, 0, 0, NULL);
	else
		bfd_show_info(vty, bfd_info, 0, 1, 0, NULL);
}

/*
 * ospf6_bfd_reg_dereg_nbr - Register/Deregister a neighbor with BFD through
 *                           zebra for starting/stopping the monitoring of
 *                           the neighbor rechahability.
 */
void ospf6_bfd_reg_dereg_nbr(struct ospf6_neighbor *on, int command)
{
	struct ospf6_interface *oi = on->ospf6_if;
	struct interface *ifp = oi->interface;
	struct bfd_info *bfd_info;
	char src[64];
	int cbit;

	if (!oi->bfd_info || !on->bfd_info)
		return;
	bfd_info = (struct bfd_info *)oi->bfd_info;

	if (IS_OSPF6_DEBUG_ZEBRA(SEND)) {
		inet_ntop(AF_INET6, &on->linklocal_addr, src, sizeof(src));
		zlog_debug("%s nbr (%s) with BFD",
			   bfd_get_command_dbg_str(command), src);
	}

	cbit = CHECK_FLAG(bfd_info->flags, BFD_FLAG_BFD_CBIT_ON);

	bfd_peer_sendmsg(zclient, bfd_info, AF_INET6, &on->linklocal_addr,
			 on->ospf6_if->linklocal_addr, ifp->name, 0, 0,
			 cbit, command, 0, VRF_DEFAULT);

	if (command == ZEBRA_BFD_DEST_DEREGISTER)
		bfd_info_free((struct bfd_info **)&on->bfd_info);
}

/*
 * ospf6_bfd_trigger_event - Neighbor is registered/deregistered with BFD when
 *                           neighbor state is changed to/from 2way.
 */
void ospf6_bfd_trigger_event(struct ospf6_neighbor *on, int old_state,
			     int state)
{
	if ((old_state < OSPF6_NEIGHBOR_TWOWAY)
	    && (state >= OSPF6_NEIGHBOR_TWOWAY))
		ospf6_bfd_reg_dereg_nbr(on, ZEBRA_BFD_DEST_REGISTER);
	else if ((old_state >= OSPF6_NEIGHBOR_TWOWAY)
		 && (state < OSPF6_NEIGHBOR_TWOWAY))
		ospf6_bfd_reg_dereg_nbr(on, ZEBRA_BFD_DEST_DEREGISTER);
}

/*
 * ospf6_bfd_reg_dereg_all_nbr - Register/Deregister all neighbors associated
 *                               with a interface with BFD through
 *                               zebra for starting/stopping the monitoring of
 *                               the neighbor rechahability.
 */
static void ospf6_bfd_reg_dereg_all_nbr(struct ospf6_interface *oi, int command)
{
	struct ospf6_neighbor *on;
	struct listnode *node;

	for (ALL_LIST_ELEMENTS_RO(oi->neighbor_list, node, on)) {
		if (command == ZEBRA_BFD_DEST_REGISTER)
			ospf6_bfd_info_nbr_create(oi, on);

		if (on->state < OSPF6_NEIGHBOR_TWOWAY) {
			if (command == ZEBRA_BFD_DEST_DEREGISTER)
				bfd_info_free(
					(struct bfd_info **)&on->bfd_info);
			continue;
		}

		ospf6_bfd_reg_dereg_nbr(on, command);
	}
}

/*
 * ospf6_bfd_nbr_replay - Replay all the neighbors that have BFD enabled
 *                        to zebra
 */
static int ospf6_bfd_nbr_replay(ZAPI_CALLBACK_ARGS)
{
	struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
	struct listnode *node;
	struct interface *ifp;
	struct ospf6_interface *oi;
	struct ospf6_neighbor *on;
	char dst[64];

	if (IS_OSPF6_DEBUG_ZEBRA(RECV))
		zlog_debug("Zebra: BFD Dest replay request");

	/* Send the client registration */
	bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER, vrf_id);

	/* Replay the neighbor, if BFD is enabled on the interface*/
	FOR_ALL_INTERFACES (vrf, ifp) {
		oi = (struct ospf6_interface *)ifp->info;

		if (!oi || !oi->bfd_info)
			continue;

		for (ALL_LIST_ELEMENTS_RO(oi->neighbor_list, node, on)) {
			if (on->state < OSPF6_NEIGHBOR_TWOWAY)
				continue;

			if (IS_OSPF6_DEBUG_ZEBRA(SEND)) {
				inet_ntop(AF_INET6, &on->linklocal_addr, dst,
					  sizeof(dst));
				zlog_debug("Replaying nbr (%s) to BFD", dst);
			}

			ospf6_bfd_reg_dereg_nbr(on, ZEBRA_BFD_DEST_UPDATE);
		}
	}
	return 0;
}

/*
 * ospf6_bfd_interface_dest_update - Find the neighbor for which the BFD status
 *                                   has changed and bring down the neighbor
 *                                   connectivity if BFD down is received.
 */
static int ospf6_bfd_interface_dest_update(ZAPI_CALLBACK_ARGS)
{
	struct interface *ifp;
	struct ospf6_interface *oi;
	struct ospf6_neighbor *on;
	struct prefix dp;
	struct prefix sp;
	struct listnode *node, *nnode;
	char dst[64];
	int status;
	int old_status;
	struct bfd_info *bfd_info;
	struct timeval tv;

	ifp = bfd_get_peer_info(zclient->ibuf, &dp, &sp, &status,
				NULL, vrf_id);

	if ((ifp == NULL) || (dp.family != AF_INET6))
		return 0;

	if (IS_OSPF6_DEBUG_ZEBRA(RECV)) {
		char buf[PREFIX2STR_BUFFER];
		prefix2str(&dp, buf, sizeof(buf));
		zlog_debug("Zebra: interface %s bfd destination %s %s",
			   ifp->name, buf, bfd_get_status_str(status));
	}


	oi = (struct ospf6_interface *)ifp->info;
	if (!oi || !oi->bfd_info)
		return 0;

	for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
		if (memcmp(&(on->linklocal_addr), &dp.u.prefix6,
			   sizeof(struct in6_addr)))
			continue;

		if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT)) {
			inet_ntop(AF_INET6, &on->linklocal_addr, dst,
				  sizeof(dst));
			zlog_debug("[%s:%s]: BFD %s", ifp->name, dst,
				   bfd_get_status_str(status));
		}

		if (!on->bfd_info)
			continue;

		bfd_info = (struct bfd_info *)on->bfd_info;
		if (bfd_info->status == status)
			continue;

		old_status = bfd_info->status;
		BFD_SET_CLIENT_STATUS(bfd_info->status, status);
		monotime(&tv);
		bfd_info->last_update = tv.tv_sec;

		if ((status == BFD_STATUS_DOWN)
		    && (old_status == BFD_STATUS_UP)) {
			THREAD_OFF(on->inactivity_timer);
			thread_add_event(master, inactivity_timer, on, 0, NULL);
		}
	}

	return 0;
}

/*
 * ospf6_bfd_info_nbr_create - Create/update BFD information for a neighbor.
 */
void ospf6_bfd_info_nbr_create(struct ospf6_interface *oi,
			       struct ospf6_neighbor *on)
{
	struct bfd_info *oi_bfd_info;
	struct bfd_info *on_bfd_info;

	if (!oi->bfd_info)
		return;

	oi_bfd_info = (struct bfd_info *)oi->bfd_info;

	if (!on->bfd_info)
		on->bfd_info = bfd_info_create();

	on_bfd_info = (struct bfd_info *)on->bfd_info;
	on_bfd_info->detect_mult = oi_bfd_info->detect_mult;
	on_bfd_info->desired_min_tx = oi_bfd_info->desired_min_tx;
	on_bfd_info->required_min_rx = oi_bfd_info->required_min_rx;
}

/*
 * ospf6_bfd_write_config - Write the interface BFD configuration.
 */
void ospf6_bfd_write_config(struct vty *vty, struct ospf6_interface *oi)
{
#if HAVE_BFDD == 0
	struct bfd_info *bfd_info;
#endif /* ! HAVE_BFDD */

	if (!oi->bfd_info)
		return;

#if HAVE_BFDD == 0
	bfd_info = (struct bfd_info *)oi->bfd_info;

	if (CHECK_FLAG(bfd_info->flags, BFD_FLAG_PARAM_CFG))
		vty_out(vty, " ipv6 ospf6 bfd %d %d %d\n",
			bfd_info->detect_mult, bfd_info->required_min_rx,
			bfd_info->desired_min_tx);
	else
#endif /* ! HAVE_BFDD */
		vty_out(vty, " ipv6 ospf6 bfd\n");
}

/*
 * ospf6_bfd_if_param_set - Set the configured BFD paramter values for
 *                            interface.
 */
static void ospf6_bfd_if_param_set(struct ospf6_interface *oi, uint32_t min_rx,
				   uint32_t min_tx, uint8_t detect_mult,
				   int defaults)
{
	int command = 0;

	bfd_set_param((struct bfd_info **)&(oi->bfd_info), min_rx, min_tx,
		      detect_mult, defaults, &command);
	if (command)
		ospf6_bfd_reg_dereg_all_nbr(oi, command);
}

DEFUN (ipv6_ospf6_bfd,
       ipv6_ospf6_bfd_cmd,
       "ipv6 ospf6 bfd",
       IP6_STR
       OSPF6_STR
       "Enables BFD support\n"
       )
{
	VTY_DECLVAR_CONTEXT(interface, ifp);
	struct ospf6_interface *oi;
	assert(ifp);

	oi = (struct ospf6_interface *)ifp->info;
	if (oi == NULL)
		oi = ospf6_interface_create(ifp);
	assert(oi);

	ospf6_bfd_if_param_set(oi, BFD_DEF_MIN_RX, BFD_DEF_MIN_TX,
			       BFD_DEF_DETECT_MULT, 1);
	return CMD_SUCCESS;
}

#if HAVE_BFDD > 0
DEFUN_HIDDEN(
#else
DEFUN(
#endif /* HAVE_BFDD */
       ipv6_ospf6_bfd_param,
       ipv6_ospf6_bfd_param_cmd,
       "ipv6 ospf6 bfd (2-255) (50-60000) (50-60000)",
       IP6_STR
       OSPF6_STR
       "Enables BFD support\n"
       "Detect Multiplier\n"
       "Required min receive interval\n"
       "Desired min transmit interval\n")
{
	VTY_DECLVAR_CONTEXT(interface, ifp);
	int idx_number = 3;
	int idx_number_2 = 4;
	int idx_number_3 = 5;
	struct ospf6_interface *oi;
	uint32_t rx_val;
	uint32_t tx_val;
	uint8_t dm_val;
	int ret;

	assert(ifp);

	oi = (struct ospf6_interface *)ifp->info;
	if (oi == NULL)
		oi = ospf6_interface_create(ifp);
	assert(oi);

	if ((ret = bfd_validate_param(
		     vty, argv[idx_number]->arg, argv[idx_number_2]->arg,
		     argv[idx_number_3]->arg, &dm_val, &rx_val, &tx_val))
	    != CMD_SUCCESS)
		return ret;

	ospf6_bfd_if_param_set(oi, rx_val, tx_val, dm_val, 0);

	return CMD_SUCCESS;
}

DEFUN (no_ipv6_ospf6_bfd,
       no_ipv6_ospf6_bfd_cmd,
       "no ipv6 ospf6 bfd",
       NO_STR
       IP6_STR
       OSPF6_STR
       "Disables BFD support\n"
       )
{
	VTY_DECLVAR_CONTEXT(interface, ifp);
	struct ospf6_interface *oi;
	assert(ifp);

	oi = (struct ospf6_interface *)ifp->info;
	if (oi == NULL)
		oi = ospf6_interface_create(ifp);
	assert(oi);

	if (oi->bfd_info) {
		ospf6_bfd_reg_dereg_all_nbr(oi, ZEBRA_BFD_DEST_DEREGISTER);
		bfd_info_free((struct bfd_info **)&(oi->bfd_info));
	}

	return CMD_SUCCESS;
}

void ospf6_bfd_init(void)
{
	bfd_gbl_init();

	/* Initialize BFD client functions */
	zclient->interface_bfd_dest_update = ospf6_bfd_interface_dest_update;
	zclient->bfd_dest_replay = ospf6_bfd_nbr_replay;

	/* Install BFD command */
	install_element(INTERFACE_NODE, &ipv6_ospf6_bfd_cmd);
	install_element(INTERFACE_NODE, &ipv6_ospf6_bfd_param_cmd);
	install_element(INTERFACE_NODE, &no_ipv6_ospf6_bfd_cmd);
}
Commit	Line	Data
7f342629 DS	1	/**
	2	* ospf6_bfd.c: IPv6 OSPF BFD handling routines
	3	*
	4	* @copyright Copyright (C) 2015 Cumulus Networks, Inc.
	5	*
	6	* This file is part of GNU Zebra.
	7	*
	8	* GNU Zebra 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	* GNU Zebra 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	*
896014f4 DL	18	* You should have received a copy of the GNU General Public License along
	19	* with this program; see the file COPYING; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
7f342629 DS	21	*/
	22
	23	#include <zebra.h>
	24
	25	#include "command.h"
	26	#include "linklist.h"
	27	#include "memory.h"
	28	#include "prefix.h"
	29	#include "thread.h"
	30	#include "buffer.h"
	31	#include "stream.h"
	32	#include "zclient.h"
	33	#include "vty.h"
	34	#include "table.h"
	35	#include "bfd.h"
	36	#include "if.h"
	37	#include "ospf6d.h"
	38	#include "ospf6_message.h"
	39	#include "ospf6_neighbor.h"
	40	#include "ospf6_interface.h"
	41	#include "ospf6_route.h"
	42	#include "ospf6_zebra.h"
	43	#include "ospf6_bfd.h"
	44
	45	extern struct zclient *zclient;
	46
68fe91d6	47	/*
	48	* ospf6_bfd_info_free - Free BFD info structure
	49	*/
d62a17ae	50	void ospf6_bfd_info_free(void **bfd_info)
68fe91d6	51	{
d62a17ae	52	bfd_info_free((struct bfd_info **)bfd_info);
68fe91d6	53	}
	54
	55	/*
	56	* ospf6_bfd_show_info - Show BFD info structure
	57	*/
d62a17ae	58	void ospf6_bfd_show_info(struct vty vty, void bfd_info, int param_only)
68fe91d6	59	{
d62a17ae	60	if (param_only)
	61	bfd_show_param(vty, bfd_info, 1, 0, 0, NULL);
	62	else
	63	bfd_show_info(vty, bfd_info, 0, 1, 0, NULL);
68fe91d6	64	}
68fe91d6	65
7f342629 DS	66	/*
	67	* ospf6_bfd_reg_dereg_nbr - Register/Deregister a neighbor with BFD through
	68	* zebra for starting/stopping the monitoring of
	69	* the neighbor rechahability.
	70	*/
d62a17ae	71	void ospf6_bfd_reg_dereg_nbr(struct ospf6_neighbor *on, int command)
7f342629	72	{
d62a17ae	73	struct ospf6_interface *oi = on->ospf6_if;
	74	struct interface *ifp = oi->interface;
	75	struct bfd_info *bfd_info;
	76	char src[64];
9beff0bd	77	int cbit;
d62a17ae	78
	79	if (!oi->bfd_info \|\| !on->bfd_info)
	80	return;
	81	bfd_info = (struct bfd_info *)oi->bfd_info;
	82
	83	if (IS_OSPF6_DEBUG_ZEBRA(SEND)) {
	84	inet_ntop(AF_INET6, &on->linklocal_addr, src, sizeof(src));
	85	zlog_debug("%s nbr (%s) with BFD",
	86	bfd_get_command_dbg_str(command), src);
	87	}
	88
9beff0bd PG	89	cbit = CHECK_FLAG(bfd_info->flags, BFD_FLAG_BFD_CBIT_ON);
9beff0bd PG	90
d62a17ae	91	bfd_peer_sendmsg(zclient, bfd_info, AF_INET6, &on->linklocal_addr,
9beff0bd PG	92	on->ospf6_if->linklocal_addr, ifp->name, 0, 0,
9beff0bd PG	93	cbit, command, 0, VRF_DEFAULT);
d62a17ae	94
	95	if (command == ZEBRA_BFD_DEST_DEREGISTER)
	96	bfd_info_free((struct bfd_info **)&on->bfd_info);
7f342629 DS	97	}
	98
	99	/*
	100	* ospf6_bfd_trigger_event - Neighbor is registered/deregistered with BFD when
	101	* neighbor state is changed to/from 2way.
	102	*/
d62a17ae	103	void ospf6_bfd_trigger_event(struct ospf6_neighbor *on, int old_state,
d62a17ae	104	int state)
7f342629	105	{
d62a17ae	106	if ((old_state < OSPF6_NEIGHBOR_TWOWAY)
	107	&& (state >= OSPF6_NEIGHBOR_TWOWAY))
	108	ospf6_bfd_reg_dereg_nbr(on, ZEBRA_BFD_DEST_REGISTER);
	109	else if ((old_state >= OSPF6_NEIGHBOR_TWOWAY)
	110	&& (state < OSPF6_NEIGHBOR_TWOWAY))
	111	ospf6_bfd_reg_dereg_nbr(on, ZEBRA_BFD_DEST_DEREGISTER);
7f342629 DS	112	}
	113
	114	/*
	115	* ospf6_bfd_reg_dereg_all_nbr - Register/Deregister all neighbors associated
	116	* with a interface with BFD through
	117	* zebra for starting/stopping the monitoring of
	118	* the neighbor rechahability.
	119	*/
d62a17ae	120	static void ospf6_bfd_reg_dereg_all_nbr(struct ospf6_interface *oi, int command)
7f342629	121	{
d62a17ae	122	struct ospf6_neighbor *on;
	123	struct listnode *node;
	124
	125	for (ALL_LIST_ELEMENTS_RO(oi->neighbor_list, node, on)) {
	126	if (command == ZEBRA_BFD_DEST_REGISTER)
	127	ospf6_bfd_info_nbr_create(oi, on);
	128
	129	if (on->state < OSPF6_NEIGHBOR_TWOWAY) {
	130	if (command == ZEBRA_BFD_DEST_DEREGISTER)
	131	bfd_info_free(
	132	(struct bfd_info **)&on->bfd_info);
	133	continue;
	134	}
	135
	136	ospf6_bfd_reg_dereg_nbr(on, command);
	137	}
7f342629 DS	138	}
	139
	140	/*
	141	* ospf6_bfd_nbr_replay - Replay all the neighbors that have BFD enabled
	142	* to zebra
	143	*/
121f9dee	144	static int ospf6_bfd_nbr_replay(ZAPI_CALLBACK_ARGS)
7f342629	145	{
f4e14fdb RW	146	struct vrf *vrf = vrf_lookup_by_id(VRF_DEFAULT);
f4e14fdb RW	147	struct listnode *node;
d62a17ae	148	struct interface *ifp;
	149	struct ospf6_interface *oi;
	150	struct ospf6_neighbor *on;
	151	char dst[64];
	152
	153	if (IS_OSPF6_DEBUG_ZEBRA(RECV))
	154	zlog_debug("Zebra: BFD Dest replay request");
	155
	156	/* Send the client registration */
0945d5ed	157	bfd_client_sendmsg(zclient, ZEBRA_BFD_CLIENT_REGISTER, vrf_id);
d62a17ae	158
d62a17ae	159	/* Replay the neighbor, if BFD is enabled on the interface*/
451fda4f	160	FOR_ALL_INTERFACES (vrf, ifp) {
d62a17ae	161	oi = (struct ospf6_interface *)ifp->info;
	162
	163	if (!oi \|\| !oi->bfd_info)
	164	continue;
	165
f4e14fdb	166	for (ALL_LIST_ELEMENTS_RO(oi->neighbor_list, node, on)) {
d62a17ae	167	if (on->state < OSPF6_NEIGHBOR_TWOWAY)
	168	continue;
	169
	170	if (IS_OSPF6_DEBUG_ZEBRA(SEND)) {
	171	inet_ntop(AF_INET6, &on->linklocal_addr, dst,
	172	sizeof(dst));
	173	zlog_debug("Replaying nbr (%s) to BFD", dst);
	174	}
	175
	176	ospf6_bfd_reg_dereg_nbr(on, ZEBRA_BFD_DEST_UPDATE);
	177	}
	178	}
	179	return 0;
7f342629 DS	180	}
	181
	182	/*
68fe91d6	183	* ospf6_bfd_interface_dest_update - Find the neighbor for which the BFD status
	184	* has changed and bring down the neighbor
	185	* connectivity if BFD down is received.
7f342629	186	*/
121f9dee	187	static int ospf6_bfd_interface_dest_update(ZAPI_CALLBACK_ARGS)
7f342629	188	{
d62a17ae	189	struct interface *ifp;
	190	struct ospf6_interface *oi;
	191	struct ospf6_neighbor *on;
	192	struct prefix dp;
	193	struct prefix sp;
	194	struct listnode node, nnode;
	195	char dst[64];
	196	int status;
	197	int old_status;
	198	struct bfd_info *bfd_info;
	199	struct timeval tv;
	200
9beff0bd PG	201	ifp = bfd_get_peer_info(zclient->ibuf, &dp, &sp, &status,
9beff0bd PG	202	NULL, vrf_id);
d62a17ae	203
	204	if ((ifp == NULL) \|\| (dp.family != AF_INET6))
	205	return 0;
	206
	207	if (IS_OSPF6_DEBUG_ZEBRA(RECV)) {
	208	char buf[PREFIX2STR_BUFFER];
	209	prefix2str(&dp, buf, sizeof(buf));
	210	zlog_debug("Zebra: interface %s bfd destination %s %s",
	211	ifp->name, buf, bfd_get_status_str(status));
	212	}
	213
	214
	215	oi = (struct ospf6_interface *)ifp->info;
	216	if (!oi \|\| !oi->bfd_info)
	217	return 0;
	218
	219	for (ALL_LIST_ELEMENTS(oi->neighbor_list, node, nnode, on)) {
	220	if (memcmp(&(on->linklocal_addr), &dp.u.prefix6,
	221	sizeof(struct in6_addr)))
	222	continue;
	223
	224	if (IS_OSPF6_DEBUG_NEIGHBOR(EVENT)) {
	225	inet_ntop(AF_INET6, &on->linklocal_addr, dst,
	226	sizeof(dst));
	227	zlog_debug("[%s:%s]: BFD %s", ifp->name, dst,
	228	bfd_get_status_str(status));
	229	}
	230
	231	if (!on->bfd_info)
	232	continue;
	233
	234	bfd_info = (struct bfd_info *)on->bfd_info;
	235	if (bfd_info->status == status)
	236	continue;
	237
	238	old_status = bfd_info->status;
7555dc61	239	BFD_SET_CLIENT_STATUS(bfd_info->status, status);
d62a17ae	240	monotime(&tv);
	241	bfd_info->last_update = tv.tv_sec;
	242
	243	if ((status == BFD_STATUS_DOWN)
	244	&& (old_status == BFD_STATUS_UP)) {
	245	THREAD_OFF(on->inactivity_timer);
	246	thread_add_event(master, inactivity_timer, on, 0, NULL);
	247	}
	248	}
	249
	250	return 0;
7f342629 DS	251	}
7f342629 DS	252
68fe91d6	253	/*
	254	* ospf6_bfd_info_nbr_create - Create/update BFD information for a neighbor.
	255	*/
d62a17ae	256	void ospf6_bfd_info_nbr_create(struct ospf6_interface *oi,
d62a17ae	257	struct ospf6_neighbor *on)
68fe91d6	258	{
d62a17ae	259	struct bfd_info *oi_bfd_info;
d62a17ae	260	struct bfd_info *on_bfd_info;
68fe91d6	261
d62a17ae	262	if (!oi->bfd_info)
d62a17ae	263	return;
68fe91d6	264
d62a17ae	265	oi_bfd_info = (struct bfd_info *)oi->bfd_info;
68fe91d6	266
d62a17ae	267	if (!on->bfd_info)
d62a17ae	268	on->bfd_info = bfd_info_create();
68fe91d6	269
d62a17ae	270	on_bfd_info = (struct bfd_info *)on->bfd_info;
	271	on_bfd_info->detect_mult = oi_bfd_info->detect_mult;
	272	on_bfd_info->desired_min_tx = oi_bfd_info->desired_min_tx;
	273	on_bfd_info->required_min_rx = oi_bfd_info->required_min_rx;
68fe91d6	274	}
68fe91d6	275
7f342629 DS	276	/*
	277	* ospf6_bfd_write_config - Write the interface BFD configuration.
	278	*/
d62a17ae	279	void ospf6_bfd_write_config(struct vty vty, struct ospf6_interface oi)
7f342629	280	{
a0841732	281	#if HAVE_BFDD == 0
d62a17ae	282	struct bfd_info *bfd_info;
a0841732	283	#endif /* ! HAVE_BFDD */
7f342629	284
d62a17ae	285	if (!oi->bfd_info)
d62a17ae	286	return;
7f342629	287
a0841732	288	#if HAVE_BFDD == 0
d62a17ae	289	bfd_info = (struct bfd_info *)oi->bfd_info;
7f342629	290
d62a17ae	291	if (CHECK_FLAG(bfd_info->flags, BFD_FLAG_PARAM_CFG))
	292	vty_out(vty, " ipv6 ospf6 bfd %d %d %d\n",
	293	bfd_info->detect_mult, bfd_info->required_min_rx,
	294	bfd_info->desired_min_tx);
	295	else
a0841732	296	#endif /* ! HAVE_BFDD */
d62a17ae	297	vty_out(vty, " ipv6 ospf6 bfd\n");
7f342629 DS	298	}
	299
	300	/*
	301	* ospf6_bfd_if_param_set - Set the configured BFD paramter values for
	302	* interface.
	303	*/
d7c0a89a QY	304	static void ospf6_bfd_if_param_set(struct ospf6_interface *oi, uint32_t min_rx,
d7c0a89a QY	305	uint32_t min_tx, uint8_t detect_mult,
d62a17ae	306	int defaults)
7f342629	307	{
d62a17ae	308	int command = 0;
7f342629	309
d62a17ae	310	bfd_set_param((struct bfd_info **)&(oi->bfd_info), min_rx, min_tx,
	311	detect_mult, defaults, &command);
	312	if (command)
	313	ospf6_bfd_reg_dereg_all_nbr(oi, command);
7f342629 DS	314	}
	315
	316	DEFUN (ipv6_ospf6_bfd,
	317	ipv6_ospf6_bfd_cmd,
	318	"ipv6 ospf6 bfd",
	319	IP6_STR
	320	OSPF6_STR
	321	"Enables BFD support\n"
	322	)
	323	{
d62a17ae	324	VTY_DECLVAR_CONTEXT(interface, ifp);
	325	struct ospf6_interface *oi;
	326	assert(ifp);
	327
	328	oi = (struct ospf6_interface *)ifp->info;
	329	if (oi == NULL)
	330	oi = ospf6_interface_create(ifp);
	331	assert(oi);
	332
	333	ospf6_bfd_if_param_set(oi, BFD_DEF_MIN_RX, BFD_DEF_MIN_TX,
	334	BFD_DEF_DETECT_MULT, 1);
	335	return CMD_SUCCESS;
7f342629 DS	336	}
7f342629 DS	337
64dc4b2d RZ	338	#if HAVE_BFDD > 0
	339	DEFUN_HIDDEN(
	340	#else
	341	DEFUN(
	342	#endif /* HAVE_BFDD */
	343	ipv6_ospf6_bfd_param,
7f342629	344	ipv6_ospf6_bfd_param_cmd,
9ccf14f7	345	"ipv6 ospf6 bfd (2-255) (50-60000) (50-60000)",
7f342629 DS	346	IP6_STR
	347	OSPF6_STR
	348	"Enables BFD support\n"
	349	"Detect Multiplier\n"
	350	"Required min receive interval\n"
	351	"Desired min transmit interval\n")
	352	{
d62a17ae	353	VTY_DECLVAR_CONTEXT(interface, ifp);
	354	int idx_number = 3;
	355	int idx_number_2 = 4;
	356	int idx_number_3 = 5;
	357	struct ospf6_interface *oi;
d7c0a89a QY	358	uint32_t rx_val;
	359	uint32_t tx_val;
	360	uint8_t dm_val;
d62a17ae	361	int ret;
	362
	363	assert(ifp);
	364
	365	oi = (struct ospf6_interface *)ifp->info;
	366	if (oi == NULL)
	367	oi = ospf6_interface_create(ifp);
	368	assert(oi);
	369
	370	if ((ret = bfd_validate_param(
	371	vty, argv[idx_number]->arg, argv[idx_number_2]->arg,
	372	argv[idx_number_3]->arg, &dm_val, &rx_val, &tx_val))
	373	!= CMD_SUCCESS)
	374	return ret;
	375
	376	ospf6_bfd_if_param_set(oi, rx_val, tx_val, dm_val, 0);
	377
	378	return CMD_SUCCESS;
7f342629 DS	379	}
	380
	381	DEFUN (no_ipv6_ospf6_bfd,
	382	no_ipv6_ospf6_bfd_cmd,
	383	"no ipv6 ospf6 bfd",
	384	NO_STR
	385	IP6_STR
	386	OSPF6_STR
	387	"Disables BFD support\n"
	388	)
	389	{
d62a17ae	390	VTY_DECLVAR_CONTEXT(interface, ifp);
	391	struct ospf6_interface *oi;
	392	assert(ifp);
	393
	394	oi = (struct ospf6_interface *)ifp->info;
	395	if (oi == NULL)
	396	oi = ospf6_interface_create(ifp);
	397	assert(oi);
	398
	399	if (oi->bfd_info) {
	400	ospf6_bfd_reg_dereg_all_nbr(oi, ZEBRA_BFD_DEST_DEREGISTER);
	401	bfd_info_free((struct bfd_info **)&(oi->bfd_info));
	402	}
	403
	404	return CMD_SUCCESS;
7f342629 DS	405	}
7f342629 DS	406
d62a17ae	407	void ospf6_bfd_init(void)
7f342629	408	{
d62a17ae	409	bfd_gbl_init();
567b877d	410
d62a17ae	411	/* Initialize BFD client functions */
	412	zclient->interface_bfd_dest_update = ospf6_bfd_interface_dest_update;
	413	zclient->bfd_dest_replay = ospf6_bfd_nbr_replay;
7f342629	414
d62a17ae	415	/* Install BFD command */
	416	install_element(INTERFACE_NODE, &ipv6_ospf6_bfd_cmd);
	417	install_element(INTERFACE_NODE, &ipv6_ospf6_bfd_param_cmd);
	418	install_element(INTERFACE_NODE, &no_ipv6_ospf6_bfd_cmd);
7f342629	419	}