// SPDX-License-Identifier: GPL-2.0-or-later
/**
 * ospf_bfd.c: OSPF BFD handling routines
 *
 * @copyright Copyright (C) 2015 Cumulus Networks, Inc.
 */

#include <zebra.h>

#include "command.h"
#include "json.h"
#include "linklist.h"
#include "memory.h"
#include "prefix.h"
#include "frrevent.h"
#include "buffer.h"
#include "stream.h"
#include "zclient.h"
#include "vty.h"
#include "table.h"
#include "bfd.h"
#include "ospfd.h"
#include "ospf_asbr.h"
#include "ospf_lsa.h"
#include "ospf_lsdb.h"
#include "ospf_neighbor.h"
#include "ospf_interface.h"
#include "ospf_nsm.h"
#include "ospf_bfd.h"
#include "ospf_dump.h"
#include "ospf_vty.h"

DEFINE_MTYPE_STATIC(OSPFD, BFD_CONFIG, "BFD configuration data");

/*
 * ospf_bfd_trigger_event - Neighbor is registered/deregistered with BFD when
 *                          neighbor state is changed to/from 2way.
 */
void ospf_bfd_trigger_event(struct ospf_neighbor *nbr, int old_state, int state)
{
	if ((old_state < NSM_TwoWay) && (state >= NSM_TwoWay))
		bfd_sess_install(nbr->bfd_session);
	else if ((old_state >= NSM_TwoWay) && (state < NSM_TwoWay))
		bfd_sess_uninstall(nbr->bfd_session);
}

static void ospf_bfd_session_change(struct bfd_session_params *bsp,
				    const struct bfd_session_status *bss,
				    void *arg)
{
	struct ospf_neighbor *nbr = arg;

	/* BFD peer went down. */
	if (bss->state == BFD_STATUS_DOWN
	    && bss->previous_state == BFD_STATUS_UP) {
		if (IS_DEBUG_OSPF(bfd, BFD_LIB))
			zlog_debug("%s: NSM[%s:%pI4]: BFD Down", __func__,
				   IF_NAME(nbr->oi), &nbr->address.u.prefix4);

		OSPF_NSM_EVENT_SCHEDULE(nbr, NSM_InactivityTimer);
	}

	/* BFD peer went up. */
	if (bss->state == BSS_UP && bss->previous_state == BSS_DOWN)
		if (IS_DEBUG_OSPF(bfd, BFD_LIB))
			zlog_debug("%s: NSM[%s:%pI4]: BFD Up", __func__,
				   IF_NAME(nbr->oi), &nbr->address.u.prefix4);
}

void ospf_neighbor_bfd_apply(struct ospf_neighbor *nbr)
{
	struct ospf_interface *oi = nbr->oi;
	struct ospf_if_params *oip = IF_DEF_PARAMS(oi->ifp);

	/* BFD configuration was removed. */
	if (oip->bfd_config == NULL) {
		bfd_sess_free(&nbr->bfd_session);
		return;
	}

	/* New BFD session. */
	if (nbr->bfd_session == NULL) {
		nbr->bfd_session = bfd_sess_new(ospf_bfd_session_change, nbr);
		bfd_sess_set_ipv4_addrs(nbr->bfd_session, NULL, &nbr->src);
		bfd_sess_set_interface(nbr->bfd_session, oi->ifp->name);
		bfd_sess_set_vrf(nbr->bfd_session, oi->ospf->vrf_id);
	}

	/* Set new configuration. */
	bfd_sess_set_timers(nbr->bfd_session,
			    oip->bfd_config->detection_multiplier,
			    oip->bfd_config->min_rx, oip->bfd_config->min_tx);
	bfd_sess_set_profile(nbr->bfd_session, oip->bfd_config->profile);

	/* Don't start sessions on down OSPF sessions. */
	if (nbr->state < NSM_TwoWay)
		return;

	bfd_sess_install(nbr->bfd_session);
}

