module ietf-rip {

    yang-version 1.1;

    namespace
      "urn:ietf:params:xml:ns:yang:ietf-rip";

    prefix rip;

    import ietf-inet-types {
      prefix inet;
    }
    import ietf-yang-types {
      prefix yang;
    }
    import ietf-interfaces {
      prefix if;
    }
    import ietf-ip {
      prefix ip;
    }
    import ietf-routing {
      prefix rt;
    }
    import ietf-key-chain {
      prefix key-chain;
    }
    import ietf-bfd-types {
      prefix bfd-types;
    }
    import ietf-ospf {
      prefix ospf;
    }
    import ietf-isis {
      prefix isis;
    }

    organization
      "IETF Routing Area Working Group (rtgwg)";

    contact
      "WG Web:   <https://datatracker.ietf.org/wg/rtgwg/>
     WG List:  <mailto:rgtwg@ietf.org>

     Editor:   Xufeng Liu
               <mailto:xufeng.liu.ietf@gmail.com>

     Editor:   Prateek Sarda
               <mailto:prateek.sarda@ericsson.com>

     Editor:   Vikram Choudhary
               <mailto:vikschw@gmail.com>";

    description
      "This YANG module defines a model for managing Routing
     Information Protocol (RIP), including RIP version 2 and RIPng.

     Copyright (c) 2020 IETF Trust and the persons identified as
     authors of the code.  All rights reserved.

