2023-02-08 13:17:09 +01:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2018-05-09 06:34:57 +02:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1997, 1998, 1999 Kunihiro Ishiguro <kunihiro@zebra.org>
|
|
|
|
* Copyright (C) 2018 NetDEF, Inc.
|
|
|
|
* Renato Westphal
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <zebra.h>
|
|
|
|
|
|
|
|
#include "if.h"
|
2024-01-19 17:40:12 +01:00
|
|
|
#include "if_rmap.h"
|
2018-05-09 06:34:57 +02:00
|
|
|
#include "vrf.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "prefix.h"
|
|
|
|
#include "command.h"
|
|
|
|
#include "northbound_cli.h"
|
|
|
|
#include "libfrr.h"
|
|
|
|
|
|
|
|
#include "ripd/ripd.h"
|
2019-10-17 20:46:54 +02:00
|
|
|
#include "ripd/rip_nb.h"
|
2018-05-09 06:34:57 +02:00
|
|
|
#include "ripd/rip_cli_clippy.c"
|
|
|
|
|
2018-05-09 06:34:58 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG_NOSH (router_rip,
|
2018-05-09 06:34:58 +02:00
|
|
|
router_rip_cmd,
|
2019-01-04 22:08:10 +01:00
|
|
|
"router rip [vrf NAME]",
|
2018-05-09 06:34:58 +02:00
|
|
|
"Enable a routing process\n"
|
2019-01-04 22:08:10 +01:00
|
|
|
"Routing Information Protocol (RIP)\n"
|
|
|
|
VRF_CMD_HELP_STR)
|
2018-05-09 06:34:58 +02:00
|
|
|
{
|
2019-01-04 22:08:10 +01:00
|
|
|
char xpath[XPATH_MAXLEN];
|
2018-05-09 06:34:58 +02:00
|
|
|
int ret;
|
|
|
|
|
2019-01-04 22:08:10 +01:00
|
|
|
/* Build RIP instance XPath. */
|
|
|
|
if (!vrf)
|
|
|
|
vrf = VRF_DEFAULT_NAME;
|
|
|
|
snprintf(xpath, sizeof(xpath), "/frr-ripd:ripd/instance[vrf='%s']",
|
|
|
|
vrf);
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, xpath, NB_OP_CREATE, NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
ret = nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:34:58 +02:00
|
|
|
if (ret == CMD_SUCCESS)
|
2019-01-04 22:08:10 +01:00
|
|
|
VTY_PUSH_XPATH(RIP_NODE, xpath);
|
2018-05-09 06:34:58 +02:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_router_rip,
|
2018-05-09 06:34:58 +02:00
|
|
|
no_router_rip_cmd,
|
2019-01-04 22:08:10 +01:00
|
|
|
"no router rip [vrf NAME]",
|
2018-05-09 06:34:58 +02:00
|
|
|
NO_STR
|
|
|
|
"Enable a routing process\n"
|
2019-01-04 22:08:10 +01:00
|
|
|
"Routing Information Protocol (RIP)\n"
|
|
|
|
VRF_CMD_HELP_STR)
|
2018-05-09 06:34:58 +02:00
|
|
|
{
|
2019-01-04 22:08:10 +01:00
|
|
|
char xpath[XPATH_MAXLEN];
|
|
|
|
|
|
|
|
/* Build RIP instance XPath. */
|
|
|
|
if (!vrf)
|
|
|
|
vrf = VRF_DEFAULT_NAME;
|
|
|
|
snprintf(xpath, sizeof(xpath), "/frr-ripd:ripd/instance[vrf='%s']",
|
|
|
|
vrf);
|
|
|
|
|
2019-03-02 19:00:46 +01:00
|
|
|
nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
2021-05-28 21:16:18 +02:00
|
|
|
return nb_cli_apply_changes_clear_pending(vty, NULL);
|
2018-05-09 06:34:58 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_router_rip(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:34:58 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
2019-01-04 22:08:10 +01:00
|
|
|
const char *vrf_name;
|
|
|
|
|
2023-11-29 20:37:23 +01:00
|
|
|
vrf_name = yang_dnode_get_string(dnode, "vrf");
|
2019-01-04 22:08:10 +01:00
|
|
|
|
2018-05-09 06:34:58 +02:00
|
|
|
vty_out(vty, "!\n");
|
2019-01-04 22:08:10 +01:00
|
|
|
vty_out(vty, "router rip");
|
|
|
|
if (!strmatch(vrf_name, VRF_DEFAULT_NAME))
|
|
|
|
vty_out(vty, " vrf %s", vrf_name);
|
|
|
|
vty_out(vty, "\n");
|
2018-05-09 06:34:58 +02:00
|
|
|
}
|
|
|
|
|
2018-05-09 06:34:58 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/allow-ecmp
|
|
|
|
*/
|
2023-05-04 08:13:07 +02:00
|
|
|
DEFUN_YANG (rip_allow_ecmp,
|
2018-05-09 06:34:58 +02:00
|
|
|
rip_allow_ecmp_cmd,
|
2023-05-04 08:13:07 +02:00
|
|
|
"allow-ecmp [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]",
|
|
|
|
"Allow Equal Cost MultiPath\n"
|
|
|
|
"Number of paths\n")
|
|
|
|
{
|
2023-05-23 08:20:27 +02:00
|
|
|
int idx_number = 0;
|
2023-05-04 08:13:07 +02:00
|
|
|
char mpaths[3] = {};
|
|
|
|
uint32_t paths = MULTIPATH_NUM;
|
|
|
|
|
2023-05-23 08:20:27 +02:00
|
|
|
if (argv_find(argv, argc, CMD_RANGE_STR(1, MULTIPATH_NUM), &idx_number))
|
2023-05-04 08:13:07 +02:00
|
|
|
paths = strtol(argv[idx_number]->arg, NULL, 10);
|
|
|
|
snprintf(mpaths, sizeof(mpaths), "%u", paths);
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, "./allow-ecmp", NB_OP_MODIFY, mpaths);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFUN_YANG (no_rip_allow_ecmp,
|
|
|
|
no_rip_allow_ecmp_cmd,
|
|
|
|
"no allow-ecmp [" CMD_RANGE_STR(1, MULTIPATH_NUM) "]",
|
2018-05-09 06:34:58 +02:00
|
|
|
NO_STR
|
2023-05-04 08:13:07 +02:00
|
|
|
"Allow Equal Cost MultiPath\n"
|
|
|
|
"Number of paths\n")
|
2018-05-09 06:34:58 +02:00
|
|
|
{
|
2023-05-04 08:13:07 +02:00
|
|
|
nb_cli_enqueue_change(vty, "./allow-ecmp", NB_OP_MODIFY, 0);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:34:58 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_allow_ecmp(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:34:58 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
2023-05-04 08:13:07 +02:00
|
|
|
uint8_t paths;
|
|
|
|
|
|
|
|
paths = yang_dnode_get_uint8(dnode, NULL);
|
2018-05-09 06:34:58 +02:00
|
|
|
|
2023-05-04 08:13:07 +02:00
|
|
|
if (!paths)
|
|
|
|
vty_out(vty, " no allow-ecmp\n");
|
|
|
|
else
|
|
|
|
vty_out(vty, " allow-ecmp %d\n", paths);
|
2018-05-09 06:34:58 +02:00
|
|
|
}
|
|
|
|
|
2018-05-09 06:34:58 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/default-information-originate
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_default_information_originate,
|
2018-05-09 06:34:58 +02:00
|
|
|
rip_default_information_originate_cmd,
|
|
|
|
"[no] default-information originate",
|
|
|
|
NO_STR
|
|
|
|
"Control distribution of default route\n"
|
|
|
|
"Distribute a default route\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./default-information-originate",
|
|
|
|
NB_OP_MODIFY, no ? "false" : "true");
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:34:58 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void cli_show_rip_default_information_originate(struct vty *vty,
|
2021-10-13 19:08:37 +02:00
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:34:58 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
if (!yang_dnode_get_bool(dnode, NULL))
|
|
|
|
vty_out(vty, " no");
|
|
|
|
|
|
|
|
vty_out(vty, " default-information originate\n");
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:34:59 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/default-metric
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_default_metric,
|
2018-05-09 06:34:59 +02:00
|
|
|
rip_default_metric_cmd,
|
|
|
|
"default-metric (1-16)",
|
|
|
|
"Set a metric of redistribute routes\n"
|
|
|
|
"Default metric\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./default-metric", NB_OP_MODIFY,
|
|
|
|
default_metric_str);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:34:59 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_rip_default_metric,
|
2018-05-09 06:34:59 +02:00
|
|
|
no_rip_default_metric_cmd,
|
|
|
|
"no default-metric [(1-16)]",
|
|
|
|
NO_STR
|
|
|
|
"Set a metric of redistribute routes\n"
|
|
|
|
"Default metric\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./default-metric", NB_OP_MODIFY, NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:34:59 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_default_metric(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:34:59 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " default-metric %s\n",
|
|
|
|
yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:34:59 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/distance/default
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_distance,
|
2018-05-09 06:34:59 +02:00
|
|
|
rip_distance_cmd,
|
|
|
|
"distance (1-255)",
|
|
|
|
"Administrative distance\n"
|
|
|
|
"Distance value\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./distance/default", NB_OP_MODIFY,
|
|
|
|
distance_str);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:34:59 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_rip_distance,
|
2018-05-09 06:34:59 +02:00
|
|
|
no_rip_distance_cmd,
|
|
|
|
"no distance [(1-255)]",
|
|
|
|
NO_STR
|
|
|
|
"Administrative distance\n"
|
|
|
|
"Distance value\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./distance/default", NB_OP_MODIFY, NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:34:59 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_distance(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:34:59 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
2018-11-25 00:55:25 +01:00
|
|
|
if (yang_dnode_is_default(dnode, NULL))
|
|
|
|
vty_out(vty, " no distance\n");
|
|
|
|
else
|
|
|
|
vty_out(vty, " distance %s\n",
|
|
|
|
yang_dnode_get_string(dnode, NULL));
|
2018-05-09 06:34:59 +02:00
|
|
|
}
|
|
|
|
|
2018-05-09 06:34:59 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/distance/source
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_distance_source,
|
2018-05-09 06:34:59 +02:00
|
|
|
rip_distance_source_cmd,
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
"[no] distance (1-255) A.B.C.D/M$prefix [WORD$acl]",
|
2018-05-09 06:34:59 +02:00
|
|
|
NO_STR
|
|
|
|
"Administrative distance\n"
|
|
|
|
"Distance value\n"
|
|
|
|
"IP source prefix\n"
|
|
|
|
"Access list name\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
if (!no) {
|
|
|
|
nb_cli_enqueue_change(vty, ".", NB_OP_CREATE, NULL);
|
2018-11-29 20:06:22 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./distance", NB_OP_MODIFY,
|
|
|
|
distance_str);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./access-list",
|
2019-01-30 10:54:25 +01:00
|
|
|
acl ? NB_OP_MODIFY : NB_OP_DESTROY, acl);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
} else
|
2019-01-30 10:54:25 +01:00
|
|
|
nb_cli_enqueue_change(vty, ".", NB_OP_DESTROY, NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./distance/source[prefix='%s']",
|
|
|
|
prefix_str);
|
2018-05-09 06:34:59 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_distance_source(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:34:59 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " distance %s %s",
|
2023-11-29 20:37:23 +01:00
|
|
|
yang_dnode_get_string(dnode, "distance"),
|
|
|
|
yang_dnode_get_string(dnode, "prefix"));
|
|
|
|
if (yang_dnode_exists(dnode, "access-list"))
|
2018-05-09 06:34:59 +02:00
|
|
|
vty_out(vty, " %s",
|
2023-11-29 20:37:23 +01:00
|
|
|
yang_dnode_get_string(dnode, "access-list"));
|
2018-05-09 06:34:59 +02:00
|
|
|
vty_out(vty, "\n");
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:34:59 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/explicit-neighbor
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_neighbor,
|
2018-05-09 06:34:59 +02:00
|
|
|
rip_neighbor_cmd,
|
|
|
|
"[no] neighbor A.B.C.D",
|
|
|
|
NO_STR
|
|
|
|
"Specify a neighbor router\n"
|
|
|
|
"Neighbor address\n")
|
|
|
|
{
|
2024-01-23 01:09:25 +01:00
|
|
|
char xpath[XPATH_MAXLEN];
|
|
|
|
|
|
|
|
snprintf(xpath, sizeof(xpath), "./explicit-neighbor[.='%s']",
|
|
|
|
neighbor_str);
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, xpath, no ? NB_OP_DESTROY : NB_OP_CREATE,
|
|
|
|
NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:34:59 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_neighbor(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:34:59 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " neighbor %s\n", yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:00 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/network
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_network_prefix,
|
2018-05-09 06:35:00 +02:00
|
|
|
rip_network_prefix_cmd,
|
|
|
|
"[no] network A.B.C.D/M",
|
|
|
|
NO_STR
|
|
|
|
"Enable routing on an IP network\n"
|
|
|
|
"IP prefix <network>/<length>, e.g., 35.0.0.0/8\n")
|
|
|
|
{
|
2024-01-23 01:09:25 +01:00
|
|
|
char xpath[XPATH_MAXLEN];
|
|
|
|
|
|
|
|
snprintf(xpath, sizeof(xpath), "./network[.='%s']", network_str);
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, xpath, no ? NB_OP_DESTROY : NB_OP_CREATE,
|
|
|
|
NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:35:00 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_network_prefix(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:00 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " network %s\n", yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/interface
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_network_if,
|
2018-05-09 06:35:00 +02:00
|
|
|
rip_network_if_cmd,
|
|
|
|
"[no] network WORD",
|
|
|
|
NO_STR
|
|
|
|
"Enable routing on an IP network\n"
|
|
|
|
"Interface name\n")
|
|
|
|
{
|
2024-01-23 01:09:25 +01:00
|
|
|
char xpath[XPATH_MAXLEN];
|
|
|
|
|
|
|
|
snprintf(xpath, sizeof(xpath), "./interface[.='%s']", network);
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, xpath, no ? NB_OP_DESTROY : NB_OP_CREATE,
|
|
|
|
NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:35:00 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_network_interface(struct vty *vty,
|
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:35:00 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " network %s\n", yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:00 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/offset-list
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_offset_list,
|
2018-05-09 06:35:00 +02:00
|
|
|
rip_offset_list_cmd,
|
2021-10-21 21:52:14 +02:00
|
|
|
"[no] offset-list ACCESSLIST4_NAME$acl <in|out>$direction (0-16)$metric [IFNAME]",
|
2018-05-09 06:35:00 +02:00
|
|
|
NO_STR
|
|
|
|
"Modify RIP metric\n"
|
|
|
|
"Access-list name\n"
|
|
|
|
"For incoming updates\n"
|
|
|
|
"For outgoing updates\n"
|
|
|
|
"Metric value\n"
|
|
|
|
"Interface to match\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
if (!no) {
|
|
|
|
nb_cli_enqueue_change(vty, ".", NB_OP_CREATE, NULL);
|
|
|
|
nb_cli_enqueue_change(vty, "./access-list", NB_OP_MODIFY, acl);
|
|
|
|
nb_cli_enqueue_change(vty, "./metric", NB_OP_MODIFY,
|
|
|
|
metric_str);
|
|
|
|
} else
|
2019-01-30 10:54:25 +01:00
|
|
|
nb_cli_enqueue_change(vty, ".", NB_OP_DESTROY, NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(
|
|
|
|
vty, "./offset-list[interface='%s'][direction='%s']",
|
|
|
|
ifname ? ifname : "*", direction);
|
2018-05-09 06:35:00 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_offset_list(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:00 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
const char *interface;
|
|
|
|
|
2023-11-29 20:37:23 +01:00
|
|
|
interface = yang_dnode_get_string(dnode, "interface");
|
2018-05-09 06:35:00 +02:00
|
|
|
|
|
|
|
vty_out(vty, " offset-list %s %s %s",
|
2023-11-29 20:37:23 +01:00
|
|
|
yang_dnode_get_string(dnode, "access-list"),
|
|
|
|
yang_dnode_get_string(dnode, "direction"),
|
|
|
|
yang_dnode_get_string(dnode, "metric"));
|
2018-05-09 06:35:00 +02:00
|
|
|
if (!strmatch(interface, "*"))
|
|
|
|
vty_out(vty, " %s", interface);
|
|
|
|
vty_out(vty, "\n");
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:00 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/passive-default
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_passive_default,
|
2018-05-09 06:35:00 +02:00
|
|
|
rip_passive_default_cmd,
|
|
|
|
"[no] passive-interface default",
|
|
|
|
NO_STR
|
|
|
|
"Suppress routing updates on an interface\n"
|
|
|
|
"default for all interfaces\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./passive-default", NB_OP_MODIFY,
|
|
|
|
no ? "false" : "true");
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:35:00 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_passive_default(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:00 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
if (!yang_dnode_get_bool(dnode, NULL))
|
|
|
|
vty_out(vty, " no");
|
|
|
|
|
|
|
|
vty_out(vty, " passive-interface default\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/passive-interface
|
|
|
|
* /frr-ripd:ripd/instance/non-passive-interface
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_passive_interface,
|
2018-05-09 06:35:00 +02:00
|
|
|
rip_passive_interface_cmd,
|
|
|
|
"[no] passive-interface IFNAME",
|
|
|
|
NO_STR
|
|
|
|
"Suppress routing updates on an interface\n"
|
|
|
|
"Interface name\n")
|
|
|
|
{
|
2019-03-02 21:45:14 +01:00
|
|
|
bool passive_default =
|
|
|
|
yang_dnode_get_bool(vty->candidate_config->dnode, "%s%s",
|
|
|
|
VTY_CURR_XPATH, "/passive-default");
|
2024-01-23 01:09:25 +01:00
|
|
|
char xpath[XPATH_MAXLEN];
|
|
|
|
enum nb_operation op;
|
2019-03-02 21:45:14 +01:00
|
|
|
|
|
|
|
if (passive_default) {
|
2024-01-23 01:09:25 +01:00
|
|
|
snprintf(xpath, sizeof(xpath),
|
|
|
|
"./non-passive-interface[.='%s']", ifname);
|
|
|
|
op = no ? NB_OP_CREATE : NB_OP_DESTROY;
|
2019-03-02 21:45:14 +01:00
|
|
|
} else {
|
2024-01-23 01:09:25 +01:00
|
|
|
snprintf(xpath, sizeof(xpath), "./passive-interface[.='%s']",
|
|
|
|
ifname);
|
|
|
|
op = no ? NB_OP_DESTROY : NB_OP_CREATE;
|
2019-03-02 21:45:14 +01:00
|
|
|
}
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
2024-01-23 01:09:25 +01:00
|
|
|
nb_cli_enqueue_change(vty, xpath, op, NULL);
|
|
|
|
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:35:00 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_passive_interface(struct vty *vty,
|
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:35:00 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " passive-interface %s\n",
|
|
|
|
yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_non_passive_interface(struct vty *vty,
|
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:35:00 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " no passive-interface %s\n",
|
|
|
|
yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:01 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/redistribute
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_redistribute,
|
2018-05-09 06:35:01 +02:00
|
|
|
rip_redistribute_cmd,
|
2022-06-13 11:18:36 +02:00
|
|
|
"[no] redistribute " FRR_REDIST_STR_RIPD "$protocol [{metric (0-16)|route-map RMAP_NAME$route_map}]",
|
2018-05-09 06:35:01 +02:00
|
|
|
NO_STR
|
|
|
|
REDIST_STR
|
|
|
|
FRR_REDIST_HELP_STR_RIPD
|
|
|
|
"Metric\n"
|
|
|
|
"Metric value\n"
|
|
|
|
"Route map reference\n"
|
|
|
|
"Pointer to route-map entries\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
if (!no) {
|
|
|
|
nb_cli_enqueue_change(vty, ".", NB_OP_CREATE, NULL);
|
|
|
|
nb_cli_enqueue_change(vty, "./route-map",
|
2019-01-30 10:54:25 +01:00
|
|
|
route_map ? NB_OP_MODIFY : NB_OP_DESTROY,
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
route_map);
|
|
|
|
nb_cli_enqueue_change(vty, "./metric",
|
2019-01-30 10:54:25 +01:00
|
|
|
metric_str ? NB_OP_MODIFY : NB_OP_DESTROY,
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
metric_str);
|
|
|
|
} else
|
2019-01-30 10:54:25 +01:00
|
|
|
nb_cli_enqueue_change(vty, ".", NB_OP_DESTROY, NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./redistribute[protocol='%s']",
|
|
|
|
protocol);
|
2018-05-09 06:35:01 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_redistribute(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:01 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " redistribute %s",
|
2023-11-29 20:37:23 +01:00
|
|
|
yang_dnode_get_string(dnode, "protocol"));
|
|
|
|
if (yang_dnode_exists(dnode, "metric"))
|
2018-05-09 06:35:01 +02:00
|
|
|
vty_out(vty, " metric %s",
|
2023-11-29 20:37:23 +01:00
|
|
|
yang_dnode_get_string(dnode, "metric"));
|
|
|
|
if (yang_dnode_exists(dnode, "route-map"))
|
2018-05-09 06:35:01 +02:00
|
|
|
vty_out(vty, " route-map %s",
|
2023-11-29 20:37:23 +01:00
|
|
|
yang_dnode_get_string(dnode, "route-map"));
|
2018-05-09 06:35:01 +02:00
|
|
|
vty_out(vty, "\n");
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:01 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/static-route
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_route,
|
2018-05-09 06:35:01 +02:00
|
|
|
rip_route_cmd,
|
|
|
|
"[no] route A.B.C.D/M",
|
|
|
|
NO_STR
|
|
|
|
"RIP static route configuration\n"
|
|
|
|
"IP prefix <network>/<length>\n")
|
|
|
|
{
|
2024-01-23 01:09:25 +01:00
|
|
|
char xpath[XPATH_MAXLEN];
|
|
|
|
|
|
|
|
snprintf(xpath, sizeof(xpath), "./static-route[.='%s']", route_str);
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, xpath, no ? NB_OP_DESTROY : NB_OP_CREATE,
|
|
|
|
NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:35:01 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_route(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:01 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " route %s\n", yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:01 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/timers
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_timers,
|
2018-05-09 06:35:01 +02:00
|
|
|
rip_timers_cmd,
|
|
|
|
"timers basic (5-2147483647)$update (5-2147483647)$timeout (5-2147483647)$garbage",
|
|
|
|
"Adjust routing timers\n"
|
|
|
|
"Basic routing protocol update timers\n"
|
|
|
|
"Routing table update timer value in second. Default is 30.\n"
|
|
|
|
"Routing information timeout timer. Default is 180.\n"
|
|
|
|
"Garbage collection timer. Default is 120.\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./update-interval", NB_OP_MODIFY,
|
|
|
|
update_str);
|
|
|
|
nb_cli_enqueue_change(vty, "./holddown-interval", NB_OP_MODIFY,
|
|
|
|
timeout_str);
|
|
|
|
nb_cli_enqueue_change(vty, "./flush-interval", NB_OP_MODIFY,
|
|
|
|
garbage_str);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./timers");
|
2018-05-09 06:35:01 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_rip_timers,
|
2018-05-09 06:35:01 +02:00
|
|
|
no_rip_timers_cmd,
|
|
|
|
"no timers basic [(5-2147483647) (5-2147483647) (5-2147483647)]",
|
|
|
|
NO_STR
|
|
|
|
"Adjust routing timers\n"
|
|
|
|
"Basic routing protocol update timers\n"
|
|
|
|
"Routing table update timer value in second. Default is 30.\n"
|
|
|
|
"Routing information timeout timer. Default is 180.\n"
|
|
|
|
"Garbage collection timer. Default is 120.\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./update-interval", NB_OP_MODIFY, NULL);
|
|
|
|
nb_cli_enqueue_change(vty, "./holddown-interval", NB_OP_MODIFY, NULL);
|
|
|
|
nb_cli_enqueue_change(vty, "./flush-interval", NB_OP_MODIFY, NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./timers");
|
2018-05-09 06:35:01 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_timers(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:01 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " timers basic %s %s %s\n",
|
2023-11-29 20:37:23 +01:00
|
|
|
yang_dnode_get_string(dnode, "update-interval"),
|
|
|
|
yang_dnode_get_string(dnode, "holddown-interval"),
|
|
|
|
yang_dnode_get_string(dnode, "flush-interval"));
|
2018-05-09 06:35:01 +02:00
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:01 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/version
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (rip_version,
|
2018-05-09 06:35:01 +02:00
|
|
|
rip_version_cmd,
|
|
|
|
"version (1-2)",
|
|
|
|
"Set routing protocol version\n"
|
|
|
|
"version\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./version/receive", NB_OP_MODIFY,
|
|
|
|
version_str);
|
|
|
|
nb_cli_enqueue_change(vty, "./version/send", NB_OP_MODIFY, version_str);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:35:01 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_rip_version,
|
2018-05-09 06:35:01 +02:00
|
|
|
no_rip_version_cmd,
|
|
|
|
"no version [(1-2)]",
|
|
|
|
NO_STR
|
|
|
|
"Set routing protocol version\n"
|
|
|
|
"version\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./version/receive", NB_OP_MODIFY, NULL);
|
|
|
|
nb_cli_enqueue_change(vty, "./version/send", NB_OP_MODIFY, NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2018-05-09 06:35:01 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_rip_version(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:01 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* We have only one "version" command and three possible combinations of
|
|
|
|
* send/receive values.
|
|
|
|
*/
|
2023-11-29 20:37:23 +01:00
|
|
|
switch (yang_dnode_get_enum(dnode, "receive")) {
|
2018-05-09 06:35:01 +02:00
|
|
|
case RI_RIP_VERSION_1:
|
|
|
|
vty_out(vty, " version 1\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_2:
|
|
|
|
vty_out(vty, " version 2\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_1_AND_2:
|
|
|
|
vty_out(vty, " no version\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-14 17:12:37 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:ripd/instance/default-bfd-profile
|
|
|
|
*/
|
|
|
|
DEFPY_YANG(rip_bfd_default_profile, rip_bfd_default_profile_cmd,
|
|
|
|
"bfd default-profile BFDPROF$profile",
|
|
|
|
"Bidirectional Forwarding Detection\n"
|
|
|
|
"BFD default profile\n"
|
|
|
|
"Profile name\n")
|
|
|
|
{
|
|
|
|
nb_cli_enqueue_change(vty, "./default-bfd-profile", NB_OP_MODIFY,
|
|
|
|
profile);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFPY_YANG(no_rip_bfd_default_profile, no_rip_bfd_default_profile_cmd,
|
|
|
|
"no bfd default-profile [BFDPROF]",
|
|
|
|
NO_STR
|
|
|
|
"Bidirectional Forwarding Detection\n"
|
|
|
|
"BFD default profile\n"
|
|
|
|
"Profile name\n")
|
|
|
|
{
|
|
|
|
nb_cli_enqueue_change(vty, "./default-bfd-profile", NB_OP_DESTROY,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
void cli_show_ripd_instance_default_bfd_profile(struct vty *vty,
|
|
|
|
const struct lyd_node *dnode,
|
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " bfd default-profile %s\n",
|
|
|
|
yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:03 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/split-horizon
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (ip_rip_split_horizon,
|
2018-05-09 06:35:03 +02:00
|
|
|
ip_rip_split_horizon_cmd,
|
|
|
|
"[no] ip rip split-horizon [poisoned-reverse$poisoned_reverse]",
|
|
|
|
NO_STR
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Perform split horizon\n"
|
|
|
|
"With poisoned-reverse\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
const char *value;
|
2018-05-09 06:35:03 +02:00
|
|
|
|
|
|
|
if (no)
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "disabled";
|
2018-05-09 06:35:03 +02:00
|
|
|
else if (poisoned_reverse)
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "poison-reverse";
|
2018-05-09 06:35:03 +02:00
|
|
|
else
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "simple";
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, "./split-horizon", NB_OP_MODIFY, value);
|
2018-05-09 06:35:03 +02:00
|
|
|
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_ip_rip_split_horizon(struct vty *vty,
|
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:35:03 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
int value;
|
|
|
|
|
|
|
|
value = yang_dnode_get_enum(dnode, NULL);
|
|
|
|
switch (value) {
|
|
|
|
case RIP_NO_SPLIT_HORIZON:
|
|
|
|
vty_out(vty, " no ip rip split-horizon\n");
|
|
|
|
break;
|
|
|
|
case RIP_SPLIT_HORIZON:
|
|
|
|
vty_out(vty, " ip rip split-horizon\n");
|
|
|
|
break;
|
|
|
|
case RIP_SPLIT_HORIZON_POISONED_REVERSE:
|
|
|
|
vty_out(vty, " ip rip split-horizon poisoned-reverse\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/v2-broadcast
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (ip_rip_v2_broadcast,
|
2018-05-09 06:35:03 +02:00
|
|
|
ip_rip_v2_broadcast_cmd,
|
|
|
|
"[no] ip rip v2-broadcast",
|
|
|
|
NO_STR
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Send ip broadcast v2 update\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./v2-broadcast", NB_OP_MODIFY,
|
|
|
|
no ? "false" : "true");
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_ip_rip_v2_broadcast(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:03 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
if (!yang_dnode_get_bool(dnode, NULL))
|
|
|
|
vty_out(vty, " no");
|
|
|
|
|
|
|
|
vty_out(vty, " ip rip v2-broadcast\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/version-receive
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (ip_rip_receive_version,
|
2018-05-09 06:35:03 +02:00
|
|
|
ip_rip_receive_version_cmd,
|
|
|
|
"ip rip receive version <{1$v1|2$v2}|none>",
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Advertisement reception\n"
|
|
|
|
"Version control\n"
|
|
|
|
"RIP version 1\n"
|
|
|
|
"RIP version 2\n"
|
|
|
|
"None\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
const char *value;
|
2018-05-09 06:35:03 +02:00
|
|
|
|
|
|
|
if (v1 && v2)
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "both";
|
2018-05-09 06:35:03 +02:00
|
|
|
else if (v1)
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "1";
|
2018-05-09 06:35:03 +02:00
|
|
|
else if (v2)
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "2";
|
2018-05-09 06:35:03 +02:00
|
|
|
else
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "none";
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, "./version-receive", NB_OP_MODIFY, value);
|
2018-05-09 06:35:03 +02:00
|
|
|
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_ip_rip_receive_version,
|
2018-05-09 06:35:03 +02:00
|
|
|
no_ip_rip_receive_version_cmd,
|
|
|
|
"no ip rip receive version [<{1|2}|none>]",
|
|
|
|
NO_STR
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Advertisement reception\n"
|
|
|
|
"Version control\n"
|
|
|
|
"RIP version 1\n"
|
|
|
|
"RIP version 2\n"
|
|
|
|
"None\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./version-receive", NB_OP_MODIFY, NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_ip_rip_receive_version(struct vty *vty,
|
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:35:03 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
switch (yang_dnode_get_enum(dnode, NULL)) {
|
|
|
|
case RI_RIP_UNSPEC:
|
|
|
|
vty_out(vty, " no ip rip receive version\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_1:
|
|
|
|
vty_out(vty, " ip rip receive version 1\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_2:
|
|
|
|
vty_out(vty, " ip rip receive version 2\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_1_AND_2:
|
|
|
|
vty_out(vty, " ip rip receive version 1 2\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_NONE:
|
|
|
|
vty_out(vty, " ip rip receive version none\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/version-send
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (ip_rip_send_version,
|
2018-05-09 06:35:03 +02:00
|
|
|
ip_rip_send_version_cmd,
|
|
|
|
"ip rip send version <{1$v1|2$v2}|none>",
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Advertisement transmission\n"
|
|
|
|
"Version control\n"
|
|
|
|
"RIP version 1\n"
|
|
|
|
"RIP version 2\n"
|
|
|
|
"None\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
const char *value;
|
2018-05-09 06:35:03 +02:00
|
|
|
|
|
|
|
if (v1 && v2)
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "both";
|
2018-05-09 06:35:03 +02:00
|
|
|
else if (v1)
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "1";
|
2018-05-09 06:35:03 +02:00
|
|
|
else if (v2)
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "2";
|
2018-05-09 06:35:03 +02:00
|
|
|
else
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "none";
|
|
|
|
|
|
|
|
nb_cli_enqueue_change(vty, "./version-send", NB_OP_MODIFY, value);
|
2018-05-09 06:35:03 +02:00
|
|
|
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_ip_rip_send_version,
|
2018-05-09 06:35:03 +02:00
|
|
|
no_ip_rip_send_version_cmd,
|
|
|
|
"no ip rip send version [<{1|2}|none>]",
|
|
|
|
NO_STR
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Advertisement transmission\n"
|
|
|
|
"Version control\n"
|
|
|
|
"RIP version 1\n"
|
|
|
|
"RIP version 2\n"
|
|
|
|
"None\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./version-send", NB_OP_MODIFY, NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2021-10-13 19:08:37 +02:00
|
|
|
void cli_show_ip_rip_send_version(struct vty *vty, const struct lyd_node *dnode,
|
2018-05-09 06:35:03 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
switch (yang_dnode_get_enum(dnode, NULL)) {
|
|
|
|
case RI_RIP_UNSPEC:
|
|
|
|
vty_out(vty, " no ip rip send version\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_1:
|
|
|
|
vty_out(vty, " ip rip send version 1\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_2:
|
|
|
|
vty_out(vty, " ip rip send version 2\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_1_AND_2:
|
|
|
|
vty_out(vty, " ip rip send version 1 2\n");
|
|
|
|
break;
|
|
|
|
case RI_RIP_VERSION_NONE:
|
|
|
|
vty_out(vty, " ip rip send version none\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/authentication-scheme
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (ip_rip_authentication_mode,
|
2018-05-09 06:35:03 +02:00
|
|
|
ip_rip_authentication_mode_cmd,
|
|
|
|
"ip rip authentication mode <md5$mode [auth-length <rfc|old-ripd>$auth_length]|text$mode>",
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Authentication control\n"
|
|
|
|
"Authentication mode\n"
|
|
|
|
"Keyed message digest\n"
|
|
|
|
"MD5 authentication data length\n"
|
|
|
|
"RFC compatible\n"
|
|
|
|
"Old ripd compatible\n"
|
|
|
|
"Clear text authentication\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
const char *value = NULL;
|
2018-05-09 06:35:03 +02:00
|
|
|
|
|
|
|
if (auth_length) {
|
|
|
|
if (strmatch(auth_length, "rfc"))
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "16";
|
2018-05-09 06:35:03 +02:00
|
|
|
else
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
value = "20";
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./authentication-scheme/mode", NB_OP_MODIFY,
|
|
|
|
strmatch(mode, "md5") ? "md5" : "plain-text");
|
2019-04-05 03:28:00 +02:00
|
|
|
if (strmatch(mode, "md5"))
|
|
|
|
nb_cli_enqueue_change(vty,
|
|
|
|
"./authentication-scheme/md5-auth-length",
|
|
|
|
NB_OP_MODIFY, value);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_ip_rip_authentication_mode,
|
2018-05-09 06:35:03 +02:00
|
|
|
no_ip_rip_authentication_mode_cmd,
|
|
|
|
"no ip rip authentication mode [<md5 [auth-length <rfc|old-ripd>]|text>]",
|
|
|
|
NO_STR
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Authentication control\n"
|
|
|
|
"Authentication mode\n"
|
|
|
|
"Keyed message digest\n"
|
|
|
|
"MD5 authentication data length\n"
|
|
|
|
"RFC compatible\n"
|
|
|
|
"Old ripd compatible\n"
|
|
|
|
"Clear text authentication\n")
|
|
|
|
{
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./authentication-scheme/mode", NB_OP_MODIFY,
|
|
|
|
NULL);
|
|
|
|
nb_cli_enqueue_change(vty, "./authentication-scheme/md5-auth-length",
|
2019-04-05 03:28:00 +02:00
|
|
|
NB_OP_DESTROY, NULL);
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void cli_show_ip_rip_authentication_scheme(struct vty *vty,
|
2021-10-13 19:08:37 +02:00
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:35:03 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
2023-11-29 20:37:23 +01:00
|
|
|
switch (yang_dnode_get_enum(dnode, "mode")) {
|
2018-05-09 06:35:03 +02:00
|
|
|
case RIP_NO_AUTH:
|
|
|
|
vty_out(vty, " no ip rip authentication mode\n");
|
|
|
|
break;
|
|
|
|
case RIP_AUTH_SIMPLE_PASSWORD:
|
|
|
|
vty_out(vty, " ip rip authentication mode text\n");
|
|
|
|
break;
|
|
|
|
case RIP_AUTH_MD5:
|
|
|
|
vty_out(vty, " ip rip authentication mode md5");
|
|
|
|
if (show_defaults
|
2023-11-29 20:37:23 +01:00
|
|
|
|| !yang_dnode_is_default(dnode, "md5-auth-length")) {
|
|
|
|
if (yang_dnode_get_enum(dnode, "md5-auth-length")
|
2018-05-09 06:35:03 +02:00
|
|
|
== RIP_AUTH_MD5_SIZE)
|
|
|
|
vty_out(vty, " auth-length rfc");
|
|
|
|
else
|
|
|
|
vty_out(vty, " auth-length old-ripd");
|
|
|
|
}
|
|
|
|
vty_out(vty, "\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/authentication-password
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (ip_rip_authentication_string,
|
2018-05-09 06:35:03 +02:00
|
|
|
ip_rip_authentication_string_cmd,
|
|
|
|
"ip rip authentication string LINE$password",
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Authentication control\n"
|
|
|
|
"Authentication string\n"
|
|
|
|
"Authentication string\n")
|
|
|
|
{
|
|
|
|
if (strlen(password) > 16) {
|
|
|
|
vty_out(vty,
|
|
|
|
"%% RIPv2 authentication string must be shorter than 16\n");
|
|
|
|
return CMD_WARNING_CONFIG_FAILED;
|
|
|
|
}
|
|
|
|
|
2021-05-04 16:41:58 +02:00
|
|
|
if (yang_dnode_existsf(vty->candidate_config->dnode, "%s%s",
|
|
|
|
VTY_CURR_XPATH,
|
|
|
|
"/frr-ripd:rip/authentication-key-chain")) {
|
2018-05-09 06:35:03 +02:00
|
|
|
vty_out(vty, "%% key-chain configuration exists\n");
|
|
|
|
return CMD_WARNING_CONFIG_FAILED;
|
|
|
|
}
|
|
|
|
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./authentication-password", NB_OP_MODIFY,
|
|
|
|
password);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_ip_rip_authentication_string,
|
2018-05-09 06:35:03 +02:00
|
|
|
no_ip_rip_authentication_string_cmd,
|
|
|
|
"no ip rip authentication string [LINE]",
|
|
|
|
NO_STR
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Authentication control\n"
|
|
|
|
"Authentication string\n"
|
|
|
|
"Authentication string\n")
|
|
|
|
{
|
2019-03-02 19:00:46 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./authentication-password", NB_OP_DESTROY,
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void cli_show_ip_rip_authentication_string(struct vty *vty,
|
2021-10-13 19:08:37 +02:00
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:35:03 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " ip rip authentication string %s\n",
|
|
|
|
yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/authentication-key-chain
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (ip_rip_authentication_key_chain,
|
2018-05-09 06:35:03 +02:00
|
|
|
ip_rip_authentication_key_chain_cmd,
|
|
|
|
"ip rip authentication key-chain LINE$keychain",
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Authentication control\n"
|
|
|
|
"Authentication key-chain\n"
|
|
|
|
"name of key-chain\n")
|
|
|
|
{
|
2021-05-04 16:41:58 +02:00
|
|
|
if (yang_dnode_existsf(vty->candidate_config->dnode, "%s%s",
|
|
|
|
VTY_CURR_XPATH,
|
|
|
|
"/frr-ripd:rip/authentication-password")) {
|
2018-05-09 06:35:03 +02:00
|
|
|
vty_out(vty, "%% authentication string configuration exists\n");
|
|
|
|
return CMD_WARNING_CONFIG_FAILED;
|
|
|
|
}
|
|
|
|
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./authentication-key-chain", NB_OP_MODIFY,
|
|
|
|
keychain);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (no_ip_rip_authentication_key_chain,
|
2018-05-09 06:35:03 +02:00
|
|
|
no_ip_rip_authentication_key_chain_cmd,
|
|
|
|
"no ip rip authentication key-chain [LINE]",
|
|
|
|
NO_STR
|
|
|
|
IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Authentication control\n"
|
|
|
|
"Authentication key-chain\n"
|
|
|
|
"name of key-chain\n")
|
|
|
|
{
|
2019-01-30 10:54:25 +01:00
|
|
|
nb_cli_enqueue_change(vty, "./authentication-key-chain", NB_OP_DESTROY,
|
lib, ripd: rework API for converted CLI commands
When editing the candidate configuration, the northbound must ensure
that either all changes made by a command are accepted or none are.
This is done to prevent inconsistent states where only parts of a
command are applied in the event any error happens.
The previous API for converted commands, the nb_cli_cfg_change()
function, required callers to pass an array containing all changes
that needed to be applied in the candidate configuration. The
problem with this API is that it was very inconvenient for complex
commands, which change different configuration options depending
on several factors. This required users to manipulate the array
of configuration changes using low-level primitives, making it
complicated to implement some commands.
To solve this problem, introduce a new API based on the two following
functions:
- nb_cli_enqueue_change()
- nb_cli_apply_changes()
The first function is used to enqueue configuration changes, one
at time. Then the nb_cli_apply_changes() function is used to apply
all the enqueued configuration changes.
To implement this, a static-sized array was allocated in the "vty"
structure, along with a counter of enqueued changes. This eliminates
the need to declare an array of configuration changes in every
converted CLI command, simplifying things quite considerably.
Signed-off-by: Renato Westphal <renato@opensourcerouting.org>
2018-11-26 18:30:14 +01:00
|
|
|
NULL);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
2018-05-09 06:35:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void cli_show_ip_rip_authentication_key_chain(struct vty *vty,
|
2021-10-13 19:08:37 +02:00
|
|
|
const struct lyd_node *dnode,
|
2018-05-09 06:35:03 +02:00
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " ip rip authentication key-chain %s\n",
|
|
|
|
yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2021-10-14 17:12:37 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/bfd-monitoring/enable
|
|
|
|
*/
|
|
|
|
DEFPY_YANG(ip_rip_bfd, ip_rip_bfd_cmd, "[no] ip rip bfd",
|
|
|
|
NO_STR IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Enable BFD support\n")
|
|
|
|
{
|
|
|
|
nb_cli_enqueue_change(vty, "./bfd-monitoring/enable", NB_OP_MODIFY,
|
|
|
|
no ? "false" : "true");
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
|
|
|
}
|
|
|
|
|
|
|
|
void cli_show_ip_rip_bfd_enable(struct vty *vty, const struct lyd_node *dnode,
|
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " ip rip bfd\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* XPath: /frr-interface:lib/interface/frr-ripd:rip/bfd/profile
|
|
|
|
*/
|
|
|
|
DEFPY_YANG(ip_rip_bfd_profile, ip_rip_bfd_profile_cmd,
|
|
|
|
"[no] ip rip bfd profile BFDPROF$profile",
|
|
|
|
NO_STR IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Enable BFD support\n"
|
|
|
|
"Use a pre-configured profile\n"
|
|
|
|
"Profile name\n")
|
|
|
|
{
|
|
|
|
if (no)
|
|
|
|
nb_cli_enqueue_change(vty, "./bfd-monitoring/profile",
|
|
|
|
NB_OP_DESTROY, NULL);
|
|
|
|
else
|
|
|
|
nb_cli_enqueue_change(vty, "./bfd-monitoring/profile",
|
|
|
|
NB_OP_MODIFY, profile);
|
|
|
|
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFPY_YANG(no_ip_rip_bfd_profile, no_ip_rip_bfd_profile_cmd,
|
|
|
|
"no ip rip bfd profile",
|
|
|
|
NO_STR IP_STR
|
|
|
|
"Routing Information Protocol\n"
|
|
|
|
"Enable BFD support\n"
|
|
|
|
"Use a pre-configured profile\n")
|
|
|
|
{
|
|
|
|
nb_cli_enqueue_change(vty, "./bfd-monitoring/profile", NB_OP_DESTROY,
|
|
|
|
NULL);
|
|
|
|
return nb_cli_apply_changes(vty, "./frr-ripd:rip");
|
|
|
|
}
|
|
|
|
|
|
|
|
void cli_show_ip_rip_bfd_profile(struct vty *vty, const struct lyd_node *dnode,
|
|
|
|
bool show_defaults)
|
|
|
|
{
|
|
|
|
vty_out(vty, " ip rip bfd profile %s\n",
|
|
|
|
yang_dnode_get_string(dnode, NULL));
|
|
|
|
}
|
|
|
|
|
2018-05-09 06:35:04 +02:00
|
|
|
/*
|
|
|
|
* XPath: /frr-ripd:clear-rip-route
|
|
|
|
*/
|
2020-07-06 17:47:44 +02:00
|
|
|
DEFPY_YANG (clear_ip_rip,
|
2018-05-09 06:35:04 +02:00
|
|
|
clear_ip_rip_cmd,
|
2019-01-04 22:08:10 +01:00
|
|
|
"clear ip rip [vrf WORD]",
|
2018-05-09 06:35:04 +02:00
|
|
|
CLEAR_STR
|
|
|
|
IP_STR
|
2019-01-04 22:08:10 +01:00
|
|
|
"Clear IP RIP database\n"
|
|
|
|
VRF_CMD_HELP_STR)
|
2018-05-09 06:35:04 +02:00
|
|
|
{
|
2019-01-04 22:08:10 +01:00
|
|
|
struct list *input;
|
2019-12-13 00:48:04 +01:00
|
|
|
int ret;
|
2019-01-04 22:08:10 +01:00
|
|
|
|
|
|
|
input = list_new();
|
|
|
|
if (vrf) {
|
|
|
|
struct yang_data *yang_vrf;
|
|
|
|
|
|
|
|
yang_vrf = yang_data_new("/frr-ripd:clear-rip-route/input/vrf",
|
|
|
|
vrf);
|
|
|
|
listnode_add(input, yang_vrf);
|
|
|
|
}
|
|
|
|
|
2020-10-04 00:34:33 +02:00
|
|
|
ret = nb_cli_rpc(vty, "/frr-ripd:clear-rip-route", input, NULL);
|
2019-12-13 00:48:04 +01:00
|
|
|
|
|
|
|
list_delete(&input);
|
|
|
|
|
|
|
|
return ret;
|
2018-05-09 06:35:04 +02:00
|
|
|
}
|
|
|
|
|
2024-01-21 15:01:58 +01:00
|
|
|
DEFPY_YANG(
|
|
|
|
rip_distribute_list, rip_distribute_list_cmd,
|
2024-01-22 22:34:56 +01:00
|
|
|
"distribute-list ACCESSLIST4_NAME$name <in|out>$dir [WORD$ifname]",
|
|
|
|
"Filter networks in routing updates\n"
|
|
|
|
"Access-list name\n"
|
|
|
|
"Filter incoming routing updates\n"
|
|
|
|
"Filter outgoing routing updates\n"
|
|
|
|
"Interface name\n")
|
|
|
|
{
|
|
|
|
char xpath[XPATH_MAXLEN];
|
|
|
|
|
|
|
|
snprintf(xpath, sizeof(xpath),
|
|
|
|
"./distribute-list[interface='%s']/%s/access-list",
|
|
|
|
ifname ? ifname : "", dir);
|
|
|
|
/* nb_cli_enqueue_change(vty, ".", NB_OP_CREATE, NULL); */
|
|
|
|
nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, name);
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFPY_YANG(
|
|
|
|
rip_distribute_list_prefix, rip_distribute_list_prefix_cmd,
|
|
|
|
"distribute-list prefix PREFIXLIST4_NAME$name <in|out>$dir [WORD$ifname]",
|
2024-01-21 15:01:58 +01:00
|
|
|
"Filter networks in routing updates\n"
|
|
|
|
"Specify a prefix list\n"
|
2024-01-22 22:34:56 +01:00
|
|
|
"Prefix-list name\n"
|
2024-01-21 15:01:58 +01:00
|
|
|
"Filter incoming routing updates\n"
|
|
|
|
"Filter outgoing routing updates\n"
|
|
|
|
"Interface name\n")
|
2021-02-08 17:36:05 +01:00
|
|
|
{
|
2024-01-21 15:01:58 +01:00
|
|
|
char xpath[XPATH_MAXLEN];
|
2021-02-08 17:36:05 +01:00
|
|
|
|
2024-01-21 15:01:58 +01:00
|
|
|
snprintf(xpath, sizeof(xpath),
|
2024-01-22 22:34:56 +01:00
|
|
|
"./distribute-list[interface='%s']/%s/prefix-list",
|
|
|
|
ifname ? ifname : "", dir);
|
2024-01-21 15:01:58 +01:00
|
|
|
/* nb_cli_enqueue_change(vty, ".", NB_OP_CREATE, NULL); */
|
|
|
|
nb_cli_enqueue_change(vty, xpath, NB_OP_MODIFY, name);
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2021-02-08 17:36:05 +01:00
|
|
|
}
|
|
|
|
|
2024-01-21 15:01:58 +01:00
|
|
|
DEFPY_YANG(no_rip_distribute_list,
|
|
|
|
no_rip_distribute_list_cmd,
|
2024-01-22 22:34:56 +01:00
|
|
|
"no distribute-list [ACCESSLIST4_NAME$name] <in|out>$dir [WORD$ifname]",
|
|
|
|
NO_STR
|
|
|
|
"Filter networks in routing updates\n"
|
|
|
|
"Access-list name\n"
|
|
|
|
"Filter incoming routing updates\n"
|
|
|
|
"Filter outgoing routing updates\n"
|
|
|
|
"Interface name\n")
|
|
|
|
{
|
|
|
|
const struct lyd_node *value_node;
|
|
|
|
char xpath[XPATH_MAXLEN];
|
|
|
|
|
|
|
|
snprintf(xpath, sizeof(xpath),
|
|
|
|
"./distribute-list[interface='%s']/%s/access-list",
|
|
|
|
ifname ? ifname : "", dir);
|
|
|
|
/*
|
|
|
|
* See if the user has specified specific list so check it exists.
|
|
|
|
*
|
|
|
|
* NOTE: Other FRR CLI commands do not do this sort of verification and
|
|
|
|
* there may be an official decision not to.
|
|
|
|
*/
|
|
|
|
if (name) {
|
|
|
|
value_node = yang_dnode_getf(vty->candidate_config->dnode, "%s/%s",
|
|
|
|
VTY_CURR_XPATH, xpath);
|
|
|
|
if (!value_node || strcmp(name, lyd_get_value(value_node))) {
|
|
|
|
vty_out(vty, "distribute list doesn't exist\n");
|
|
|
|
return CMD_WARNING_CONFIG_FAILED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
DEFPY_YANG(no_rip_distribute_list_prefix,
|
|
|
|
no_rip_distribute_list_prefix_cmd,
|
|
|
|
"no distribute-list prefix [PREFIXLIST4_NAME$name] <in|out>$dir [WORD$ifname]",
|
2024-01-21 15:01:58 +01:00
|
|
|
NO_STR
|
|
|
|
"Filter networks in routing updates\n"
|
|
|
|
"Specify a prefix list\n"
|
2024-01-22 22:34:56 +01:00
|
|
|
"Prefix-list name\n"
|
2024-01-21 15:01:58 +01:00
|
|
|
"Filter incoming routing updates\n"
|
|
|
|
"Filter outgoing routing updates\n"
|
|
|
|
"Interface name\n")
|
|
|
|
{
|
|
|
|
const struct lyd_node *value_node;
|
|
|
|
char xpath[XPATH_MAXLEN];
|
2021-02-08 17:36:05 +01:00
|
|
|
|
2024-01-21 15:01:58 +01:00
|
|
|
snprintf(xpath, sizeof(xpath),
|
2024-01-22 22:34:56 +01:00
|
|
|
"./distribute-list[interface='%s']/%s/prefix-list",
|
|
|
|
ifname ? ifname : "", dir);
|
2024-01-21 15:01:58 +01:00
|
|
|
/*
|
|
|
|
* See if the user has specified specific list so check it exists.
|
|
|
|
*
|
|
|
|
* NOTE: Other FRR CLI commands do not do this sort of verification and
|
|
|
|
* there may be an official decision not to.
|
|
|
|
*/
|
|
|
|
if (name) {
|
|
|
|
value_node = yang_dnode_getf(vty->candidate_config->dnode, "%s/%s",
|
|
|
|
VTY_CURR_XPATH, xpath);
|
|
|
|
if (!value_node || strcmp(name, lyd_get_value(value_node))) {
|
|
|
|
vty_out(vty, "distribute list doesn't exist\n");
|
|
|
|
return CMD_WARNING_CONFIG_FAILED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nb_cli_enqueue_change(vty, xpath, NB_OP_DESTROY, NULL);
|
|
|
|
return nb_cli_apply_changes(vty, NULL);
|
2021-02-08 17:36:05 +01:00
|
|
|
}
|
|
|
|
|
2024-01-19 17:40:12 +01:00
|
|
|
/* RIP node structure. */
|
|
|
|
static struct cmd_node rip_node = {
|
|
|
|
.name = "rip",
|
|
|
|
.node = RIP_NODE,
|
|
|
|
.parent_node = CONFIG_NODE,
|
|
|
|
.prompt = "%s(config-router)# ",
|
|
|
|
// .config_write = config_write_rip,
|
|
|
|
};
|
|
|
|
|
2018-05-09 06:34:57 +02:00
|
|
|
void rip_cli_init(void)
|
|
|
|
{
|
2024-01-19 17:40:12 +01:00
|
|
|
install_node(&rip_node);
|
|
|
|
|
2018-05-09 06:34:58 +02:00
|
|
|
install_element(CONFIG_NODE, &router_rip_cmd);
|
|
|
|
install_element(CONFIG_NODE, &no_router_rip_cmd);
|
2018-05-09 06:34:58 +02:00
|
|
|
|
2021-02-08 17:36:05 +01:00
|
|
|
install_element(RIP_NODE, &rip_distribute_list_cmd);
|
2024-01-22 22:34:56 +01:00
|
|
|
install_element(RIP_NODE, &rip_distribute_list_prefix_cmd);
|
2024-01-21 15:01:58 +01:00
|
|
|
install_element(RIP_NODE, &no_rip_distribute_list_cmd);
|
2024-01-22 22:34:56 +01:00
|
|
|
install_element(RIP_NODE, &no_rip_distribute_list_prefix_cmd);
|
2021-02-08 17:36:05 +01:00
|
|
|
|
2018-05-09 06:34:58 +02:00
|
|
|
install_element(RIP_NODE, &rip_allow_ecmp_cmd);
|
2023-05-04 08:13:07 +02:00
|
|
|
install_element(RIP_NODE, &no_rip_allow_ecmp_cmd);
|
2018-05-09 06:34:58 +02:00
|
|
|
install_element(RIP_NODE, &rip_default_information_originate_cmd);
|
2018-05-09 06:34:59 +02:00
|
|
|
install_element(RIP_NODE, &rip_default_metric_cmd);
|
|
|
|
install_element(RIP_NODE, &no_rip_default_metric_cmd);
|
2018-05-09 06:34:59 +02:00
|
|
|
install_element(RIP_NODE, &rip_distance_cmd);
|
|
|
|
install_element(RIP_NODE, &no_rip_distance_cmd);
|
2018-05-09 06:34:59 +02:00
|
|
|
install_element(RIP_NODE, &rip_distance_source_cmd);
|
2018-05-09 06:34:59 +02:00
|
|
|
install_element(RIP_NODE, &rip_neighbor_cmd);
|
2018-05-09 06:35:00 +02:00
|
|
|
install_element(RIP_NODE, &rip_network_prefix_cmd);
|
|
|
|
install_element(RIP_NODE, &rip_network_if_cmd);
|
2018-05-09 06:35:00 +02:00
|
|
|
install_element(RIP_NODE, &rip_offset_list_cmd);
|
2018-05-09 06:35:00 +02:00
|
|
|
install_element(RIP_NODE, &rip_passive_default_cmd);
|
|
|
|
install_element(RIP_NODE, &rip_passive_interface_cmd);
|
2018-05-09 06:35:01 +02:00
|
|
|
install_element(RIP_NODE, &rip_redistribute_cmd);
|
2018-05-09 06:35:01 +02:00
|
|
|
install_element(RIP_NODE, &rip_route_cmd);
|
2018-05-09 06:35:01 +02:00
|
|
|
install_element(RIP_NODE, &rip_timers_cmd);
|
|
|
|
install_element(RIP_NODE, &no_rip_timers_cmd);
|
2018-05-09 06:35:01 +02:00
|
|
|
install_element(RIP_NODE, &rip_version_cmd);
|
|
|
|
install_element(RIP_NODE, &no_rip_version_cmd);
|
2021-10-14 17:12:37 +02:00
|
|
|
install_element(RIP_NODE, &rip_bfd_default_profile_cmd);
|
|
|
|
install_element(RIP_NODE, &no_rip_bfd_default_profile_cmd);
|
2024-01-19 17:40:12 +01:00
|
|
|
install_default(RIP_NODE);
|
2018-05-09 06:35:03 +02:00
|
|
|
|
|
|
|
install_element(INTERFACE_NODE, &ip_rip_split_horizon_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &ip_rip_v2_broadcast_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &ip_rip_receive_version_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &no_ip_rip_receive_version_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &ip_rip_send_version_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &no_ip_rip_send_version_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &ip_rip_authentication_mode_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &no_ip_rip_authentication_mode_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &ip_rip_authentication_string_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &no_ip_rip_authentication_string_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &ip_rip_authentication_key_chain_cmd);
|
|
|
|
install_element(INTERFACE_NODE,
|
|
|
|
&no_ip_rip_authentication_key_chain_cmd);
|
2021-10-14 17:12:37 +02:00
|
|
|
install_element(INTERFACE_NODE, &ip_rip_bfd_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &ip_rip_bfd_profile_cmd);
|
|
|
|
install_element(INTERFACE_NODE, &no_ip_rip_bfd_profile_cmd);
|
2018-05-09 06:35:03 +02:00
|
|
|
|
2018-05-09 06:35:04 +02:00
|
|
|
install_element(ENABLE_NODE, &clear_ip_rip_cmd);
|
2024-01-19 17:40:12 +01:00
|
|
|
|
|
|
|
if_rmap_init(RIP_NODE);
|
|
|
|
}
|
|
|
|
/* clang-format off */
|
|
|
|
const struct frr_yang_module_info frr_ripd_cli_info = {
|
|
|
|
.name = "frr-ripd",
|
|
|
|
.ignore_cfg_cbs = true,
|
|
|
|
.nodes = {
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance",
|
|
|
|
.cbs.cli_show = cli_show_router_rip,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/allow-ecmp",
|
|
|
|
.cbs.cli_show = cli_show_rip_allow_ecmp,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/default-information-originate",
|
|
|
|
.cbs.cli_show = cli_show_rip_default_information_originate,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/default-metric",
|
|
|
|
.cbs.cli_show = cli_show_rip_default_metric,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/distance/default",
|
|
|
|
.cbs.cli_show = cli_show_rip_distance,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/distance/source",
|
|
|
|
.cbs.cli_show = cli_show_rip_distance_source,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/explicit-neighbor",
|
|
|
|
.cbs.cli_show = cli_show_rip_neighbor,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/network",
|
|
|
|
.cbs.cli_show = cli_show_rip_network_prefix,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/interface",
|
|
|
|
.cbs.cli_show = cli_show_rip_network_interface,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/offset-list",
|
|
|
|
.cbs.cli_show = cli_show_rip_offset_list,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/passive-default",
|
|
|
|
.cbs.cli_show = cli_show_rip_passive_default,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/passive-interface",
|
|
|
|
.cbs.cli_show = cli_show_rip_passive_interface,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/non-passive-interface",
|
|
|
|
.cbs.cli_show = cli_show_rip_non_passive_interface,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/redistribute",
|
|
|
|
.cbs.cli_show = cli_show_rip_redistribute,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/if-route-maps/if-route-map",
|
|
|
|
.cbs.cli_show = cli_show_if_route_map,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/static-route",
|
|
|
|
.cbs.cli_show = cli_show_rip_route,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/timers",
|
|
|
|
.cbs.cli_show = cli_show_rip_timers,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/version",
|
|
|
|
.cbs.cli_show = cli_show_rip_version,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-ripd:ripd/instance/default-bfd-profile",
|
|
|
|
.cbs.cli_show = cli_show_ripd_instance_default_bfd_profile,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/split-horizon",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_split_horizon,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/v2-broadcast",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_v2_broadcast,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/version-receive",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_receive_version,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/version-send",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_send_version,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/authentication-scheme",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_authentication_scheme,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/authentication-password",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_authentication_string,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/authentication-key-chain",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_authentication_key_chain,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/bfd-monitoring/enable",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_bfd_enable,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = "/frr-interface:lib/interface/frr-ripd:rip/bfd-monitoring/profile",
|
|
|
|
.cbs.cli_show = cli_show_ip_rip_bfd_profile,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
.xpath = NULL,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
};
|