static void ospf_interface_bfd_apply(struct interface *ifp)
{
	struct ospf_interface *oi;
	struct route_table *nbrs;
	struct ospf_neighbor *nbr;
	struct route_node *irn;
	struct route_node *nrn;

	/* Iterate over all interfaces and set neighbors BFD session. */
	for (irn = route_top(IF_OIFS(ifp)); irn; irn = route_next(irn)) {
		if ((oi = irn->info) == NULL)
			continue;
		if ((nbrs = oi->nbrs) == NULL)
			continue;
		for (nrn = route_top(nbrs); nrn; nrn = route_next(nrn)) {
			if ((nbr = nrn->info) == NULL || nbr == oi->nbr_self)
				continue;

			ospf_neighbor_bfd_apply(nbr);
		}
	}
}

static void ospf_interface_enable_bfd(struct interface *ifp)
{
	struct ospf_if_params *oip = IF_DEF_PARAMS(ifp);

	if (oip->bfd_config)
		return;

	/* Allocate memory for configurations and set defaults. */
	oip->bfd_config = XCALLOC(MTYPE_BFD_CONFIG, sizeof(*oip->bfd_config));
	oip->bfd_config->detection_multiplier = BFD_DEF_DETECT_MULT;
	oip->bfd_config->min_rx = BFD_DEF_MIN_RX;
	oip->bfd_config->min_tx = BFD_DEF_MIN_TX;
}

void ospf_interface_disable_bfd(struct interface *ifp,
				struct ospf_if_params *oip)
{
	XFREE(MTYPE_BFD_CONFIG, oip->bfd_config);
	ospf_interface_bfd_apply(ifp);
}

/*
 * ospf_bfd_write_config - Write the interface BFD configuration.
 */
void ospf_bfd_write_config(struct vty *vty, const struct ospf_if_params *params
			   __attribute__((unused)))
{
#if HAVE_BFDD == 0
	if (params->bfd_config->detection_multiplier != BFD_DEF_DETECT_MULT
	    || params->bfd_config->min_rx != BFD_DEF_MIN_RX
	    || params->bfd_config->min_tx != BFD_DEF_MIN_TX)
		vty_out(vty, " ip ospf bfd %d %d %d\n",
			params->bfd_config->detection_multiplier,
			params->bfd_config->min_rx, params->bfd_config->min_tx);
	else
#endif /* ! HAVE_BFDD */
		vty_out(vty, " ip ospf bfd\n");

	if (params->bfd_config->profile[0])
		vty_out(vty, " ip ospf bfd profile %s\n",
			params->bfd_config->profile);
}

void ospf_interface_bfd_show(struct vty *vty, const struct interface *ifp,
			     struct json_object *json)
{
	struct ospf_if_params *params = IF_DEF_PARAMS(ifp);
	struct bfd_configuration *bfd_config = params->bfd_config;
	struct json_object *json_bfd;

	if (bfd_config == NULL)
		return;

	if (json) {
		json_bfd = json_object_new_object();
		json_object_int_add(json_bfd, "detectionMultiplier",
				    bfd_config->detection_multiplier);
		json_object_int_add(json_bfd, "rxMinInterval",
				    bfd_config->min_rx);
		json_object_int_add(json_bfd, "txMinInterval",
				    bfd_config->min_tx);
		json_object_object_add(json, "peerBfdInfo", json_bfd);
	} else
		vty_out(vty,
			"  BFD: Detect Multiplier: %d, Min Rx interval: %d, Min Tx interval: %d\n",
			bfd_config->detection_multiplier, bfd_config->min_rx,
			bfd_config->min_tx);
}

DEFUN (ip_ospf_bfd,
       ip_ospf_bfd_cmd,
       "ip ospf bfd",
       "IP Information\n"
       "OSPF interface commands\n"
       "Enables BFD support\n")
{
	VTY_DECLVAR_CONTEXT(interface, ifp);
	ospf_interface_enable_bfd(ifp);
	ospf_interface_bfd_apply(ifp);
	return CMD_SUCCESS;
}