     Redistribution and use in source and binary forms, with or
     without modification, is permitted pursuant to, and subject to
     the license terms contained in, the Simplified BSD License set
     forth in Section 4.c of the IETF Trust's Legal Provisions
     Relating to IETF Documents
     (http://trustee.ietf.org/license-info).

     This version of this YANG module is part of RFC 8695; see the
     RFC itself for full legal notices.";

    revision "2020-02-20" {
      description "Initial revision.";
      reference
        "RFC 8695: A YANG Data Model for Routing Information Protocol
        (RIP).
         RFC 2453: RIP Version 2.
         RFC 2080: RIPng for IPv6.
         RFC 1724: RIP Version 2 MIB Extension.";

    }


    feature bfd {
      description
        "This feature indicates that the RIP implementation on the
       system supports BFD (Bidirectional Forwarding Detection).";
    }

    feature explicit-neighbors {
      description
        "This feature indicates that the system supports explicit
       neighbor configuration on a RIP interface.";
    }

    feature global-statistics {
      description
        "This feature indicates that the system supports collecting
       global statistics data related to RIP.";
    }

    feature interface-statistics {
      description
        "This feature indicates that the system supports collecting
       per-interface statistics data related to RIP.";
    }

    typedef prefix-set-ref {
      type string;
      description
        "A type for a reference to a prefix set.
       The string value is the name identifier for uniquely
       identifying the referenced prefix set, which contains a list
       of prefixes that a routing policy can applied.  The definition
       of such a prefix set is outside the scope of this document.";
    }

    typedef route-policy-ref {
      type string;
      description
        "A type for a reference to a route policy.
       The string value is the name identifier for uniquely
       identifying the referenced routing policy, which contains one
       or more policy rules that can be used for a routing decision.
       The definition of such a routing policy is outside the scope
       of this document.";
    }

    identity rip {
      base rt:routing-protocol;
      description
        "Identity for the Routing Information Protocol.";
    }

    identity ripv2 {
      base rip:rip;
      description
        "Identity for RIPv2 (RIP version 2).";
    }

    identity ripng {
      base rip:rip;
      description "Identity for RIPng.";
    }

    grouping originate-default-route-container {
      description
        "Container for settings on whether to originate the default
       route in RIP routing instance.";
      container originate-default-route {
        description
          "Injects the default route into the RIP (RIPv2 or RIPng)
         routing instance.";
        leaf enabled {
          type boolean;
          default "false";
          description
            "'true' if originating default route is enabled.";
        }

        leaf route-policy {
          type route-policy-ref;
          description
            "The conditions of the route policy are applied to the
           default route.";
        }
      }  // container originate-default-route
    }  // grouping originate-default-route-container

    grouping redistribute-container {
      description
        "Container of redistribute attributes.";
      container redistribute {
        description
          "Redistributes routes learned from other routing protocols
         into the RIP routing instance.";
        list bgp {
          key "asn";
          description
            "Redistributes routes from the specified BGP (Border
           Gateway Protocol) autonomous system (AS) into the RIP
           routing instance.";
          leaf asn {
            type inet:as-number;
            description
              "BGP autonomous system (AS) number.";
          }

          uses redistribute-route-policy-attributes;
        }  // list bgp

        container cg-nat {
          presence
            "Present if Carrier-Grade Network Address
                  Translation (CGNAT) routes are redistributed.";
          description
            "Carrier-Grade Network Address Translation (CGNAT)
           routes.";
          uses redistribute-route-policy-attributes;
        }  // container cg-nat

        container connected {
          presence
            "Present if directly attached network routes are
                  redistributed.";
          description
            "Redistributes directly attached networks into the RIP
           routing instance.";
          uses redistribute-route-policy-attributes;
        }  // container connected

        container ipsec {
          presence
            "Present if IP security routing instance routes
                  are redistributed.";
          description
            "Redistributes routes from the IP security routing
           instance into the RIP routing instance.";
          uses redistribute-route-policy-attributes;
        }  // container ipsec

        list isis {
          key "instance";
          description
            "Redistributes IS-IS routes.";
          leaf instance {
            type leafref {
              path
                "../../../../../rt:control-plane-protocol/rt:name";
            }
            must
              "derived-from-or-self("
                + "../../../../../rt:control-plane-protocol"
                + "[rt:name = current()]/rt:type, 'isis:isis')" {
              description
                "The type of the routing protocol must be 'isis'.";
            }
            description
              "Redistributes routes from the specified IS-IS routing
             instance into the RIP routing instance.";
          }

          leaf level {
            type enumeration {
              enum "1" {
                value 0;
                description
                  "IS-IS level 1 routes.";
              }
              enum "2" {
                value 1;
                description
                  "IS-IS level 2 routes.";
              }
              enum "1-2" {
                value 2;
                description
                  "IS-IS level 1-2 routes.";
              }
            }
            description "IS-IS level.";
          }

          uses redistribute-route-policy-attributes;
        }  // list isis

        container nat {
          presence
            "Present if Network Address Translation (NAT) routes
                  are redistributed.";
          description
            "Redistributes Network Address Translation (NAT)
           routes into the RIP routing instance.";
          uses redistribute-route-policy-attributes;
        }  // container nat

        list ospfv2 {
          when
            "derived-from-or-self(../../../rt:type, 'rip:ripv2')" {
            description
              "Applicable to RIPv2.";
          }
          key "instance";
          description
            "Redistributes routes from the specified OSPFv2 routing
           instance into the RIPv2 routing instance.";
          leaf instance {
            type leafref {
              path
                "../../../../../rt:control-plane-protocol/rt:name";
            }
            must
              "derived-from-or-self("
                + "../../../../../rt:control-plane-protocol"
                + "[rt:name = current()]/rt:type, 'ospf:ospfv2')" {
              description
                "The type of the routing protocol must be 'ospfv2'.";
            }
            description
              "OSPFv2 instance ID. Redistributes routes from the
             specified OSPFv2 routing instance into the RIPv2 routing
             instance.";
          }

          leaf route-type {
            type ospf:route-type;
            description
              "Redistributes only those OSPFv2 routes matching the
             specified route type into the RIPv2 routing instance.";
          }

          uses redistribute-route-policy-attributes;
        }  // list ospfv2

        list ospfv3 {
          when
            "derived-from-or-self(../../../rt:type, 'rip:ripng')" {
            description
              "Applicable to RIPng.";
          }
          key "instance";
          description
            "Redistributes routes from the specified OSPFv3 routing
           instance into the RIPng routing instance.";
          leaf instance {
            type leafref {
              path
                "../../../../../rt:control-plane-protocol/rt:name";
            }
            must
              "derived-from-or-self("
                + "../../../../../rt:control-plane-protocol"
                + "[rt:name = current()]/rt:type, 'ospf:ospfv3')" {
              description
                "The type of the routing protocol must be 'ospfv3'.";
            }
            description
              "OSPFv3 instance ID. Redistributes routes from the
             specified OSPFv3 routing instance into the RIPng routing
             instance.";
          }

          leaf route-type {
            type ospf:route-type;
            description
              "Redistributes only those OSPFv3 routes matching the
             specified route type into the RIPng routing instance.";
          }

          uses redistribute-route-policy-attributes;
        }  // list ospfv3

        list ripv2 {
          when
            "derived-from-or-self(../../../rt:type, 'rip:ripv2')" {
            description
              "Applicable to RIPv2.";
          }
          key "instance";
          description
            "Redistributes routes from another RIPv2 routing instance
           into the current RIPv2 routing instance.";
          leaf instance {
            type leafref {
              path
                "../../../../../rt:control-plane-protocol/rt:name";
            }
            must
              "derived-from-or-self("
                + "../../../../../rt:control-plane-protocol"
                + "[rt:name = current()]/rt:type, 'rip:ripv2')" {
              description
                "The type of the routing protocol must be 'ripv2'.";
            }
            description
              "Redistributes routes from the specified RIPv2 routing
             instance into the RIPv2 routing instance.";
          }

          uses redistribute-route-policy-attributes;
        }  // list ripv2

        list ripng {
          when
            "derived-from-or-self(../../../rt:type, 'rip:ripng')" {
            description
              "Applicable to RIPng.";
          }
          key "instance";
          description
            "Redistributes routes from another RIPng routing instance
           into the current RIPng routing instance.";
          leaf instance {
            type leafref {
              path
                "../../../../../rt:control-plane-protocol/rt:name";
            }
            must
              "derived-from-or-self("
                + "../../../../../rt:control-plane-protocol"
                + "[rt:name = current()]/rt:type, 'rip:ripng')" {
              description
                "The type of the routing protocol must be 'ripng'.";
            }
            description
              "Redistributes routes from the specified RIPng routing
             instance into the RIPng routing instance.";
          }

          uses redistribute-route-policy-attributes;
        }  // list ripng

        container static {
          presence
            "Present if redistributing static routes.";
          description
            "Redistributes static routes into the RIP routing
           instance.";
          uses redistribute-route-policy-attributes;
        }  // container static
      }  // container redistribute
    }  // grouping redistribute-container

