mirror of https://github.com/FRRouting/frr.git
776 lines
21 KiB
YANG
776 lines
21 KiB
YANG
// SPDX-License-Identifier: BSD-2-Clause
|
|
module frr-ripd {
|
|
yang-version 1.1;
|
|
namespace "http://frrouting.org/yang/ripd";
|
|
prefix frr-ripd;
|
|
|
|
import ietf-inet-types {
|
|
prefix inet;
|
|
}
|
|
import ietf-yang-types {
|
|
prefix yang;
|
|
}
|
|
import frr-if-rmap {
|
|
prefix frr-if-rmap;
|
|
}
|
|
import frr-bfdd {
|
|
prefix frr-bfdd;
|
|
}
|
|
import frr-filter {
|
|
prefix frr-filter;
|
|
}
|
|
import frr-interface {
|
|
prefix frr-interface;
|
|
}
|
|
import frr-nexthop {
|
|
prefix frr-nexthop;
|
|
}
|
|
import frr-vrf {
|
|
prefix frr-vrf;
|
|
}
|
|
import frr-route-map {
|
|
prefix frr-route-map;
|
|
}
|
|
import frr-route-types {
|
|
prefix frr-route-types;
|
|
}
|
|
|
|
organization
|
|
"FRRouting";
|
|
contact
|
|
"FRR Users List: <mailto:frog@lists.frrouting.org>
|
|
FRR Development List: <mailto:dev@lists.frrouting.org>";
|
|
description
|
|
"This module defines a model for managing FRR ripd daemon.
|
|
|
|
Copyright 2020 FRRouting
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
\"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.";
|
|
|
|
revision 2019-09-09 {
|
|
description
|
|
"Changed interface references to use
|
|
frr-interface:interface-ref typedef";
|
|
reference "FRRouting";
|
|
}
|
|
revision 2017-12-06 {
|
|
description
|
|
"Initial revision.";
|
|
reference
|
|
"RFC 1058: Routing Information Protocol.
|
|
RFC 2453: RIP Version 2.";
|
|
}
|
|
|
|
typedef rip-route-type {
|
|
type enumeration {
|
|
enum normal {
|
|
value 0;
|
|
description "Normal RIP route type.";
|
|
}
|
|
enum static {
|
|
value 1;
|
|
description "Static RIP route type.";
|
|
}
|
|
enum default {
|
|
value 2;
|
|
description "Default RIP route type.";
|
|
}
|
|
enum redistribute {
|
|
value 3;
|
|
description "Redistribute RIP route type.";
|
|
}
|
|
enum interface {
|
|
value 4;
|
|
description "Interface RIP route type.";
|
|
}
|
|
}
|
|
description
|
|
"Types of RIP routes.";
|
|
}
|
|
|
|
container ripd {
|
|
description "rip routing instance data";
|
|
list instance {
|
|
key "vrf";
|
|
description
|
|
"RIP routing instance.";
|
|
|
|
leaf vrf {
|
|
type frr-vrf:vrf-ref;
|
|
description
|
|
"VRF name.";
|
|
}
|
|
leaf allow-ecmp {
|
|
type uint8;
|
|
default 0;
|
|
description
|
|
"Allow equal-cost multi-path.";
|
|
}
|
|
leaf default-information-originate {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Control distribution of default route.";
|
|
}
|
|
leaf default-metric {
|
|
type uint8 {
|
|
range "1..16";
|
|
}
|
|
default "1";
|
|
description
|
|
"Default metric of redistributed routes.";
|
|
}
|
|
container distance {
|
|
description
|
|
"Administrative distance.";
|
|
leaf default {
|
|
type uint8 {
|
|
range "0..255";
|
|
}
|
|
default "0";
|
|
description
|
|
"Default administrative distance.";
|
|
}
|
|
list source {
|
|
key "prefix";
|
|
description
|
|
"Custom administrative distance per IP prefix.";
|
|
leaf prefix {
|
|
type inet:ipv4-prefix;
|
|
description
|
|
"Prefix.";
|
|
}
|
|
leaf distance {
|
|
type uint8 {
|
|
range "1..255";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Administrative distance.";
|
|
}
|
|
leaf access-list {
|
|
type string;
|
|
description
|
|
"Access-list name.";
|
|
}
|
|
}
|
|
}
|
|
leaf-list explicit-neighbor {
|
|
type inet:ipv4-address;
|
|
description
|
|
"Specifies the RIP neighbors. Useful for a
|
|
non-broadcast multiple access (NBMA) network.";
|
|
}
|
|
leaf-list network {
|
|
type inet:ipv4-prefix;
|
|
description
|
|
"Enable RIP on the specified IP network.";
|
|
}
|
|
leaf-list interface {
|
|
type frr-interface:interface-ref;
|
|
description
|
|
"Enable RIP on the specified interface.";
|
|
}
|
|
list offset-list {
|
|
key "interface direction";
|
|
description
|
|
"Offset-list to modify route metric.";
|
|
leaf interface {
|
|
type union {
|
|
type frr-interface:interface-ref;
|
|
type enumeration {
|
|
enum '*' {
|
|
description
|
|
"Match all interfaces.";
|
|
}
|
|
}
|
|
}
|
|
description
|
|
"Interface to match. Use '*' to match all interfaces.";
|
|
}
|
|
leaf direction {
|
|
type enumeration {
|
|
enum in {
|
|
value 0;
|
|
description
|
|
"Incoming updates.";
|
|
}
|
|
enum out {
|
|
value 1;
|
|
description
|
|
"Outgoing updates.";
|
|
}
|
|
}
|
|
description
|
|
"Incoming or outgoing updates.";
|
|
}
|
|
leaf access-list {
|
|
type string;
|
|
mandatory true;
|
|
description
|
|
"Access-list name.";
|
|
}
|
|
leaf metric {
|
|
type uint8 {
|
|
range "0..16";
|
|
}
|
|
mandatory true;
|
|
description
|
|
"Route metric.";
|
|
}
|
|
}
|
|
leaf passive-default {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Control whether interfaces are in the passive mode
|
|
by default or not.";
|
|
}
|
|
leaf-list passive-interface {
|
|
when "../passive-default = 'false'";
|
|
type frr-interface:interface-ref;
|
|
description
|
|
"A list of interfaces where the sending of RIP packets
|
|
is disabled.";
|
|
}
|
|
leaf-list non-passive-interface {
|
|
when "../passive-default = 'true'";
|
|
type frr-interface:interface-ref;
|
|
description
|
|
"A list of interfaces where the sending of RIP packets
|
|
is enabled.";
|
|
}
|
|
|
|
uses frr-filter:distribute-list-group;
|
|
|
|
list redistribute {
|
|
key "protocol";
|
|
description
|
|
"Redistributes routes learned from other routing protocols.";
|
|
leaf protocol {
|
|
type frr-route-types:frr-route-types-v4;
|
|
must '. != "rip"';
|
|
description
|
|
"Routing protocol.";
|
|
}
|
|
leaf route-map {
|
|
type frr-route-map:route-map-ref;
|
|
description
|
|
"Applies the conditions of the specified route-map to
|
|
routes that are redistributed into the RIP routing
|
|
instance.";
|
|
}
|
|
leaf metric {
|
|
type uint8 {
|
|
range "0..16";
|
|
}
|
|
description
|
|
"Metric used for the redistributed route. If a metric is
|
|
not specified, the metric configured with the
|
|
default-metric attribute in RIP router configuration is
|
|
used. If the default-metric attribute has not been
|
|
configured, the default metric for redistributed routes
|
|
is 0.";
|
|
}
|
|
}
|
|
|
|
uses frr-if-rmap:if-route-maps-group;
|
|
|
|
leaf-list static-route {
|
|
type inet:ipv4-prefix;
|
|
description
|
|
"RIP static routes.";
|
|
}
|
|
container timers {
|
|
description
|
|
"Settings of basic timers";
|
|
leaf flush-interval {
|
|
type uint32 {
|
|
range "5..2147483647";
|
|
}
|
|
units "seconds";
|
|
default "120";
|
|
description
|
|
"Interval before a route is flushed from the routing
|
|
table.";
|
|
}
|
|
leaf holddown-interval {
|
|
type uint32 {
|
|
range "5..2147483647";
|
|
}
|
|
units "seconds";
|
|
default "180";
|
|
description
|
|
"Interval before better routes are released.";
|
|
}
|
|
leaf update-interval {
|
|
type uint32 {
|
|
range "5..2147483647";
|
|
}
|
|
units "seconds";
|
|
default "30";
|
|
description
|
|
"Interval at which RIP updates are sent.";
|
|
}
|
|
}
|
|
container version {
|
|
description "version of rip";
|
|
leaf receive {
|
|
type enumeration {
|
|
enum "1" {
|
|
value 1;
|
|
description
|
|
"Accept RIPv1 updates only.";
|
|
}
|
|
enum "2" {
|
|
value 2;
|
|
description
|
|
"Accept RIPv2 updates only.";
|
|
}
|
|
enum "1-2" {
|
|
value 3;
|
|
description
|
|
"Accept both RIPv1 and RIPv2 updates.";
|
|
}
|
|
}
|
|
must
|
|
'(. = "1" and ../send = "1") or ' +
|
|
'(. = "2" and ../send = "2") or ' +
|
|
'(. = "1-2" and ../send = "2")';
|
|
default "1-2";
|
|
description
|
|
"Advertisement reception - Version control.";
|
|
}
|
|
leaf send {
|
|
type enumeration {
|
|
enum "1" {
|
|
value 1;
|
|
description
|
|
"Send RIPv1 updates only.";
|
|
}
|
|
enum "2" {
|
|
value 2;
|
|
description
|
|
"Send RIPv2 updates only.";
|
|
}
|
|
}
|
|
must
|
|
'(../receive = "1" and . = "1") or ' +
|
|
'(../receive = "2" and . = "2") or ' +
|
|
'(../receive = "1-2" and . = "2")';
|
|
default "2";
|
|
description
|
|
"Advertisement transmission - Version control.";
|
|
}
|
|
}
|
|
|
|
leaf default-bfd-profile {
|
|
type frr-bfdd:profile-ref;
|
|
description
|
|
"Use this BFD profile for all peers by default.";
|
|
}
|
|
|
|
/*
|
|
* Operational data.
|
|
*/
|
|
container state {
|
|
config false;
|
|
description
|
|
"Operational data.";
|
|
|
|
container neighbors {
|
|
description
|
|
"Neighbor information.";
|
|
list neighbor {
|
|
key "address";
|
|
description
|
|
"A RIP neighbor.";
|
|
leaf address {
|
|
type inet:ipv4-address;
|
|
description
|
|
"IP address that a RIP neighbor is using as its
|
|
source address.";
|
|
}
|
|
leaf last-update {
|
|
type yang:date-and-time;
|
|
description
|
|
"The time when the most recent RIP update was
|
|
received from this neighbor.";
|
|
}
|
|
leaf bad-packets-rcvd {
|
|
type yang:counter32;
|
|
description
|
|
"The number of RIP invalid packets received from
|
|
this neighbor which were subsequently discarded
|
|
for any reason (e.g. a version 0 packet, or an
|
|
unknown command type).";
|
|
}
|
|
leaf bad-routes-rcvd {
|
|
type yang:counter32;
|
|
description
|
|
"The number of routes received from this neighbor,
|
|
in valid RIP packets, which were ignored for any
|
|
reason (e.g. unknown address family, or invalid
|
|
metric).";
|
|
}
|
|
}
|
|
}
|
|
container routes {
|
|
description
|
|
"Route information.";
|
|
list route {
|
|
key "prefix";
|
|
description
|
|
"A RIP IPv4 route.";
|
|
leaf prefix {
|
|
type inet:ipv4-prefix;
|
|
description
|
|
"IP address (in the form A.B.C.D) and prefix length,
|
|
separated by the slash (/) character. The range of
|
|
values for the prefix-length is 0 to 32.";
|
|
}
|
|
container nexthops {
|
|
description "container of nexthops";
|
|
list nexthop {
|
|
description "A list of nexthop objects.";
|
|
leaf nh-type {
|
|
type frr-nexthop:nexthop-type;
|
|
mandatory true;
|
|
description
|
|
"The nexthop type.";
|
|
}
|
|
leaf protocol {
|
|
type frr-route-types:frr-route-types-v4;
|
|
description
|
|
"The protocol originating this route.";
|
|
}
|
|
leaf rip-type {
|
|
type rip-route-type;
|
|
description
|
|
"The RIP type of route.";
|
|
}
|
|
leaf gateway {
|
|
type inet:ipv4-address;
|
|
description
|
|
"The nexthop gateway address.";
|
|
}
|
|
leaf interface {
|
|
type frr-interface:interface-ref;
|
|
description
|
|
"The nexthop egress interface.";
|
|
}
|
|
leaf from {
|
|
type inet:ipv4-address;
|
|
description
|
|
"The nexthop gateway address.";
|
|
}
|
|
leaf tag {
|
|
type uint32;
|
|
default "0";
|
|
description
|
|
"Route tag";
|
|
}
|
|
leaf external-metric {
|
|
type uint32;
|
|
description
|
|
"External metric if learned from external protocol.";
|
|
}
|
|
leaf expire-time {
|
|
type uint32;
|
|
description
|
|
"Seconds before route expires.";
|
|
}
|
|
}
|
|
}
|
|
leaf metric {
|
|
type uint8 {
|
|
range "0..16";
|
|
}
|
|
description
|
|
"Route metric.";
|
|
}
|
|
/*
|
|
* Replaced by container `nexthops` above.
|
|
*/
|
|
leaf next-hop {
|
|
type inet:ipv4-address;
|
|
status deprecated;
|
|
description
|
|
"Next hop IPv4 address.";
|
|
}
|
|
leaf interface {
|
|
type frr-interface:interface-ref;
|
|
status deprecated;
|
|
description
|
|
"The interface that the route uses.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Per-interface configuration data
|
|
*/
|
|
augment "/frr-interface:lib/frr-interface:interface" {
|
|
description "rip interface data";
|
|
container rip {
|
|
description
|
|
"RIP interface parameters.";
|
|
leaf split-horizon {
|
|
type enumeration {
|
|
enum "disabled" {
|
|
value 0;
|
|
description
|
|
"Disables split-horizon processing.";
|
|
}
|
|
enum "simple" {
|
|
value 1;
|
|
description
|
|
"Enables simple split-horizon processing.";
|
|
}
|
|
enum "poison-reverse" {
|
|
value 2;
|
|
description
|
|
"Enables split-horizon processing with poison
|
|
reverse.";
|
|
}
|
|
}
|
|
default "simple";
|
|
description
|
|
"Controls RIP split-horizon processing on the specified
|
|
interface.";
|
|
}
|
|
leaf v2-broadcast {
|
|
type boolean;
|
|
default "false";
|
|
description
|
|
"Send IP broadcast v2 update.";
|
|
}
|
|
leaf version-receive {
|
|
type enumeration {
|
|
enum "unspecified" {
|
|
value 0;
|
|
description
|
|
"Inherit configuration from the routing instance.";
|
|
}
|
|
enum "1" {
|
|
value 1;
|
|
description
|
|
"Accept RIPv1 updates only.";
|
|
}
|
|
enum "2" {
|
|
value 2;
|
|
description
|
|
"Accept RIPv2 updates only.";
|
|
}
|
|
enum "both" {
|
|
value 3;
|
|
description
|
|
"Accept both RIPv1 and RIPv2 updates.";
|
|
}
|
|
enum "none" {
|
|
value 4;
|
|
description
|
|
"Do not accept neither RIPv1 nor RIPv2 updates.";
|
|
}
|
|
}
|
|
default "unspecified";
|
|
description
|
|
"Advertisement reception - Version control.";
|
|
}
|
|
leaf version-send {
|
|
type enumeration {
|
|
enum "unspecified" {
|
|
value 0;
|
|
description
|
|
"Inherit configuration from the routing instance.";
|
|
}
|
|
enum "1" {
|
|
value 1;
|
|
description
|
|
"Send RIPv1 updates only.";
|
|
}
|
|
enum "2" {
|
|
value 2;
|
|
description
|
|
"Send RIPv2 updates only.";
|
|
}
|
|
enum "both" {
|
|
value 3;
|
|
description
|
|
"Send both RIPv1 and RIPv2 updates.";
|
|
}
|
|
enum "none" {
|
|
value 4;
|
|
description
|
|
"Do not send neither RIPv1 nor RIPv2 updates.";
|
|
}
|
|
}
|
|
default "unspecified";
|
|
description
|
|
"Advertisement transmission - Version control.";
|
|
}
|
|
container authentication-scheme {
|
|
description
|
|
"Specify the authentication scheme for the RIP interface";
|
|
leaf mode {
|
|
type enumeration {
|
|
enum "none" {
|
|
value 0;
|
|
description
|
|
"No authentication.";
|
|
}
|
|
enum "plain-text" {
|
|
value 2;
|
|
description
|
|
"Plain-text authentication.";
|
|
}
|
|
enum "md5" {
|
|
value 3;
|
|
description
|
|
"MD5 authentication.";
|
|
}
|
|
}
|
|
default "none";
|
|
description
|
|
"Specify the authentication mode.";
|
|
}
|
|
leaf md5-auth-length {
|
|
when "../mode = 'md5'";
|
|
type enumeration {
|
|
enum "16" {
|
|
value 16;
|
|
description
|
|
"RFC compatible.";
|
|
}
|
|
enum "20" {
|
|
value 20;
|
|
description
|
|
"Old ripd compatible.";
|
|
}
|
|
}
|
|
default "20";
|
|
description
|
|
"MD5 authentication data length.";
|
|
}
|
|
}
|
|
choice authentication-data {
|
|
description
|
|
"Choose whether to use a simple password or a key-chain.";
|
|
leaf authentication-password {
|
|
type string {
|
|
length "1..16";
|
|
}
|
|
description
|
|
"Authentication string.";
|
|
}
|
|
leaf authentication-key-chain {
|
|
type string;
|
|
description
|
|
"Key-chain name.";
|
|
}
|
|
}
|
|
|
|
container bfd-monitoring {
|
|
presence
|
|
"Present if BFD is configured for RIP peers in this interface.";
|
|
description "Configure BFD use in RIPD";
|
|
|
|
leaf enable {
|
|
type boolean;
|
|
default false;
|
|
description
|
|
"Enable/disable BFD monitoring.";
|
|
}
|
|
|
|
leaf profile {
|
|
type frr-bfdd:profile-ref;
|
|
description
|
|
"BFD profile to use.";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* RPCs
|
|
*/
|
|
rpc clear-rip-route {
|
|
description
|
|
"Clears RIP routes from the IP routing table and routes
|
|
redistributed into the RIP protocol.";
|
|
|
|
input {
|
|
leaf vrf {
|
|
type frr-vrf:vrf-ref;
|
|
description
|
|
"VRF name identifying a specific RIP instance.
|
|
This leaf is optional for the rpc.
|
|
If it is specified, the rpc will clear all routes in the
|
|
specified RIP instance;
|
|
if it is not specified, the rpc will clear all routes in
|
|
all RIP instances.";
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Notifications
|
|
*/
|
|
notification authentication-type-failure {
|
|
description
|
|
"This notification is sent when the system
|
|
receives a PDU with the wrong authentication type
|
|
field.";
|
|
leaf interface-name {
|
|
type frr-interface:interface-ref;
|
|
description
|
|
"Describes the name of the RIP interface.";
|
|
}
|
|
leaf raw-pdu {
|
|
type binary;
|
|
description
|
|
"Received raw PDU.";
|
|
}
|
|
}
|
|
notification authentication-failure {
|
|
description
|
|
"This notification is sent when the system
|
|
receives a PDU with the wrong authentication
|
|
information.";
|
|
leaf interface-name {
|
|
type frr-interface:interface-ref;
|
|
description
|
|
"Describes the name of the RIP interface.";
|
|
}
|
|
leaf raw-pdu {
|
|
type binary;
|
|
description
|
|
"Received raw PDU.";
|
|
}
|
|
}
|
|
}
|