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

    yang-version 1;

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

    prefix ip-udp-oper;

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

    include Cisco-IOS-XR-ip-udp-oper-sub4 {
      revision-date "2020-04-06";
    }
    include Cisco-IOS-XR-ip-udp-oper-sub3 {
      revision-date "2020-04-06";
    }
    include Cisco-IOS-XR-ip-udp-oper-sub2 {
      revision-date "2020-04-06";
    }
    include Cisco-IOS-XR-ip-udp-oper-sub1 {
      revision-date "2020-04-06";
    }

    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-udp package operational data.
     
     This module contains definitions
     for the following management objects:
       udp: IP UDP Operational Data
       udp-connection: UDP connection operational data
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-04-06" {
      description
        "min_ttl_dropped field is added to PCB_DETAIL output.";
    }

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

    revision "2018-08-09" {
      description
        "bind_local field is added to PCB_DETAIL output";
    }

    revision "2018-03-04" {
      description
        "PCB_ID argument is passed in string format.";
    }

    revision "2017-09-07" {
      description
        "Fixed type translation error.";
    }

    revision "2016-02-26" {
      description "Descriptions updated.";
    }

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

    semver:module-version "1.1.0";
    semver:module-version "1.0.0";

    typedef Lpts-pcb-query {
      type enumeration {
        enum "all" {
          value 0;
          description "No filter";
        }
        enum "static-policy" {
          value 1;
          description "Static policy filter";
        }
        enum "interface" {
          value 2;
          description "Interface filter";
        }
        enum "packet" {
          value 3;
          description "Packet type filter";
        }
      }
      description "Lpts pcb query";
    }

    container udp {
      config false;
      description "IP UDP Operational Data";
      container nodes {
        description
          "Node-specific UDP operational data";
        list node {
          key "node-name";
          description
            "UDP operational data for a particular node";
          container statistics {
            description
              "Statistical UDP operational data for a node";
            container ipv4-traffic {
              description
                "UDP Traffic statistics for IPv4";
              leaf udp-input-packets {
                type uint32;
                description "UDP Received";
              }

              leaf udp-checksum-error-packets {
                type uint32;
                description
                  "UDP Checksum Errors";
              }

              leaf udp-no-port-packets {
                type uint32;
                description "UDP No Port";
              }

              leaf udp-bad-length-packets {
                type uint32;
                description "UDP bad length";
              }

              leaf udp-output-packets {
                type uint32;
                description
                  "UDP Transmitted";
              }

              leaf udp-dropped-packets {
                type uint32;
                description
                  "UDP drop for other reason";
              }
            }  // container ipv4-traffic

            container ipv6-traffic {
              description
                "UDP Traffic statistics for IPv6";
              leaf udp-input-packets {
                type uint32;
                description "UDP Received";
              }

              leaf udp-checksum-error-packets {
                type uint32;
                description
                  "UDP Checksum Errors";
              }

              leaf udp-no-port-packets {
                type uint32;
                description "UDP No Port";
              }

              leaf udp-bad-length-packets {
                type uint32;
                description "UDP bad length";
              }

              leaf udp-output-packets {
                type uint32;
                description
                  "UDP Transmitted";
              }

              leaf udp-dropped-packets {
                type uint32;
                description
                  "UDP drop for other reason";
              }
            }  // container ipv6-traffic
          }  // container statistics

          leaf node-name {
            type xr:Node-id;
            description "Node name";
          }
        }  // list node
      }  // container nodes
    }  // container udp

    container udp-connection {
      config false;
      description
        "UDP connection operational data";
      container nodes {
        description
          "List of UDP connections nodes";
        list node {
          key "node-name";
          description
            "Information about a particular node";
          container statistics {
            description
              "Statistics of UDP connections";
            container clients {
              description
                "Table listing clients";
              list client {
                key "client-id";
                description
                  "Describing Client ID";
                leaf client-id {
                  type uint32 {
                    range "0..4294967295";
                  }
                  description
                    "Displaying client's aggregated statistics";
                }

                leaf client-jid {
                  type int32;
                  description
                    "Job ID of the transport client";
                }

                leaf client-name {
                  type string {
                    length "0..21";
                  }
                  description
                    "Transport client name";
                }

                leaf ipv4-received-packets {
                  type uint32;
                  description
                    "Total IPv4 packets received from client";
                }

                leaf ipv4-sent-packets {
                  type uint32;
                  description
                    "Total IPv4 packets sent to client";
                }

                leaf ipv6-received-packets {
                  type uint32;
                  description
                    "Total IPv6 packets received from app";
                }

                leaf ipv6-sent-packets {
                  type uint32;
                  description
                    "Total IPv6 packets sent to app";
                }
              }  // list client
            }  // container clients

            container summary {
              description
                "Summary statistics across all UDP connections";
              leaf received-total-packets {
                type uint32;
                description
                  "Total packets received";
              }

              leaf received-no-port-packets {
                type uint32;
                description
                  "Packets received when no wild listener";
              }

              leaf received-bad-checksum-packets {
                type uint32;
                description
                  "Packets received has bad checksum";
              }

              leaf received-too-short-packets {
                type uint32;
                description
                  "Packets received is too short";
              }

              leaf received-drop-packets {
                type uint32;
                description
                  "Packets dropped for other reasons";
              }

              leaf sent-total-packets {
                type uint32;
                description
                  "Total packets sent";
              }

              leaf sent-error-packets {
                type uint32;
                description
                  "Total send erorr packets";
              }

              leaf forward-broadcast-packets {
                type uint32;
                description
                  "Total forwarding broadcast packets";
              }

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

              leaf failed-clone-packets {
                type uint32;
                description
                  "Total failed cloned packets";
              }
            }  // container summary

            container pcb-statistics {
              description
                "Table listing the UDP connections for which
               statistics are provided";
              list pcb-statistic {
                key "pcb-address";
                description
                  "Satistics associated with a particular PCB";
                leaf pcb-address {
                  type xr:Cisco-ios-xr-string;
                  description
                    "Protocol Control Block address";
                }

                container send {
                  description
                    "UDP send statistics";
                  leaf received-application-bytes {
                    type uint64;
                    units "byte";
                    description
                      "Bytes received from application";
                  }

                  leaf received-xipc-pulses {
                    type uint64;
                    description
                      "XIPC pulses received from application";
                  }

                  leaf sent-network-packets {
                    type uint64;
                    description
                      "Packets sent to network (v4/v6 IO)";
                  }

                  leaf sent-net-io-packets {
                    type uint64;
                    description
                      "Packets sent to network (NetIO)";
                  }

                  leaf failed-queued-network-packets {
                    type uint32;
                    description
                      "Packets failed getting queued to network (v4/v6
IO)";
                  }

                  leaf failed-queued-net-io-packets {
                    type uint32;
                    description
                      "Packets failed getting queued to network (NetIO)";
                  }
                }  // container send

                container receive {
                  description
                    "UDP receive statistics";
                  leaf received-network-packets {
                    type uint64;
                    description
                      "Packets received from network";
                  }

                  leaf failed-queued-application-packets {
                    type uint32;
                    description
                      "Packets failed queued to application";
                  }

                  leaf queued-application-packets {
                    type uint64;
                    description
                      "Packets queued to application";
                  }

                  leaf failed-queued-application-socket-packets {
                    type uint32;
                    description
                      "Packet that couldn't be queued to application.on
socket";
                  }

                  leaf queued-application-socket-packets {
                    type uint64;
                    description
                      "Packets queued to application on socket";
                  }

                  leaf min-ttl-dropped {
                    type uint64;
                    description
                      "Received packets dropped due to minttl";
                  }
                }  // container receive

                leaf vrf-id {
                  type uint32;
                  description "VRF ID";
                }

                leaf is-paw-socket {
                  type boolean;
                  description
                    "True if paw socket";
                }
              }  // list pcb-statistic
            }  // container pcb-statistics
          }  // container statistics

          container lpts {
            description
              "LPTS statistical data";
            container queries {
              description
                "List of query options";
              list query {
                key "query-name";
                description "Query option";
                container pcbs {
                  description "List of PCBs";
                  list pcb {
                    key "pcb-address";
                    description
                      "A PCB information";
                    leaf pcb-address {
                      type xr:Cisco-ios-xr-string;
                      description
                        "PCB address";
                    }

                    container local-address {
                      description
                        "Local IP address";
                      leaf af-name {
                        type Addr-family;
                        description "AFName";
                      }

                      leaf ipv4-address {
                        when
                          "../af-name = 'inet'" {
                          description
                            "../AFName = 'INET'";
                        }
                        type inet:ipv4-address;
                        description
                          "IPv4 address";
                      }

                      leaf ipv6-address {
                        when
                          "../af-name = 'inet6'" {
                          description
                            "../AFName = 'INET6'";
                        }
                        type Lpts-ipv6-address;
                        description
                          "IPv6 address";
                      }
                    }  // container local-address

                    container foreign-address {
                      description
                        "Remote IP address";
                      leaf af-name {
                        type Addr-family;
                        description "AFName";
                      }

                      leaf ipv4-address {
                        when
                          "../af-name = 'inet'" {
                          description
                            "../AFName = 'INET'";
                        }
                        type inet:ipv4-address;
                        description
                          "IPv4 address";
                      }

                      leaf ipv6-address {
                        when
                          "../af-name = 'inet6'" {
                          description
                            "../AFName = 'INET6'";
                        }
                        type Lpts-ipv6-address;
                        description
                          "IPv6 address";
                      }
                    }  // container foreign-address

                    container common {
                      description
                        "Common PCB information";
                      container lpts-pcb {
                        description
                          "LPTS PCB information";
                        container options {
                          description
                            "Receive options";
                          leaf is-receive-filter {
                            type boolean;
                            description
                              "Receive filter enabled";
                          }

                          leaf is-ip-sla {
                            type boolean;
                            description
                              "IP SLA";
                          }
                        }  // container options

                        container lpts-flags {
                          description
                            "LPTS flags";
                          leaf is-pcb-bound {
                            type boolean;
                            description
                              "PCB bound";
                          }

                          leaf is-local-address-ignore {
                            type boolean;
                            description
                              "Sent drop packets";
                          }

                          leaf is-ignore-vrf-filter {
                            type boolean;
                            description
                              "Ignore VRF Filter";
                          }
                        }  // container lpts-flags

                        container accept-mask {
                          description
                            "AcceptMask";
                          leaf is-interface {
                            type boolean;
                            description
                              "Set interface";
                          }

                          leaf is-packet-type {
                            type boolean;
                            description
                              "Set packet type";
                          }

                          leaf is-remote-address {
                            type boolean;
                            description
                              "Set Remote address";
                          }

                          leaf is-remote-port {
                            type boolean;
                            description
                              "Set Remote Port";
                          }

                          leaf is-local-address {
                            type boolean;
                            description
                              "Set Local Address";
                          }

                          leaf is-local-port {
                            type boolean;
                            description
                              "Set Local Port";
                          }
                        }  // container accept-mask

                        leaf ttl {
                          type uint8;
                          description
                            "Minimum TTL";
                        }

                        leaf flow-types-info {
                          type uint32;
                          description
                            "flow information";
                        }

                        list filter {
                          description
                            "Interface Filters";
                          container packet-type {
                            description
                              "Protocol-specific packet type";
                            leaf type {
                              type Packet;
                              description
                                "Type";
                            }

                            leaf icmp-message-type {
                              when
                                "../type = 'icmp'" {
                                description
                                  "../Type = 'ICMP'";
                              }
                              type Message-icmp;
                              description
                                "ICMP message type";
                            }

                            leaf icm-pv6-message-type {
                              when
                                "../type = 'icm-pv6'" {
                                description
                                  "../Type = 'ICMPv6'";
                              }
                              type Message-icmpv6;
                              description
                                "ICMPv6 message type";
                            }

                            leaf igmp-message-type {
                              when
                                "../type = 'igmp'" {
                                description
                                  "../Type = 'IGMP'";
                              }
                              type Message-igmp;
                              description
                                "IGMP message type";
                            }

                            leaf message-id {
                              when
                                "../type = 'unknown'" {
                                description
                                  "../Type = 'Unknown'";
                              }
                              type Message-id;
                              description
                                "Message type in number";
                            }
                          }  // container packet-type

                          container remote-address {
                            description
                              "Remote address";
                            leaf af-name {
                              type Addr-family;
                              description
                                "AFName";
                            }

                            leaf ipv4-address {
                              when
                                "../af-name = 'inet'" {
                                description
                                  "../AFName = 'INET'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv4 address";
                            }

                            leaf ipv6-address {
                              when
                                "../af-name = 'inet6'" {
                                description
                                  "../AFName = 'INET6'";
                              }
                              type Lpts-ipv6-address;
                              description
                                "IPv6 address";
                            }
                          }  // container remote-address

                          container local-address {
                            description
                              "Local address";
                            leaf af-name {
                              type Addr-family;
                              description
                                "AFName";
                            }

                            leaf ipv4-address {
                              when
                                "../af-name = 'inet'" {
                                description
                                  "../AFName = 'INET'";
                              }
                              type inet:ipv4-address;
                              description
                                "IPv4 address";
                            }

                            leaf ipv6-address {
                              when
                                "../af-name = 'inet6'" {
                                description
                                  "../AFName = 'INET6'";
                              }
                              type Lpts-ipv6-address;
                              description
                                "IPv6 address";
                            }
                          }  // container local-address

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

                          leaf remote-length {
                            type uint16;
                            description
                              "Remote address length";
                          }

                          leaf local-length {
                            type uint16;
                            description
                              "Local address length";
                          }

                          leaf receive-remote-port {
                            type uint16;
                            description
                              "Receive Remote port";
                          }

                          leaf receive-local-port {
                            type uint16;
                            description
                              "Receive Local port";
                          }

                          leaf priority {
                            type uint8;
                            description
                              "Priority";
                          }

                          leaf ttl {
                            type uint8;
                            description
                              "Minimum TTL";
                          }

                          leaf flow-types-info {
                            type uint32;
                            description
                              "flow information";
                          }
                        }  // list filter
                      }  // container lpts-pcb

                      leaf af-name {
                        type Addr-family;
                        description
                          "Address Family";
                      }
                    }  // container common

                    leaf l4-protocol {
                      type uint32;
                      description
                        "Layer 4 protocol";
                    }

                    leaf local-port {
                      type uint16;
                      description
                        "Local port";
                    }

                    leaf foreign-port {
                      type uint16;
                      description
                        "Remote port";
                    }
                  }  // list pcb
                }  // container pcbs

                leaf query-name {
                  type Lpts-pcb-query;
                  description "Query option";
                }
              }  // list query
            }  // container queries
          }  // container lpts

          container pcb-details {
            description
              "Detail information for list of UDP connections
             .";
            list pcb-detail {
              key "pcb-address";
              description
                "Detail information about a UDP connection";
              leaf pcb-address {
                type xr:Cisco-ios-xr-string;
                description
                  "Protocol Control Block address";
              }

              container local-address {
                description "Local address";
                leaf af-name {
                  type Udp-address-family;
                  description "AFName";
                }

                leaf ipv4-address {
                  when "../af-name = 'ipv4'" {
                    description
                      "../AFName = 'IPv4'";
                  }
                  type inet:ipv4-address;
                  description "IPv4 Address";
                }

                leaf ipv6-address {
                  when
                    "../af-name != 'ipv4'" {
                    description
                      "../AFName != 'IPv4'";
                  }
                  type Udp-in6-addr;
                  description "IPv6 Address";
                }
              }  // container local-address

              container foreign-address {
                description
                  "Foreign address";
                leaf af-name {
                  type Udp-address-family;
                  description "AFName";
                }

                leaf ipv4-address {
                  when "../af-name = 'ipv4'" {
                    description
                      "../AFName = 'IPv4'";
                  }
                  type inet:ipv4-address;
                  description "IPv4 Address";
                }

                leaf ipv6-address {
                  when
                    "../af-name != 'ipv4'" {
                    description
                      "../AFName != 'IPv4'";
                  }
                  type Udp-in6-addr;
                  description "IPv6 Address";
                }
              }  // container foreign-address

              container pcb-flags {
                description "PCB flags";
                leaf recv-opts {
                  type boolean;
                  description
                    "Receive input options";
                }

                leaf recv-ret-opts {
                  type boolean;
                  description
                    "Receive input source-route options";
                }

                leaf recv-dest-addr {
                  type boolean;
                  description
                    "Receive destination address";
                }

                leaf header-include {
                  type boolean;
                  description
                    "Header include option";
                }

                leaf recv-intf {
                  type boolean;
                  description
                    "Receive input interface";
                }

                leaf recv-header {
                  type boolean;
                  description
                    "Receive header";
                }

                leaf mcast-loopback {
                  type boolean;
                  description
                    "Loopback of multicast packet";
                }

                leaf recv-l2-header {
                  type boolean;
                  description
                    "Receive L2 header";
                }

                leaf recv-packet-info {
                  type boolean;
                  description
                    "Receive packet information";
                }

                leaf router-alert {
                  type boolean;
                  description
                    "Receive router alert packets";
                }

                leaf recv-hop-limit {
                  type boolean;
                  description
                    "Receive hop limit";
                }

                leaf recv-routing-header {
                  type boolean;
                  description
                    "Receive routing header";
                }

                leaf recv-hop-header {
                  type boolean;
                  description
                    "Receive hop by hop option header";
                }

                leaf recv-dest-header {
                  type boolean;
                  description
                    "Receive destination option header";
                }

                leaf recv-traffic-class {
                  type boolean;
                  description
                    "Receive traffic class";
                }

                leaf recv-ip-sec {
                  type boolean;
                  description
                    "Receive IP security information";
                }

                leaf recv-tabel-id {
                  type boolean;
                  description
                    "Receive table identifier";
                }

                leaf recv-pak-priority {
                  type boolean;
                  description
                    "Receive packet priority";
                }

                leaf conn-limit {
                  type boolean;
                  description
                    "Connection limit";
                }

                leaf opt-handled {
                  type boolean;
                  description
                    "Option handled";
                }

                leaf bind-local {
                  type boolean;
                  description
                    "Local node packet delivery";
                }
              }  // container pcb-flags

              leaf af-name {
                type Udp-address-family;
                description "Address family";
              }

              leaf local-process-id {
                type uint32;
                description
                  "ID of local process";
              }

              leaf local-port {
                type uint16;
                description "Local port";
              }

              leaf foreign-port {
                type uint16;
                description "Foreign port";
              }

              leaf receive-queue {
                type uint32;
                description
                  "Receive queue count";
              }

              leaf send-queue {
                type uint32;
                description
                  "Send queue count";
              }

              leaf vrf-id {
                type uint32;
                description "VRF ID";
              }

              leaf flow-label {
                type uint32;
                description
                  "Flow label set ";
              }

              leaf traffic-class {
                type int32;
                description
                  "Traffic Class set ";
              }
            }  // list pcb-detail
          }  // container pcb-details

          container pcb-briefs {
            description
              "Brief information for list of UDP connections.";
            list pcb-brief {
              key "pcb-address";
              description
                "Brief information about a UDP connection";
              leaf pcb-address {
                type xr:Cisco-ios-xr-string;
                description
                  "Protocol Control Block address";
              }

              container local-address {
                description "Local address";
                leaf af-name {
                  type Udp-address-family;
                  description "AFName";
                }

                leaf ipv4-address {
                  when "../af-name = 'ipv4'" {
                    description
                      "../AFName = 'IPv4'";
                  }
                  type inet:ipv4-address;
                  description "IPv4 Address";
                }

                leaf ipv6-address {
                  when
                    "../af-name != 'ipv4'" {
                    description
                      "../AFName != 'IPv4'";
                  }
                  type Udp-in6-addr;
                  description "IPv6 Address";
                }
              }  // container local-address

              container foreign-address {
                description
                  "Foreign address";
                leaf af-name {
                  type Udp-address-family;
                  description "AFName";
                }

                leaf ipv4-address {
                  when "../af-name = 'ipv4'" {
                    description
                      "../AFName = 'IPv4'";
                  }
                  type inet:ipv4-address;
                  description "IPv4 Address";
                }

                leaf ipv6-address {
                  when
                    "../af-name != 'ipv4'" {
                    description
                      "../AFName != 'IPv4'";
                  }
                  type Udp-in6-addr;
                  description "IPv6 Address";
                }
              }  // container foreign-address

              leaf af-name {
                type Udp-address-family;
                description "Address family";
              }

              leaf local-port {
                type uint16;
                description "Local port";
              }

              leaf foreign-port {
                type uint16;
                description "Foreign port";
              }

              leaf receive-queue {
                type uint32;
                description
                  "Receive queue count";
              }

              leaf send-queue {
                type uint32;
                description
                  "Send queue count";
              }

              leaf vrf-id {
                type uint32;
                description "VRF ID";
              }
            }  // list pcb-brief
          }  // container pcb-briefs

          leaf node-name {
            type xr:Node-id;
            description "Node name";
          }
        }  // list node
      }  // container nodes
    }  // container udp-connection
  }  // module Cisco-IOS-XR-ip-udp-oper