    grouping redistribute-route-policy-attributes {
      description
        "Attributes for redistributing a route policy.";
      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 1.";
      }

      leaf route-policy {
        type route-policy-ref;
        description
          "Applies the conditions of the specified route policy to
         routes that are redistributed into the RIP routing
         instance.";
      }
    }  // grouping redistribute-route-policy-attributes

    grouping timers-container {
      description
        "Container for settings of basic timers";
      container timers {
        must
          'invalid-interval >= (update-interval * 3)' {
          description
            "invalid-interval must be at least three times the value
           for the update-interval argument.";
        }
        must
          'flush-interval > invalid-interval' {
          description
            "flush-interval must be larger than the value for the
           invalid-interval argument.";
        }
        description
          "Timers for the specified RIPv2 or RIPng instance or
         interface.";
        leaf update-interval {
          type uint16 {
            range "1..32767";
          }
          units "seconds";
          default "30";
          description
            "Interval at which RIPv2 or RIPng updates are sent.";
        }

        leaf invalid-interval {
          type uint16 {
            range "1..32767";
          }
          units "seconds";
          default "180";
          description
            "Interval before a route is declared invalid after no
           updates are received.  This value is at least three times
           the value for the update-interval argument.";
        }

        leaf holddown-interval {
          type uint16 {
            range "1..32767";
          }
          units "seconds";
          default "180";
          description
            "Interval before better routes are released.";
        }

        leaf flush-interval {
          type uint16 {
            range "1..32767";
          }
          units "seconds";
          default "240";
          description
            "Interval before a route is flushed from the routing
           table. This value must be larger than the value for the
           invalid-interval argument.";
        }
      }  // container timers
    }  // grouping timers-container

    grouping global-attributes {
      description
        "Global configuration and state attributes.";
      uses originate-default-route-container;

      leaf default-metric {
        type uint8 {
          range "0..16";
        }
        default "1";
        description
          "Set the default metric.";
      }

      leaf distance {
        type uint8 {
          range "1..255";
        }
        default "120";
        description
          "The administrative distance of the RIPv2 or RIPng for the
         current RIPv2 or RIPng instance.";
      }

      leaf triggered-update-threshold {
        type uint8 {
          range "1..30";
        }
        units "seconds";
        default "5";
        description
          "This attribute is used to suppress triggered updates.
         When the arrival of a regularly scheduled update matches the
         number of seconds or is less than the number seconds
         configured with this attribute, the triggered update is
         suppressed.";
      }

      leaf maximum-paths {
        type uint8 {
          range "1..16";
        }
        default "8";
        description
          "The number of multiple equal-cost RIPv2 or RIPng routes
         that can be used as the best paths for balancing the load
         of outgoing traffic packets.";
      }

      leaf output-delay {
        type uint8 {
          range "1..50";
        }
        units "milliseconds";
        description
          "A delay time between packets sent in multipacket
         RIPv2 or RIPng updates.";
      }
    }  // grouping global-attributes

    grouping distribute-lists {
      description
        "Grouping for distribute lists.";
      list distribute-list {
        key "prefix-set-name direction";
        description
          "List of distribute-lists, which are used to filter incoming
         or outgoing routing updates.";
        leaf prefix-set-name {
          type prefix-set-ref;
          description
            "Reference to a prefix list to be applied to RIPv2 or
           RIPng packets.";
        }

        leaf direction {
          type enumeration {
            enum "in" {
              value 0;
              description
                "Apply the distribute-list to incoming routes.";
            }
            enum "out" {
              value 1;
              description
                "Apply the distribute-list to outgoing routes.";
            }
          }
          description
            "Direction of the routing updates.";
        }

        leaf if-name {
          type if:interface-ref;
          description
            "Reference to an interface to which the prefix list is
           applied.";
        }
      }  // list distribute-list
    }  // grouping distribute-lists

    grouping route-attributes {
      description
        "Grouping for route attributes.";
      leaf redistributed {
        type boolean;
        description "Redistributed routes.";
      }

      leaf route-type {
        type enumeration {
          enum "connected" {
            value 0;
            description "Connected route.";
          }
          enum "external" {
            value 1;
            description "External route.";
          }
          enum "external-backup" {
            value 2;
            description
              "External backup route.";
          }
          enum "rip" {
            value 3;
            description "RIP route.";
          }
        }
        description "Route type.";
      }

      leaf metric {
        type uint8 {
          range "0..16";
        }
        description "Route metric.";
      }

      leaf expire-time {
        type uint16;
        description "Expiration time.";
      }

      leaf deleted {
        type boolean;
        description "Deleted route.";
      }

      leaf holddown {
        type boolean;
        description "Holddown route.";
      }

      leaf need-triggered-update {
        type boolean;
        description
          "The route needs triggered update.";
      }

      leaf inactive {
        type boolean;
        description "The route is inactive.";
      }

      leaf flush-expire-before-holddown {
        type boolean;
        description
          "The flush timer expired before holddown time.";
      }
    }  // grouping route-attributes

    augment /rt:routing/rt:control-plane-protocols/rt:control-plane-protocol {
      when
        "derived-from(rt:type, 'rip:rip')" {
        description
          "This augment is only valid for a routing protocol instance
         of RIP (type 'ripv2' or 'ripng').";
      }
      description "RIP augmentation.";
      container rip {
        description "RIP data.";
        uses global-attributes;

        uses distribute-lists;

        uses redistribute-container;

        uses timers-container;

        container interfaces {
          description
            "Containing a list of RIP interfaces.";
          list interface {
            key "interface";
            description
              "List of RIP interfaces.";
            leaf interface {
              type if:interface-ref;
              must
                "(derived-from-or-self("
                  + "../../../../rt:type, 'rip:ripv2') and "
                  + "/if:interfaces/if:interface[if:name=current()]/"
                  + "ip:ipv4) or "
                  + "(derived-from-or-self("
                  + "../../../../rt:type, 'rip:ripng') and "
                  + "/if:interfaces/if:interface[if:name=current()]/"
                  + "ip:ipv6)" {
                error-message
                  "Invalid interface type.";
                description
                  "RIPv2 can be enabled on IPv4 interface, and
                 RIPng can be enabled on IPv6 interface.";
              }
              description
                "Enable RIP on this interface.";
            }

            container authentication {
              when
                "derived-from-or-self("
                  + "../../../../rt:type, 'rip:ripv2')" {
                description
                  "Only applicable to RIPv2.";
              }
              description
                "Enables authentication and specifies the
               authentication scheme for the RIP interface.";
              choice auth-type-selection {
                description
                  "Specify the authentication scheme.";
                reference
                  "RFC8177: YANG Data Model for Key Chains.";

                leaf key-chain {
                  type key-chain:key-chain-ref;
                  description
                    "key-chain name.";
                }

                case auth-key {
                  leaf key {
                    type string;
                    description
                      "Key string in ASCII format.";
                  }

                  leaf crypto-algorithm {
                    type identityref {
                      base key-chain:crypto-algorithm;
                    }
                    description
                      "Cryptographic algorithm associated with the
                     key.";
                  }
                }  // case auth-key
              }  // choice auth-type-selection
            }  // container authentication

            container bfd {
              if-feature bfd;
              description
                "BFD configuration.";
              uses bfd-types:client-cfg-parms;
            }  // container bfd

            leaf cost {
              type uint8 {
                range "1..16";
              }
              default "1";
              description "Interface cost.";
            }

            container neighbors {
              if-feature explicit-neighbors;
              description
                "Specifies the RIP neighbors.  Useful for a
               non-broadcast multiple access (NBMA) network.";
              list neighbor {
                key "address";
                description
                  "Specify a RIP neighbor on a non-broadcast network.";
                leaf address {
                  type inet:ip-address;
                  description
                    "Neighbor IP address.";
                }
              }  // list neighbor
            }  // container neighbors

            leaf no-listen {
              type empty;
              description
                "Disables listening to, and processing of, RIPv2 or
               RIPng packets on the specified interface.";
            }

            uses originate-default-route-container;

            leaf passive {
              type empty;
              description
                "Disables sending of RIPv2 or RIPng packets on the
               specified interface.";
            }

            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 RIPv2 or RIPng split-horizon processing on
               the specified interface.";
            }

            container summary-address {
              description
                "Summarizes information about RIPv2 or RIPng routes
               sent over the specified interface in RIPv2 or RIPng
               update packets.";
              leaf address {
                type inet:ip-prefix;
                description
                  "Specifies the IP address and the prefix length that
                 identify the routes to be summarized.  The IP
                 address can be specified in either IPv4 or IPv6
                 format, as specified in RFC6991.";
              }

              leaf metric {
                type uint8 {
                  range "0..16";
                }
                description
                  "Metric used for the route.  If this attribute is not
                 used, the value set through the default-metric
                 attribute in RIPv2 or RIPng router configuration is
                 used for the route.";
              }
            }  // container summary-address

            uses timers-container;

            leaf oper-status {
              type enumeration {
                enum "up" {
                  value 0;
                  description
                    "RIPv2 or RIPng is operational on this interface.";
                }
                enum "down" {
                  value 1;
                  description
                    "RIPv2 or RIPng is not operational on this
                   interface.";
                }
              }
              config false;
              description
                "Operational state.";
            }

            leaf next-full-update {
              type uint32;
              config false;
              description
                "Next full update time.";
            }

            leaf valid-address {
              type boolean;
              config false;
              description
                "The interface has a valid address.";
            }

            container statistics {
              if-feature interface-statistics;
              config false;
              description
                "Interface statistics counters.";
              leaf discontinuity-time {
                type yang:date-and-time;
                description
                  "The time on the most recent occasion at which any
                 one or more of the statistics counters suffered a
                 discontinuity.  If no such discontinuities have
                 occurred since the last re-initialization of the
                 local management subsystem, then this node contains
                 the time the local management subsystem
                 re-initialized itself.";
              }

              leaf bad-packets-rcvd {
                type yang:counter32;
                description
                  "The number of RIP invalid packets received by
                 the RIP process that 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, in valid RIP packets,
                 which were ignored for any reason (e.g., unknown
                 address family, or invalid metric).";
              }

              leaf updates-sent {
                type yang:counter32;
                description
                  "The number of triggered RIP updates actually
                 sent on this interface.  This explicitly does
                 NOT include full updates sent containing new
                 information.";
              }
            }  // container statistics
          }  // list interface
        }  // container interfaces

        leaf next-triggered-update {
          type uint32;
          config false;
          description
            "Next triggered update.";
        }

        leaf num-of-routes {
          type uint32;
          config false;
          description
            "The number of routes.";
        }

        container ipv4 {
          when
            "derived-from-or-self(../../rt:type, 'rip:ripv2')" {
            description
              "IPv4 address family is supported by RIPv2.";
          }
          config false;
          description
            "IPv4 address family information.";
          container neighbors {
            description
              "IPv4 neighbor information.";
            list neighbor {
              key "ipv4-address";
              description
                "A RIPv2 neighbor.";
              leaf ipv4-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 that 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 that were ignored for any
                 reason (e.g., unknown address family, or invalid
                 metric).";
              }
            }  // list neighbor
          }  // container neighbors

          container routes {
            description
              "IPv4 route information.";
            list route {
              key "ipv4-prefix";
              description
                "A RIPv2 IPv4 route.";
              leaf ipv4-prefix {
                type inet:ipv4-prefix;
                description
                  "IPv4 address and prefix length, in the format
                 specified in RFC6991.";
              }

              leaf next-hop {
                type inet:ipv4-address;
                description
                  "Next hop IPv4 address.";
              }

              leaf interface {
                type if:interface-ref;
                description
                  "The interface that the route uses.";
              }

              uses route-attributes;
            }  // list route
          }  // container routes
        }  // container ipv4

        container ipv6 {
          when
            "derived-from-or-self(../../rt:type, 'rip:ripng')" {
            description
              "IPv6 address family is supported by RIPng.";
          }
          config false;
          description
            "IPv6 address family information.";
          container neighbors {
            description
              "IPv6 neighbor information.";
            list neighbor {
              key "ipv6-address";
              description
                "A RIPng neighbor.";
              leaf ipv6-address {
                type inet:ipv6-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 that 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 that were ignored for any
                 reason (e.g., unknown address family, or invalid
                 metric).";
              }
            }  // list neighbor
          }  // container neighbors

          container routes {
            description
              "IPv6 route information.";
            list route {
              key "ipv6-prefix";
              description
                "A RIPng IPv6 route.";
              leaf ipv6-prefix {
                type inet:ipv6-prefix;
                description
                  "IPv6 address and prefix length, in the format
                 specified in RFC6991.";
              }

              leaf next-hop {
                type inet:ipv6-address;
                description
                  "Next hop IPv6 address.";
              }

              leaf interface {
                type if:interface-ref;
                description
                  "The interface that the route uses.";
              }

              uses route-attributes;
            }  // list route
          }  // container routes
        }  // container ipv6

        container statistics {
          if-feature global-statistics;
          config false;
          description
            "Global statistics counters.";
          leaf discontinuity-time {
            type yang:date-and-time;
            description
              "The time on the most recent occasion at which any one
             or more of the statistics counters suffered a
             discontinuity.  If no such discontinuities have occurred
             since the last re-initialization of the local
             management subsystem, then this node contains the time
             the local management subsystem re-initialized itself.";
          }

          leaf requests-rcvd {
            type yang:counter32;
            description
              "The number of requests received by RIP.";
          }

          leaf requests-sent {
            type yang:counter32;
            description
              "The number of requests sent by RIP.";
          }

          leaf responses-rcvd {
            type yang:counter32;
            description
              "The number of responses received by RIP.";
          }

          leaf responses-sent {
            type yang:counter32;
            description
              "The number of responses sent by RIP.";
          }
        }  // container statistics
      }  // container rip
    }

    rpc clear-rip-route {
      description
        "Clears RIP routes from the IP routing table and routes
       redistributed into RIP for the specified RIP instance
       or for all RIP instances in the current context.";
      input {
        leaf rip-instance {
          type leafref {
            path "/rt:routing/rt:control-plane-protocols/rt:control-plane-protocol/rt:name";
          }
          description
            "Instance 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.";
        }
      }
    }  // rpc clear-rip-route
  }  // module ietf-rip