#if HAVE_BFDD > 0
DEFUN_HIDDEN(
#else
DEFUN(
#endif /* HAVE_BFDD */
       ip_ospf_bfd_param,
       ip_ospf_bfd_param_cmd,
       "ip ospf bfd (2-255) (50-60000) (50-60000)",
       "IP Information\n"
       "OSPF interface commands\n"
       "Enables BFD support\n"
       "Detect Multiplier\n"
       "Required min receive interval\n"
       "Desired min transmit interval\n")
{
	VTY_DECLVAR_CONTEXT(interface, ifp);
	struct ospf_if_params *params;
	int idx_number = 3;
	int idx_number_2 = 4;
	int idx_number_3 = 5;

	ospf_interface_enable_bfd(ifp);

	params = IF_DEF_PARAMS(ifp);
	params->bfd_config->detection_multiplier =
		strtol(argv[idx_number]->arg, NULL, 10);
	params->bfd_config->min_rx = strtol(argv[idx_number_2]->arg, NULL, 10);
	params->bfd_config->min_tx = strtol(argv[idx_number_3]->arg, NULL, 10);

	ospf_interface_bfd_apply(ifp);

	return CMD_SUCCESS;
}

DEFUN (ip_ospf_bfd_prof,
       ip_ospf_bfd_prof_cmd,
       "ip ospf bfd profile BFDPROF",
       "IP Information\n"
       "OSPF interface commands\n"
       "Enables BFD support\n"
       BFD_PROFILE_STR
       BFD_PROFILE_NAME_STR)
{
	VTY_DECLVAR_CONTEXT(interface, ifp);
	struct ospf_if_params *params;
	int idx_prof = 4;

	params = IF_DEF_PARAMS(ifp);
	if (!params->bfd_config) {
		vty_out(vty, "ip ospf bfd has not been set\n");
		return CMD_WARNING;
	}

	strlcpy(params->bfd_config->profile, argv[idx_prof]->arg,
		sizeof(params->bfd_config->profile));
	ospf_interface_bfd_apply(ifp);

	return CMD_SUCCESS;
}

DEFUN (no_ip_ospf_bfd_prof,
       no_ip_ospf_bfd_prof_cmd,
       "no ip ospf bfd profile [BFDPROF]",
       NO_STR
       "IP Information\n"
       "OSPF interface commands\n"
       "Enables BFD support\n"
       BFD_PROFILE_STR
       BFD_PROFILE_NAME_STR)
{
	VTY_DECLVAR_CONTEXT(interface, ifp);
	struct ospf_if_params *params;

	params = IF_DEF_PARAMS(ifp);
	if (!params->bfd_config)
		return CMD_SUCCESS;

	params->bfd_config->profile[0] = 0;
	ospf_interface_bfd_apply(ifp);

	return CMD_SUCCESS;
}

DEFUN (no_ip_ospf_bfd,
       no_ip_ospf_bfd_cmd,
#if HAVE_BFDD > 0
       "no ip ospf bfd",
#else
       "no ip ospf bfd [(2-255) (50-60000) (50-60000)]",
#endif /* HAVE_BFDD */
       NO_STR
       "IP Information\n"
       "OSPF interface commands\n"
       "Disables BFD support\n"
#if HAVE_BFDD == 0
       "Detect Multiplier\n"
       "Required min receive interval\n"
       "Desired min transmit interval\n"
#endif /* !HAVE_BFDD */
)
{
	VTY_DECLVAR_CONTEXT(interface, ifp);
	ospf_interface_disable_bfd(ifp, IF_DEF_PARAMS(ifp));
	return CMD_SUCCESS;
}

void ospf_bfd_init(struct event_loop *tm)
{
	bfd_protocol_integration_init(zclient, tm);

	/* Install BFD command */
	install_element(INTERFACE_NODE, &ip_ospf_bfd_cmd);
	install_element(INTERFACE_NODE, &ip_ospf_bfd_param_cmd);
	install_element(INTERFACE_NODE, &ip_ospf_bfd_prof_cmd);
	install_element(INTERFACE_NODE, &no_ip_ospf_bfd_prof_cmd);
	install_element(INTERFACE_NODE, &no_ip_ospf_bfd_cmd);
}
