module Cisco-IOS-XR-ip-rip-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XR-ip-rip-oper";

    prefix ip-rip-oper;

    import ietf-inet-types {
      prefix inet;
    }
    import Cisco-IOS-XR-types {
      prefix xr;
    }
    import cisco-semver {
      prefix semver;
    }

    include Cisco-IOS-XR-ip-rip-oper-sub1 {
      revision-date "2019-04-05";
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for Cisco IOS-XR ip-rip package operational data.
     
     This module contains definitions
     for the following management objects:
       rip: RIP operational data
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-04-05" {
      description
        "Establish semantic version baseline.";
    }

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.0.1";

    container rip {
      config false;
      description "RIP operational data";
      container vrfs {
        description
          "VRF related operational data";
        list vrf {
          key "vrf-name";
          description
            "Operational data for a particular VRF";
          leaf vrf-name {
            type xr:Cisco-ios-xr-string;
            description "Name of the VRF";
          }

          container routes {
            description "RIP route database";
            list route {
              description
                "A route in the RIP database";
              leaf prefix {
                type inet:ipv4-address-no-zone;
                description "Network prefix";
              }

              leaf prefix-length {
                type uint32 {
                  range "0..32";
                }
                description "Prefix length";
              }

              leaf destination-address {
                type inet:ipv4-address;
                description
                  "Destination IP Address for this route";
              }

              leaf prefix-length-xr {
                type uint32;
                description
                  "Prefix length of IP address";
              }

              leaf distance {
                type uint16;
                description
                  "Route administrative distance";
              }

              leaf bgp-count {
                type uint16;
                description
                  "Hop count for this route";
              }

              leaf route-type {
                type uint16;
                description
                  "Type of this route";
              }

              leaf route-summary {
                type boolean;
                description
                  "Summary route placeholder indicator";
              }

              leaf route-tag {
                type uint16;
                description
                  "Generic route information";
              }

              leaf version {
                type uint8;
                description
                  "RIB supplied version number";
              }

              leaf attributes {
                type uint32;
                description
                  "RIB supplied route attributes";
              }

              leaf active {
                type boolean;
                description
                  "Active route indicator";
              }

              leaf path-origin {
                type Rip-route-origin;
                description
                  "Where this route was learnt";
              }

              leaf hold-down {
                type boolean;
                description
                  "Indicates whether route is in holddown";
              }

              list paths {
                description
                  "The paths for this route";
                leaf source-address {
                  type inet:ipv4-address;
                  description
                    "Source address";
                }

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

                leaf metric {
                  type uint16;
                  description "Metric";
                }

                leaf tag {
                  type uint16;
                  description "Tag";
                }

                leaf interface {
                  type xr:Interface-name;
                  description "Interface";
                }

                leaf uptime {
                  type uint32;
                  description "Up time";
                }

                leaf is-permanent {
                  type boolean;
                  description
                    "Permanent indicator";
                }
              }  // list paths
            }  // list route
          }  // container routes

          container configuration {
            description
              "RIP global configuration";
            leaf active {
              type boolean;
              description
                "VRF active indicator";
            }

            leaf vr-fised-socket {
              type boolean;
              description
                "VRF added to socket indicator";
            }

            leaf rip-version {
              type int32;
              description
                "Version of RIP configured";
            }

            leaf default-metric {
              type uint8;
              description
                "Default metric for RIP routes";
            }

            leaf maximum-paths {
              type uint8;
              description
                "Maximum number of paths a route can have";
            }

            leaf auto-summarize {
              type boolean;
              description
                "Auto-summarization indicator";
            }

            leaf multicast-address {
              type boolean;
              description
                "Use broadcast/multicast address indicator";
            }

            leaf flash-threshold {
              type uint8;
              description
                "Flash update threshold";
            }

            leaf input-q-length {
              type uint16;
              description
                "Length of the input queue";
            }

            leaf triggered-rip {
              type boolean;
              description
                "Triggered RIP enabled indicator";
            }

            leaf validation-indicator {
              type boolean;
              description
                "Incoming packet source validation indicator";
            }

            leaf update-timer {
              type uint32;
              description "Update timer";
            }

            leaf next-update-time {
              type uint32;
              description
                "Time left for next update";
            }

            leaf invalid-timer {
              type uint32;
              description "Invalid timer";
            }

            leaf hold-down-timer {
              type uint32;
              description "Holddown timer";
            }

            leaf flush-timer {
              type uint32;
              description "Flush timer";
            }

            leaf oom-flags {
              type uint32;
              description
                "Out-of-memory status flags";
            }

            leaf nsf-status {
              type boolean;
              description
                "NSF Enable status";
            }

            leaf nsf-life-time {
              type uint32;
              description "NSF life time";
            }
          }  // container configuration

          container statistics {
            description
              "RIP statistics information";
            leaf received-packets {
              type uint32;
              description
                "Total packets received";
            }

            leaf discarded-packets {
              type uint32;
              description
                "Total discarded packets";
            }

            leaf discarded-routes {
              type uint32;
              description
                "Total discarded routes";
            }

            leaf standby-packets-received {
              type uint32;
              description
                "Packets rx in SRP";
            }

            leaf sent-messages {
              type uint32;
              description
                "Number of messages sent";
            }

            leaf sent-message-failures {
              type uint32;
              description
                "Number of message send failures";
            }

            leaf query-responses {
              type uint32;
              description
                "Number of RIP queries responded to";
            }

            leaf periodic-updates {
              type uint32;
              description
                "Number of periodic RIP updates";
            }

            leaf route-count {
              type uint32;
              description
                "Number of routes allocated";
            }

            leaf path-count {
              type uint32;
              description
                "Number of paths allocated";
            }

            leaf route-malloc-failures {
              type uint32;
              description
                "Number of failures to allocate memory for a
route";
            }

            leaf path-malloc-failures {
              type uint32;
              description
                "Number of failures to allocate memory for a path";
            }

            leaf rib-updates {
              type uint32;
              description
                "Number of route updates to RIB made by RIP";
            }
          }  // container statistics

          container interfaces {
            description "RIP interfaces";
            list interface {
              key "interface-name";
              description
                "Information about a particular RIP interface";
              leaf interface-name {
                type xr:Interface-name;
                description "Interface name";
              }

              leaf interface {
                type string;
                description "Interface name";
              }

              leaf if-handle {
                type xr:Interface-name;
                description
                  "Interface handle";
              }

              leaf rip-enabled {
                type boolean;
                description
                  "Whether RIP is enabled on this interface";
              }

              leaf is-passive-interface {
                type boolean;
                description
                  "Passive interface indicator";
              }

              leaf multicast-address {
                type boolean;
                description
                  "Use broadcast address for v2 packets";
              }

              leaf accept-metric {
                type boolean;
                description
                  "Accept routes of metric 0 indicator";
              }

              leaf send-version {
                type uint32;
                description
                  "Versions that the interface is sending";
              }

              leaf receive-version {
                type uint32;
                description
                  "Versions that the interface will recieve";
              }

              leaf state {
                type Interface-state;
                description
                  "Current state of the interface";
              }

              leaf destination-address {
                type inet:ipv4-address;
                description
                  "IP Address of this interface";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Prefix length of the IP address";
              }

              leaf metric-cost {
                type uint32;
                description
                  "Cost added to routes through this interface";
              }

              leaf split-horizon {
                type boolean;
                description
                  "Split horizon enabled indicator";
              }

              leaf poison-horizon {
                type boolean;
                description
                  "Poisoned reverse enabled indicator";
              }

              leaf triggered-rip {
                type boolean;
                description
                  "Triggered RIP enabled indicator";
              }

              leaf neighbor-address {
                type inet:ipv4-address;
                description
                  "Interface's triggered RIP neighbor";
              }

              leaf oom-flags {
                type uint32;
                description
                  "Out-of-memory status flags";
              }

              leaf join-status {
                type boolean;
                description
                  "Multicast group join status";
              }

              leaf lpts-state {
                type boolean;
                description "LPTSState";
              }

              leaf auth-mode {
                type uint32;
                description
                  "Authentication Mode";
              }

              leaf auth-keychain {
                type string;
                description
                  "Authentication Keychain Name";
              }

              leaf send-auth-key-exists {
                type boolean;
                description
                  "Authentication send key exists";
              }

              leaf auth-key-md5 {
                type boolean;
                description
                  "Authentication key programmed with MD5 algorithm";
              }

              leaf auth-key-send-id {
                type uint64;
                description
                  "Current active Send Authentication Key Id";
              }

              leaf total-pkt-recvd {
                type uint32;
                description
                  "Total packets received";
              }

              leaf pkt-drop-wrong-kc {
                type uint32;
                description
                  "Packets dropped due to wrong keychain configured";
              }

              leaf pkt-drop-no-auth {
                type uint32;
                description
                  "Packets dropped due to missing authentication
data";
              }

              leaf pkt-drop-invalid-auth {
                type uint32;
                description
                  "Packets dropped due to invalid authentication
data";
              }

              leaf pkt-accepted-valid-auth {
                type uint32;
                description
                  "Packets accepted with valid authentication data";
              }

              list rip-summary {
                description
                  "User defined summary addresses";
                leaf prefix {
                  type inet:ipv4-address;
                  description
                    "Summary address prefix";
                }

                leaf prefix-length {
                  type uint32;
                  description
                    "Summary address prefix length";
                }

                leaf next-hop-address {
                  type inet:ipv4-address;
                  description
                    "Summary address next hop";
                }

                leaf metric {
                  type int32;
                  description
                    "Summary metric";
                }
              }  // list rip-summary

              list rip-peer {
                description
                  "Neighbors on this interface";
                leaf peer-uptime {
                  type uint32;
                  description
                    "Uptime of this peer";
                }

                leaf peer-address {
                  type inet:ipv4-address;
                  description
                    "IP Address of this peer";
                }

                leaf peer-version {
                  type uint8;
                  description
                    "RIP version for this peer";
                }

                leaf discarded-peer-packets {
                  type uint32;
                  description
                    "Discarded packets from this peer";
                }

                leaf discarded-peer-routes {
                  type uint32;
                  description
                    "Discarded routes from this peer";
                }
              }  // list rip-peer
            }  // list interface
          }  // container interfaces

          container global {
            description
              "Global Information ";
            container vrf-summary {
              description "VRF summary data";
              leaf vrf-name {
                type string;
                description "VRF Name";
              }

              leaf active {
                type boolean;
                description
                  "VRF Active indicator";
              }

              leaf oom-flags {
                type uint32;
                description
                  "Current OOM flags";
              }

              leaf route-count {
                type uint32;
                description
                  "Number of routes allocated";
              }

              leaf path-count {
                type uint32;
                description
                  "Number of paths allocated";
              }

              leaf update-timer {
                type uint32;
                description "Update timer";
              }

              leaf next-update-time {
                type uint32;
                description
                  "Time left for next update";
              }

              leaf invalid-timer {
                type uint32;
                description "Invalid timer";
              }

              leaf hold-down-timer {
                type uint32;
                description "Holddown timer";
              }

              leaf flush-timer {
                type uint32;
                description "Flush timer";
              }

              leaf interface-configured-count {
                type uint32;
                description
                  "Number of interfaces configured";
              }

              leaf active-interface-count {
                type uint32;
                description
                  "Number of active interfaces";
              }
            }  // container vrf-summary

            list interface-summary {
              description
                "List of Interfaces configured";
              leaf interface-name {
                type string;
                description "Interface name";
              }

              leaf enabled {
                type boolean;
                description
                  "RIP enabled indicator";
              }

              leaf state {
                type Interface-state;
                description
                  "Interface state";
              }

              leaf destination-address {
                type inet:ipv4-address;
                description "IP address";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Prefix length of IP address";
              }

              leaf oom-flags {
                type uint32;
                description
                  "Current OOM flags";
              }

              leaf send-version {
                type uint32;
                description
                  "RIP versions this interface sends out";
              }

              leaf receive-version {
                type uint32;
                description
                  "RIP versions this interface will receive";
              }

              leaf neighbor-count {
                type uint32;
                description
                  "Number of neighbors seen";
              }
            }  // list interface-summary
          }  // container global
        }  // list vrf
      }  // container vrfs

      container protocol {
        description
          "Protocol operational data";
        container process {
          description "RIP global process ";
          leaf vrf-config-count {
            type uint32;
            description
              "Number of VRFs configured";
          }

          leaf vrf-active-count {
            type uint32;
            description
              "Number of active VRFs";
          }

          leaf socket-descriptor {
            type int32;
            description "Socket descriptior";
          }

          leaf current-oom-state {
            type int32;
            description "Current OOM state";
          }

          leaf route-count {
            type uint32;
            description
              "Number of routes allocated";
          }

          leaf path-count {
            type uint32;
            description
              "Number of paths allocated";
          }

          list vrf-summary {
            description
              "List of VRFs configured";
            leaf vrf-name {
              type string;
              description "VRF Name";
            }

            leaf active {
              type boolean;
              description
                "VRF Active indicator";
            }

            leaf oom-flags {
              type uint32;
              description
                "Current OOM flags";
            }

            leaf route-count {
              type uint32;
              description
                "Number of routes allocated";
            }

            leaf path-count {
              type uint32;
              description
                "Number of paths allocated";
            }

            leaf update-timer {
              type uint32;
              description "Update timer";
            }

            leaf next-update-time {
              type uint32;
              description
                "Time left for next update";
            }

            leaf invalid-timer {
              type uint32;
              description "Invalid timer";
            }

            leaf hold-down-timer {
              type uint32;
              description "Holddown timer";
            }

            leaf flush-timer {
              type uint32;
              description "Flush timer";
            }

            leaf interface-configured-count {
              type uint32;
              description
                "Number of interfaces configured";
            }

            leaf active-interface-count {
              type uint32;
              description
                "Number of active interfaces";
            }
          }  // list vrf-summary
        }  // container process

        container default-vrf {
          description
            "RIP operational data for Default VRF";
          container routes {
            description "RIP route database";
            list route {
              description
                "A route in the RIP database";
              leaf prefix {
                type inet:ipv4-address-no-zone;
                description "Network prefix";
              }

              leaf prefix-length {
                type uint32 {
                  range "0..32";
                }
                description "Prefix length";
              }

              leaf destination-address {
                type inet:ipv4-address;
                description
                  "Destination IP Address for this route";
              }

              leaf prefix-length-xr {
                type uint32;
                description
                  "Prefix length of IP address";
              }

              leaf distance {
                type uint16;
                description
                  "Route administrative distance";
              }

              leaf bgp-count {
                type uint16;
                description
                  "Hop count for this route";
              }

              leaf route-type {
                type uint16;
                description
                  "Type of this route";
              }

              leaf route-summary {
                type boolean;
                description
                  "Summary route placeholder indicator";
              }

              leaf route-tag {
                type uint16;
                description
                  "Generic route information";
              }

              leaf version {
                type uint8;
                description
                  "RIB supplied version number";
              }

              leaf attributes {
                type uint32;
                description
                  "RIB supplied route attributes";
              }

              leaf active {
                type boolean;
                description
                  "Active route indicator";
              }

              leaf path-origin {
                type Rip-route-origin;
                description
                  "Where this route was learnt";
              }

              leaf hold-down {
                type boolean;
                description
                  "Indicates whether route is in holddown";
              }

              list paths {
                description
                  "The paths for this route";
                leaf source-address {
                  type inet:ipv4-address;
                  description
                    "Source address";
                }

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

                leaf metric {
                  type uint16;
                  description "Metric";
                }

                leaf tag {
                  type uint16;
                  description "Tag";
                }

                leaf interface {
                  type xr:Interface-name;
                  description "Interface";
                }

                leaf uptime {
                  type uint32;
                  description "Up time";
                }

                leaf is-permanent {
                  type boolean;
                  description
                    "Permanent indicator";
                }
              }  // list paths
            }  // list route
          }  // container routes

          container configuration {
            description
              "RIP global configuration";
            leaf active {
              type boolean;
              description
                "VRF active indicator";
            }

            leaf vr-fised-socket {
              type boolean;
              description
                "VRF added to socket indicator";
            }

            leaf rip-version {
              type int32;
              description
                "Version of RIP configured";
            }

            leaf default-metric {
              type uint8;
              description
                "Default metric for RIP routes";
            }

            leaf maximum-paths {
              type uint8;
              description
                "Maximum number of paths a route can have";
            }

            leaf auto-summarize {
              type boolean;
              description
                "Auto-summarization indicator";
            }

            leaf multicast-address {
              type boolean;
              description
                "Use broadcast/multicast address indicator";
            }

            leaf flash-threshold {
              type uint8;
              description
                "Flash update threshold";
            }

            leaf input-q-length {
              type uint16;
              description
                "Length of the input queue";
            }

            leaf triggered-rip {
              type boolean;
              description
                "Triggered RIP enabled indicator";
            }

            leaf validation-indicator {
              type boolean;
              description
                "Incoming packet source validation indicator";
            }

            leaf update-timer {
              type uint32;
              description "Update timer";
            }

            leaf next-update-time {
              type uint32;
              description
                "Time left for next update";
            }

            leaf invalid-timer {
              type uint32;
              description "Invalid timer";
            }

            leaf hold-down-timer {
              type uint32;
              description "Holddown timer";
            }

            leaf flush-timer {
              type uint32;
              description "Flush timer";
            }

            leaf oom-flags {
              type uint32;
              description
                "Out-of-memory status flags";
            }

            leaf nsf-status {
              type boolean;
              description
                "NSF Enable status";
            }

            leaf nsf-life-time {
              type uint32;
              description "NSF life time";
            }
          }  // container configuration

          container statistics {
            description
              "RIP statistics information";
            leaf received-packets {
              type uint32;
              description
                "Total packets received";
            }

            leaf discarded-packets {
              type uint32;
              description
                "Total discarded packets";
            }

            leaf discarded-routes {
              type uint32;
              description
                "Total discarded routes";
            }

            leaf standby-packets-received {
              type uint32;
              description
                "Packets rx in SRP";
            }

            leaf sent-messages {
              type uint32;
              description
                "Number of messages sent";
            }

            leaf sent-message-failures {
              type uint32;
              description
                "Number of message send failures";
            }

            leaf query-responses {
              type uint32;
              description
                "Number of RIP queries responded to";
            }

            leaf periodic-updates {
              type uint32;
              description
                "Number of periodic RIP updates";
            }

            leaf route-count {
              type uint32;
              description
                "Number of routes allocated";
            }

            leaf path-count {
              type uint32;
              description
                "Number of paths allocated";
            }

            leaf route-malloc-failures {
              type uint32;
              description
                "Number of failures to allocate memory for a
route";
            }

            leaf path-malloc-failures {
              type uint32;
              description
                "Number of failures to allocate memory for a path";
            }

            leaf rib-updates {
              type uint32;
              description
                "Number of route updates to RIB made by RIP";
            }
          }  // container statistics

          container interfaces {
            description "RIP interfaces";
            list interface {
              key "interface-name";
              description
                "Information about a particular RIP interface";
              leaf interface-name {
                type xr:Interface-name;
                description "Interface name";
              }

              leaf interface {
                type string;
                description "Interface name";
              }

              leaf if-handle {
                type xr:Interface-name;
                description
                  "Interface handle";
              }

              leaf rip-enabled {
                type boolean;
                description
                  "Whether RIP is enabled on this interface";
              }

              leaf is-passive-interface {
                type boolean;
                description
                  "Passive interface indicator";
              }

              leaf multicast-address {
                type boolean;
                description
                  "Use broadcast address for v2 packets";
              }

              leaf accept-metric {
                type boolean;
                description
                  "Accept routes of metric 0 indicator";
              }

              leaf send-version {
                type uint32;
                description
                  "Versions that the interface is sending";
              }

              leaf receive-version {
                type uint32;
                description
                  "Versions that the interface will recieve";
              }

              leaf state {
                type Interface-state;
                description
                  "Current state of the interface";
              }

              leaf destination-address {
                type inet:ipv4-address;
                description
                  "IP Address of this interface";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Prefix length of the IP address";
              }

              leaf metric-cost {
                type uint32;
                description
                  "Cost added to routes through this interface";
              }

              leaf split-horizon {
                type boolean;
                description
                  "Split horizon enabled indicator";
              }

              leaf poison-horizon {
                type boolean;
                description
                  "Poisoned reverse enabled indicator";
              }

              leaf triggered-rip {
                type boolean;
                description
                  "Triggered RIP enabled indicator";
              }

              leaf neighbor-address {
                type inet:ipv4-address;
                description
                  "Interface's triggered RIP neighbor";
              }

              leaf oom-flags {
                type uint32;
                description
                  "Out-of-memory status flags";
              }

              leaf join-status {
                type boolean;
                description
                  "Multicast group join status";
              }

              leaf lpts-state {
                type boolean;
                description "LPTSState";
              }

              leaf auth-mode {
                type uint32;
                description
                  "Authentication Mode";
              }

              leaf auth-keychain {
                type string;
                description
                  "Authentication Keychain Name";
              }

              leaf send-auth-key-exists {
                type boolean;
                description
                  "Authentication send key exists";
              }

              leaf auth-key-md5 {
                type boolean;
                description
                  "Authentication key programmed with MD5 algorithm";
              }

              leaf auth-key-send-id {
                type uint64;
                description
                  "Current active Send Authentication Key Id";
              }

              leaf total-pkt-recvd {
                type uint32;
                description
                  "Total packets received";
              }

              leaf pkt-drop-wrong-kc {
                type uint32;
                description
                  "Packets dropped due to wrong keychain configured";
              }

              leaf pkt-drop-no-auth {
                type uint32;
                description
                  "Packets dropped due to missing authentication
data";
              }

              leaf pkt-drop-invalid-auth {
                type uint32;
                description
                  "Packets dropped due to invalid authentication
data";
              }

              leaf pkt-accepted-valid-auth {
                type uint32;
                description
                  "Packets accepted with valid authentication data";
              }

              list rip-summary {
                description
                  "User defined summary addresses";
                leaf prefix {
                  type inet:ipv4-address;
                  description
                    "Summary address prefix";
                }

                leaf prefix-length {
                  type uint32;
                  description
                    "Summary address prefix length";
                }

                leaf next-hop-address {
                  type inet:ipv4-address;
                  description
                    "Summary address next hop";
                }

                leaf metric {
                  type int32;
                  description
                    "Summary metric";
                }
              }  // list rip-summary

              list rip-peer {
                description
                  "Neighbors on this interface";
                leaf peer-uptime {
                  type uint32;
                  description
                    "Uptime of this peer";
                }

                leaf peer-address {
                  type inet:ipv4-address;
                  description
                    "IP Address of this peer";
                }

                leaf peer-version {
                  type uint8;
                  description
                    "RIP version for this peer";
                }

                leaf discarded-peer-packets {
                  type uint32;
                  description
                    "Discarded packets from this peer";
                }

                leaf discarded-peer-routes {
                  type uint32;
                  description
                    "Discarded routes from this peer";
                }
              }  // list rip-peer
            }  // list interface
          }  // container interfaces

          container global {
            description
              "Global Information ";
            container vrf-summary {
              description "VRF summary data";
              leaf vrf-name {
                type string;
                description "VRF Name";
              }

              leaf active {
                type boolean;
                description
                  "VRF Active indicator";
              }

              leaf oom-flags {
                type uint32;
                description
                  "Current OOM flags";
              }

              leaf route-count {
                type uint32;
                description
                  "Number of routes allocated";
              }

              leaf path-count {
                type uint32;
                description
                  "Number of paths allocated";
              }

              leaf update-timer {
                type uint32;
                description "Update timer";
              }

              leaf next-update-time {
                type uint32;
                description
                  "Time left for next update";
              }

              leaf invalid-timer {
                type uint32;
                description "Invalid timer";
              }

              leaf hold-down-timer {
                type uint32;
                description "Holddown timer";
              }

              leaf flush-timer {
                type uint32;
                description "Flush timer";
              }

              leaf interface-configured-count {
                type uint32;
                description
                  "Number of interfaces configured";
              }

              leaf active-interface-count {
                type uint32;
                description
                  "Number of active interfaces";
              }
            }  // container vrf-summary

            list interface-summary {
              description
                "List of Interfaces configured";
              leaf interface-name {
                type string;
                description "Interface name";
              }

              leaf enabled {
                type boolean;
                description
                  "RIP enabled indicator";
              }

              leaf state {
                type Interface-state;
                description
                  "Interface state";
              }

              leaf destination-address {
                type inet:ipv4-address;
                description "IP address";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Prefix length of IP address";
              }

              leaf oom-flags {
                type uint32;
                description
                  "Current OOM flags";
              }

              leaf send-version {
                type uint32;
                description
                  "RIP versions this interface sends out";
              }

              leaf receive-version {
                type uint32;
                description
                  "RIP versions this interface will receive";
              }

              leaf neighbor-count {
                type uint32;
                description
                  "Number of neighbors seen";
              }
            }  // list interface-summary
          }  // container global
        }  // container default-vrf
      }  // container protocol

      container default-vrf {
        description
          "RIP operational data for Default VRF";
        container routes {
          description "RIP route database";
          list route {
            description
              "A route in the RIP database";
            leaf prefix {
              type inet:ipv4-address-no-zone;
              description "Network prefix";
            }

            leaf prefix-length {
              type uint32 {
                range "0..32";
              }
              description "Prefix length";
            }

            leaf destination-address {
              type inet:ipv4-address;
              description
                "Destination IP Address for this route";
            }

            leaf prefix-length-xr {
              type uint32;
              description
                "Prefix length of IP address";
            }

            leaf distance {
              type uint16;
              description
                "Route administrative distance";
            }

            leaf bgp-count {
              type uint16;
              description
                "Hop count for this route";
            }

            leaf route-type {
              type uint16;
              description
                "Type of this route";
            }

            leaf route-summary {
              type boolean;
              description
                "Summary route placeholder indicator";
            }

            leaf route-tag {
              type uint16;
              description
                "Generic route information";
            }

            leaf version {
              type uint8;
              description
                "RIB supplied version number";
            }

            leaf attributes {
              type uint32;
              description
                "RIB supplied route attributes";
            }

            leaf active {
              type boolean;
              description
                "Active route indicator";
            }

            leaf path-origin {
              type Rip-route-origin;
              description
                "Where this route was learnt";
            }

            leaf hold-down {
              type boolean;
              description
                "Indicates whether route is in holddown";
            }

            list paths {
              description
                "The paths for this route";
              leaf source-address {
                type inet:ipv4-address;
                description "Source address";
              }

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

              leaf metric {
                type uint16;
                description "Metric";
              }

              leaf tag {
                type uint16;
                description "Tag";
              }

              leaf interface {
                type xr:Interface-name;
                description "Interface";
              }

              leaf uptime {
                type uint32;
                description "Up time";
              }

              leaf is-permanent {
                type boolean;
                description
                  "Permanent indicator";
              }
            }  // list paths
          }  // list route
        }  // container routes

        container configuration {
          description
            "RIP global configuration";
          leaf active {
            type boolean;
            description
              "VRF active indicator";
          }

          leaf vr-fised-socket {
            type boolean;
            description
              "VRF added to socket indicator";
          }

          leaf rip-version {
            type int32;
            description
              "Version of RIP configured";
          }

          leaf default-metric {
            type uint8;
            description
              "Default metric for RIP routes";
          }

          leaf maximum-paths {
            type uint8;
            description
              "Maximum number of paths a route can have";
          }

          leaf auto-summarize {
            type boolean;
            description
              "Auto-summarization indicator";
          }

          leaf multicast-address {
            type boolean;
            description
              "Use broadcast/multicast address indicator";
          }

          leaf flash-threshold {
            type uint8;
            description
              "Flash update threshold";
          }

          leaf input-q-length {
            type uint16;
            description
              "Length of the input queue";
          }

          leaf triggered-rip {
            type boolean;
            description
              "Triggered RIP enabled indicator";
          }

          leaf validation-indicator {
            type boolean;
            description
              "Incoming packet source validation indicator";
          }

          leaf update-timer {
            type uint32;
            description "Update timer";
          }

          leaf next-update-time {
            type uint32;
            description
              "Time left for next update";
          }

          leaf invalid-timer {
            type uint32;
            description "Invalid timer";
          }

          leaf hold-down-timer {
            type uint32;
            description "Holddown timer";
          }

          leaf flush-timer {
            type uint32;
            description "Flush timer";
          }

          leaf oom-flags {
            type uint32;
            description
              "Out-of-memory status flags";
          }

          leaf nsf-status {
            type boolean;
            description "NSF Enable status";
          }

          leaf nsf-life-time {
            type uint32;
            description "NSF life time";
          }
        }  // container configuration

        container statistics {
          description
            "RIP statistics information";
          leaf received-packets {
            type uint32;
            description
              "Total packets received";
          }

          leaf discarded-packets {
            type uint32;
            description
              "Total discarded packets";
          }

          leaf discarded-routes {
            type uint32;
            description
              "Total discarded routes";
          }

          leaf standby-packets-received {
            type uint32;
            description "Packets rx in SRP";
          }

          leaf sent-messages {
            type uint32;
            description
              "Number of messages sent";
          }

          leaf sent-message-failures {
            type uint32;
            description
              "Number of message send failures";
          }

          leaf query-responses {
            type uint32;
            description
              "Number of RIP queries responded to";
          }

          leaf periodic-updates {
            type uint32;
            description
              "Number of periodic RIP updates";
          }

          leaf route-count {
            type uint32;
            description
              "Number of routes allocated";
          }

          leaf path-count {
            type uint32;
            description
              "Number of paths allocated";
          }

          leaf route-malloc-failures {
            type uint32;
            description
              "Number of failures to allocate memory for a
route";
          }

          leaf path-malloc-failures {
            type uint32;
            description
              "Number of failures to allocate memory for a path";
          }

          leaf rib-updates {
            type uint32;
            description
              "Number of route updates to RIB made by RIP";
          }
        }  // container statistics

        container interfaces {
          description "RIP interfaces";
          list interface {
            key "interface-name";
            description
              "Information about a particular RIP interface";
            leaf interface-name {
              type xr:Interface-name;
              description "Interface name";
            }

            leaf interface {
              type string;
              description "Interface name";
            }

            leaf if-handle {
              type xr:Interface-name;
              description "Interface handle";
            }

            leaf rip-enabled {
              type boolean;
              description
                "Whether RIP is enabled on this interface";
            }

            leaf is-passive-interface {
              type boolean;
              description
                "Passive interface indicator";
            }

            leaf multicast-address {
              type boolean;
              description
                "Use broadcast address for v2 packets";
            }

            leaf accept-metric {
              type boolean;
              description
                "Accept routes of metric 0 indicator";
            }

            leaf send-version {
              type uint32;
              description
                "Versions that the interface is sending";
            }

            leaf receive-version {
              type uint32;
              description
                "Versions that the interface will recieve";
            }

            leaf state {
              type Interface-state;
              description
                "Current state of the interface";
            }

            leaf destination-address {
              type inet:ipv4-address;
              description
                "IP Address of this interface";
            }

            leaf prefix-length {
              type uint32;
              description
                "Prefix length of the IP address";
            }

            leaf metric-cost {
              type uint32;
              description
                "Cost added to routes through this interface";
            }

            leaf split-horizon {
              type boolean;
              description
                "Split horizon enabled indicator";
            }

            leaf poison-horizon {
              type boolean;
              description
                "Poisoned reverse enabled indicator";
            }

            leaf triggered-rip {
              type boolean;
              description
                "Triggered RIP enabled indicator";
            }

            leaf neighbor-address {
              type inet:ipv4-address;
              description
                "Interface's triggered RIP neighbor";
            }

            leaf oom-flags {
              type uint32;
              description
                "Out-of-memory status flags";
            }

            leaf join-status {
              type boolean;
              description
                "Multicast group join status";
            }

            leaf lpts-state {
              type boolean;
              description "LPTSState";
            }

            leaf auth-mode {
              type uint32;
              description
                "Authentication Mode";
            }

            leaf auth-keychain {
              type string;
              description
                "Authentication Keychain Name";
            }

            leaf send-auth-key-exists {
              type boolean;
              description
                "Authentication send key exists";
            }

            leaf auth-key-md5 {
              type boolean;
              description
                "Authentication key programmed with MD5 algorithm";
            }

            leaf auth-key-send-id {
              type uint64;
              description
                "Current active Send Authentication Key Id";
            }

            leaf total-pkt-recvd {
              type uint32;
              description
                "Total packets received";
            }

            leaf pkt-drop-wrong-kc {
              type uint32;
              description
                "Packets dropped due to wrong keychain configured";
            }

            leaf pkt-drop-no-auth {
              type uint32;
              description
                "Packets dropped due to missing authentication
data";
            }

            leaf pkt-drop-invalid-auth {
              type uint32;
              description
                "Packets dropped due to invalid authentication
data";
            }

            leaf pkt-accepted-valid-auth {
              type uint32;
              description
                "Packets accepted with valid authentication data";
            }

            list rip-summary {
              description
                "User defined summary addresses";
              leaf prefix {
                type inet:ipv4-address;
                description
                  "Summary address prefix";
              }

              leaf prefix-length {
                type uint32;
                description
                  "Summary address prefix length";
              }

              leaf next-hop-address {
                type inet:ipv4-address;
                description
                  "Summary address next hop";
              }

              leaf metric {
                type int32;
                description "Summary metric";
              }
            }  // list rip-summary

            list rip-peer {
              description
                "Neighbors on this interface";
              leaf peer-uptime {
                type uint32;
                description
                  "Uptime of this peer";
              }

              leaf peer-address {
                type inet:ipv4-address;
                description
                  "IP Address of this peer";
              }

              leaf peer-version {
                type uint8;
                description
                  "RIP version for this peer";
              }

              leaf discarded-peer-packets {
                type uint32;
                description
                  "Discarded packets from this peer";
              }

              leaf discarded-peer-routes {
                type uint32;
                description
                  "Discarded routes from this peer";
              }
            }  // list rip-peer
          }  // list interface
        }  // container interfaces

        container global {
          description "Global Information ";
          container vrf-summary {
            description "VRF summary data";
            leaf vrf-name {
              type string;
              description "VRF Name";
            }

            leaf active {
              type boolean;
              description
                "VRF Active indicator";
            }

            leaf oom-flags {
              type uint32;
              description
                "Current OOM flags";
            }

            leaf route-count {
              type uint32;
              description
                "Number of routes allocated";
            }

            leaf path-count {
              type uint32;
              description
                "Number of paths allocated";
            }

            leaf update-timer {
              type uint32;
              description "Update timer";
            }

            leaf next-update-time {
              type uint32;
              description
                "Time left for next update";
            }

            leaf invalid-timer {
              type uint32;
              description "Invalid timer";
            }

            leaf hold-down-timer {
              type uint32;
              description "Holddown timer";
            }

            leaf flush-timer {
              type uint32;
              description "Flush timer";
            }

            leaf interface-configured-count {
              type uint32;
              description
                "Number of interfaces configured";
            }

            leaf active-interface-count {
              type uint32;
              description
                "Number of active interfaces";
            }
          }  // container vrf-summary

          list interface-summary {
            description
              "List of Interfaces configured";
            leaf interface-name {
              type string;
              description "Interface name";
            }

            leaf enabled {
              type boolean;
              description
                "RIP enabled indicator";
            }

            leaf state {
              type Interface-state;
              description "Interface state";
            }

            leaf destination-address {
              type inet:ipv4-address;
              description "IP address";
            }

            leaf prefix-length {
              type uint32;
              description
                "Prefix length of IP address";
            }

            leaf oom-flags {
              type uint32;
              description
                "Current OOM flags";
            }

            leaf send-version {
              type uint32;
              description
                "RIP versions this interface sends out";
            }

            leaf receive-version {
              type uint32;
              description
                "RIP versions this interface will receive";
            }

            leaf neighbor-count {
              type uint32;
              description
                "Number of neighbors seen";
            }
          }  // list interface-summary
        }  // container global
      }  // container default-vrf
    }  // container rip
  }  // module Cisco-IOS-XR-ip-rip-oper