submodule Cisco-IOS-XR-ip-tcp-oper-sub3 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-ip-tcp-oper {
        prefix Cisco-IOS-XR-ip-tcp-oper;
    }

    import ietf-inet-types {
      prefix inet;
    }
    import cisco-semver {
      prefix semver;
    }

    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 submodule contains a collection of YANG definitions
     for Cisco IOS-XR ip-tcp package operational data.
     
     Copyright (c) 2013-2020 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-05-15" {
      description
        "First SYN delay timer added";
    }

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

    revision "2018-11-01" {
      description
        "Added socket async double free prevention count in tcp statistics summary";
    }

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

    revision "2018-02-14" {
      description
        "Added support for TCP-AO feature.";
    }

    revision "2017-05-01" {
      description
        "Fixing backward compatibility error in module.";
    }

    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 Tcp-mac-algo {
      type enumeration {
        enum "not-configured" {
          value 0;
          description "Not configured";
        }
        enum "aes-128-cmac-96" {
          value 1;
          description "CMAC 96";
        }
        enum "hmac-sha1-12" {
          value 2;
          description "HMAC SHA1 12";
        }
        enum "md5-16" {
          value 3;
          description "MD5 16";
        }
        enum "sha1-20" {
          value 4;
          description "SHA1 20";
        }
        enum "hmac-md5-16" {
          value 5;
          description "HMAC MD5 16";
        }
        enum "hmac-sha1-20" {
          value 6;
          description "HMAC SHA1 20";
        }
        enum "aes-128-cmac" {
          value 7;
          description "AES 128 CMAC";
        }
        enum "aes-256-cmac" {
          value 8;
          description "AES 256 CMAC";
        }
        enum "hmac-sha1-96" {
          value 9;
          description "HMAC SHA1 96";
        }
        enum "hmac-sha-256" {
          value 10;
          description "HMAC SHA1 256";
        }
      }
      description
        "TCP AO MAC algorithm type";
    }

    typedef Tcp-key-invalid-reason {
      type enumeration {
        enum "none" {
          value 0;
          description "No reason";
        }
        enum "incomplete" {
          value 1;
          description "Incomplete";
        }
        enum "lifetime-not-same" {
          value 2;
          description
            "Send and accept lifetime are not same";
        }
        enum "send-id-invalid" {
          value 3;
          description "Send ID is invalid";
        }
        enum "recv-id-invalid" {
          value 4;
          description
            "Receive ID is invalid";
        }
      }
      description
        "TCP AO key state invalid reason";
    }

    typedef Tcp-timer {
      type enumeration {
        enum "retransmission-timer" {
          value 0;
          description "Retransmission timer";
        }
        enum "window-probe-timer" {
          value 1;
          description
            "Send Window Probe timer";
        }
        enum "timewait-state-timer" {
          value 2;
          description "TIMEWAIT state timer";
        }
        enum "ack-hold-timer" {
          value 3;
          description "ACK Hold timer";
        }
        enum "keep-alive-timer" {
          value 4;
          description "Keep Alive timer";
        }
        enum "pmtu-ager-timer" {
          value 5;
          description "PMTU Ager Timer";
        }
        enum "retransmission-giveup-timer" {
          value 6;
          description
            "Retransmission Giveup timer";
        }
        enum "throttle-timer" {
          value 7;
          description
            "Throttle (for PAW/xipc) timer";
        }
        enum "syn-delay-timer" {
          value 8;
          description
            "First SYN delay timer";
        }
      }
      description "TCP Timer Type";
    }

    typedef Pak-prio {
      type enumeration {
        enum "unspecified-packet" {
          value 0;
          description "Unspecified";
        }
        enum "normal-packet" {
          value 1;
          description
            "Normal: all traffic routed via this router,
           Telnet/FTP traffic generated from within this
           router";
        }
        enum "medium-packet" {
          value 2;
          description
            "Medium: Packets with low drop probability e.g.
           Routing updates & requests";
        }
        enum "high-packet" {
          value 3;
          description
            "High: Packets with very low drop probability
           and normal delivery e.g. L3 Keepalives like
           OSPF/ISIS Hellos";
        }
        enum "crucial-packet" {
          value 4;
          description
            "Crucial: Packets with very low drop probability
           and expedited delivery e.g L2 keepalives, HDLC
           Keepalives";
        }
      }
      description "Packet Priority Types";
    }

    typedef Tcp-in6-addr {
      type inet:ipv6-address;
      description "Tcp in6 addr";
    }

    typedef Tcp-conn-state {
      type enumeration {
        enum "closed" {
          value 0;
          description "Closed";
        }
        enum "listen" {
          value 1;
          description "Listen";
        }
        enum "syn-sent" {
          value 2;
          description "Syn sent";
        }
        enum "syn-received" {
          value 3;
          description "Syn received";
        }
        enum "established" {
          value 4;
          description "Established";
        }
        enum "close-wait" {
          value 5;
          description "Close wait";
        }
        enum "fin-wait1" {
          value 6;
          description "FIN Wait1";
        }
        enum "closing" {
          value 7;
          description "Closing";
        }
        enum "last-ack" {
          value 8;
          description "Last ack";
        }
        enum "fin-wait2" {
          value 9;
          description "FIN Wait2";
        }
        enum "time-wait" {
          value 10;
          description "Time wait";
        }
      }
      description "TCP Connection State";
    }

    typedef Tcp-address-family {
      type enumeration {
        enum "ipv4" {
          value 2;
          description "IPv4";
        }
        enum "ipv6" {
          value 10;
          description "IPv6";
        }
      }
      description "Address Family Type";
    }

    grouping TCP-SH-BRIEF-BAG {
      description
        "Summary information about a TCP connection";
      container local-address {
        description "Local address";
        uses TCP-ADDRESS-TYPE;
      }  // container local-address

      container foreign-address {
        description "Foreign address";
        uses TCP-ADDRESS-TYPE;
      }  // container foreign-address

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

      leaf pcb {
        type uint64;
        description "PCB Address";
      }

      leaf connection-state {
        type Tcp-conn-state;
        description "Connection state";
      }

      leaf local-pid {
        type uint32;
        description
          "Id of the local process";
      }

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

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

      leaf current-receive-queue-size {
        type uint32;
        units "byte";
        description
          "Current receive queue size in bytes";
      }

      leaf current-send-queue-size {
        type uint32;
        units "byte";
        description
          "Current send queue size in bytes";
      }

      leaf vrf-id {
        type uint32;
        description "VRF ID";
      }
    }  // grouping TCP-SH-BRIEF-BAG

    grouping TCP-SH-ID-BAG {
      description
        "Detailed information about a TCP AO ID under a
       keychain";
      leaf id {
        type uint8;
        description "Identifier";
      }

      list keys {
        description
          "List of keys having this id";
        uses TCP-SH-KEY-ID-BAG;
      }  // list keys
    }  // grouping TCP-SH-ID-BAG

    grouping TCP-SH-KEY-ID-BAG {
      description
        "Information about a TCP AO active key";
      leaf key-id {
        type uint64;
        description "Key identifier";
      }
    }  // grouping TCP-SH-KEY-ID-BAG

    grouping TCP-SH-KEY-BAG {
      description
        "Detailed information about a TCP AO key";
      leaf key-id {
        type uint64;
        description "Key identifier";
      }

      leaf is-active {
        type boolean;
        description "Is key active";
      }

      leaf is-expired {
        type boolean;
        description "Is key expired";
      }

      leaf is-valid {
        type boolean;
        description "Is key valid";
      }

      leaf reason {
        type Tcp-key-invalid-reason;
        description "Key invalid reason";
      }

      leaf send-id {
        type uint8;
        description "Send ID";
      }

      leaf recv-id {
        type uint8;
        description "Receive ID";
      }

      leaf crypt-algo {
        type Tcp-mac-algo;
        description
          "Cryptography algorithm associated with the key";
      }

      leaf is-configured {
        type boolean;
        description "Is key configured?";
      }

      leaf overlapping-key-available {
        type boolean;
        description
          "Is overlapping key available?";
      }

      leaf overlapping-key {
        type uint64;
        description
          "Overlapping key identifier";
      }

      list invalidated-key {
        description
          "List of keys invalidated";
        uses TCP-SH-KEY-ID-BAG;
      }  // list invalidated-key
    }  // grouping TCP-SH-KEY-BAG

    grouping TCP-SH-KEYCHAIN-BAG {
      description
        "Detailed information about a TCP AO keychain";
      leaf chain-name {
        type string;
        description "Keychain name";
      }

      leaf is-configured {
        type boolean;
        description
          "Is keychain configured?";
      }

      leaf desired-key-available {
        type boolean;
        description
          "Is desired key available?";
      }

      leaf desired-key-id {
        type uint64;
        description "Desired key identifier";
      }

      list keys {
        description
          "Keys under this keychain";
        uses TCP-SH-KEY-BAG;
      }  // list keys

      list active-key {
        description "List of active keys";
        uses TCP-SH-KEY-ID-BAG;
      }  // list active-key

      list send-id {
        description
          "Send IDs under this keychain";
        uses TCP-SH-ID-BAG;
      }  // list send-id

      list receive-id {
        description
          "Receive IDs under this keychain";
        uses TCP-SH-ID-BAG;
      }  // list receive-id
    }  // grouping TCP-SH-KEYCHAIN-BAG

    grouping TCP-SOCKBUF-STATES-BAG {
      description
        "TCP Socket Buffer State Flags";
      leaf locked {
        type boolean;
        description
          "Lock on data queue (so_rcv only)";
      }

      leaf waiting-for-lock {
        type boolean;
        description
          "Someone is waiting to lock";
      }

      leaf waiting-for-data {
        type boolean;
        description
          "Someone is waiting for data/space";
      }

      leaf input-select {
        type boolean;
        description
          "Buffer is selected for INPUT";
      }

      leaf async-io {
        type boolean;
        description "Async I/O";
      }

      leaf not-interruptible {
        type boolean;
        description "Not interruptible";
      }

      leaf io-timer-set {
        type boolean;
        description "Read/write timer set";
      }

      leaf delayed-wakeup {
        type boolean;
        description "Want delayed wakeups";
      }

      leaf wakeup {
        type boolean;
        description
          "Read/write wakeup pending";
      }

      leaf connect-wakeup {
        type boolean;
        description "Connect wakeup pending";
      }

      leaf output-select {
        type boolean;
        description
          "Buffer is selected for OUTPUT";
      }

      leaf out-of-band-select {
        type boolean;
        description
          "Buffer is selected for OBAND";
      }

      leaf packet-extended {
        type boolean;
        description
          "Packet Buffer is extended";
      }
    }  // grouping TCP-SOCKBUF-STATES-BAG

    grouping SACKHOLE-BAG {
      description "Sack send hole entry";
      leaf start {
        type uint32;
        description "Start seq no. of hole";
      }

      leaf end {
        type uint32;
        description "End   seq no. of hole";
      }

      leaf duplicated-ack {
        type uint32;
        description
          "Number of dup (s)acks for this hole";
      }

      leaf retransmitted {
        type uint32;
        description
          "Next seq. no in hole to be retransmitted";
      }
    }  // grouping SACKHOLE-BAG

    grouping SACKBLK-BAG {
      description "Sack block entry";
      leaf start {
        type uint32;
        description
          "Start seq no. of sack block";
      }

      leaf end {
        type uint32;
        description
          "End   seq no. of sack block";
      }
    }  // grouping SACKBLK-BAG

    grouping TCP-CONN-STATES-BAG {
      description "TCP Connection states";
      leaf nagle-wait {
        type boolean;
        description
          "Nagle has delayed output";
      }

      leaf ack-needed {
        type boolean;
        description "Send an ACK";
      }

      leaf fin-sent {
        type boolean;
        description "FIN has been sent";
      }

      leaf probing {
        type boolean;
        description
          "Probing a closed window";
      }

      leaf need-push {
        type boolean;
        description "Need to push data out";
      }

      leaf pushed {
        type boolean;
        description
          "A segment is pushed due to MSG_PUSH";
      }

      leaf in-syn-cache {
        type boolean;
        description
          "Connection is in SYN cache";
      }

      leaf path-mtu-ager {
        type boolean;
        description
          "Path MTU aging timer is running";
      }
    }  // grouping TCP-CONN-STATES-BAG

    grouping TCP-CONN-FEATURES-BAG {
      description "TCP Connection features";
      leaf selective-ack {
        type boolean;
        description "Selective ack on?";
      }

      leaf md5 {
        type boolean;
        description "MD5 option on?";
      }

      leaf timestamps {
        type boolean;
        description "Timestamps on?";
      }

      leaf window-scaling {
        type boolean;
        description "Window-scaling on?";
      }

      leaf nagle {
        type boolean;
        description "Nagle algorithm on?";
      }

      leaf giveup-timer {
        type boolean;
        description "Giveup timer is on?";
      }

      leaf connection-keep-alive-timer {
        type boolean;
        description "Keepalive timer is on?";
      }

      leaf path-mtu-discovery {
        type boolean;
        description
          "Path MTU Discovery feature is on?";
      }

      leaf mss-cisco {
        type boolean;
        description "tcp mss feature is on?";
      }
    }  // grouping TCP-CONN-FEATURES-BAG

    grouping TCP-SOCK-STATES-BAG {
      description "TCP Socket State Flags";
      leaf no-file-descriptor-reference {
        type boolean;
        description "No file descriptor ref";
      }

      leaf is-connected {
        type boolean;
        description
          "Socket is connected to peer";
      }

      leaf is-connecting {
        type boolean;
        description "Connecting in progress";
      }

      leaf is-disconnecting {
        type boolean;
        description
          "Disconnecting in progress";
      }

      leaf cant-send-more {
        type boolean;
        description
          "Can't send more data to peer";
      }

      leaf cant-receive-more {
        type boolean;
        description
          "Can't recv more data from peer";
      }

      leaf received-at-mark {
        type boolean;
        description "At mark on input";
      }

      leaf privileged {
        type boolean;
        description
          "Privileged for broadcast, raw...";
      }

      leaf block-close {
        type boolean;
        description
          "Close is blocked (i.e. socket is a replicated
         socket on a standby node";
      }

      leaf async-io-notify {
        type boolean;
        description "Async i/o notify";
      }

      leaf is-confirming {
        type boolean;
        description
          "Deciding to accept connection req";
      }

      leaf is-solock {
        type boolean;
        description
          "Mutex acquired by solock()";
      }

      leaf is-detached {
        type boolean;
        description
          "PCB and socket are detached";
      }

      leaf block-receive {
        type boolean;
        description
          "Socket is blocked for receive - while going
         through SSO initial sync";
      }

      leaf block-send {
        type boolean;
        description
          "Socket is blocked for send (if it is a
         replicated socket on a standby node)";
      }
    }  // grouping TCP-SOCK-STATES-BAG

    grouping TCP-SOCK-OPTIONS-BAG {
      description "TCP Socket Option Flags ";
      leaf debug {
        type boolean;
        description
          "Turn on debugging info recording";
      }

      leaf accept-connection {
        type boolean;
        description
          "Socket has had listen()";
      }

      leaf reuse-address {
        type boolean;
        description
          "Allow local address reuse";
      }

      leaf keep-alive {
        type boolean;
        description "Keep connections alive";
      }

      leaf dont-route {
        type boolean;
        description
          "Just use interface addresses";
      }

      leaf broadcast {
        type boolean;
        description
          "Permit sending of broadcast msgs";
      }

      leaf use-loopback {
        type boolean;
        description
          "Bypass hardware when possible";
      }

      leaf linger {
        type boolean;
        description
          "Linger on close if data present";
      }

      leaf out-of-band-inline {
        type boolean;
        description
          "Leave received Out-of-band data inline";
      }

      leaf reuse-port {
        type boolean;
        description
          "Allow local address & port reuse";
      }

      leaf nonblocking-io {
        type boolean;
        description
          "Nonblocking socket I/O operation";
      }

      leaf snd-buf-scaled {
        type boolean;
        description "Send buffer scaled";
      }

      leaf rcv-buf-scaled {
        type boolean;
        description "Receive buffer scaled";
      }
    }  // grouping TCP-SOCK-OPTIONS-BAG

    grouping TCP-TIMER-BAG {
      description "TCP Timer Info";
      leaf timer-type {
        type Tcp-timer;
        description "Timer Type";
      }

      leaf timer-activations {
        type uint32;
        description
          "Count of timer activations";
      }

      leaf timer-expirations {
        type uint32;
        description
          "Count of timer expirations";
      }

      leaf timer-next-activation {
        type uint32;
        description
          "Timer next activation (msec)";
      }
    }  // grouping TCP-TIMER-BAG

    grouping TCP-ADDRESS-TYPE {
      description "TCP ADDRESS TYPE";
      leaf af-name {
        type Tcp-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 Tcp-in6-addr;
        description "IPv6 Address";
      }
    }  // grouping TCP-ADDRESS-TYPE

    grouping TCP-SH-TABLE-BAG {
      description
        "Detailed information about a TCP connection";
      container local-address {
        description "Local address";
        uses TCP-ADDRESS-TYPE;
      }  // container local-address

      container foreign-address {
        description "Foreign address";
        uses TCP-ADDRESS-TYPE;
      }  // container foreign-address

      container socket-option-flags {
        description "Socket option flags";
        uses TCP-SOCK-OPTIONS-BAG;
      }  // container socket-option-flags

      container socket-state-flags {
        description "Socket state flags";
        uses TCP-SOCK-STATES-BAG;
      }  // container socket-state-flags

      container feature-flags {
        description
          "Connection feature flags";
        uses TCP-CONN-FEATURES-BAG;
      }  // container feature-flags

      container state-flags {
        description "Connection state flags";
        uses TCP-CONN-STATES-BAG;
      }  // container state-flags

      container request-flags {
        description
          "Connection request flags";
        uses TCP-CONN-FEATURES-BAG;
      }  // container request-flags

      container receive-buf-state-flags {
        description
          "Receive buffer state flags";
        uses TCP-SOCKBUF-STATES-BAG;
      }  // container receive-buf-state-flags

      container send-buf-state-flags {
        description
          "Send buffer state flags";
        uses TCP-SOCKBUF-STATES-BAG;
      }  // container send-buf-state-flags

      leaf address-family {
        type Tcp-address-family;
        description "Address Family";
      }

      leaf pcb {
        type uint64;
        description "PCB Address";
      }

      leaf so {
        type uint64;
        description "Socket Address";
      }

      leaf tcpcb {
        type uint64;
        description "TCPCB Address";
      }

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

      leaf connection-state {
        type Tcp-conn-state;
        description "Connection state";
      }

      leaf established-time {
        type uint32;
        description
          "Time at which connection is established";
      }

      leaf local-pid {
        type uint32;
        description
          "Id of the local process";
      }

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

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

      leaf packet-priority {
        type Pak-prio;
        description
          "Priority given to packets on this socket";
      }

      leaf packet-tos {
        type uint16;
        description
          "Type of Service value to be applied to
         transmistted packets";
      }

      leaf packet-ttl {
        type uint16;
        description
          "TTL to be applied to transmited packets";
      }

      leaf hash-index {
        type uint32;
        description
          "Index of the Hash Bucket";
      }

      leaf current-receive-queue-size {
        type uint32;
        units "byte";
        description
          "Current receive queue size in bytes";
      }

      leaf max-receive-queue-size {
        type uint32;
        units "byte";
        description
          "Max receive queue size in bytes";
      }

      leaf current-send-queue-size {
        type uint32;
        units "byte";
        description
          "Current send queue size in bytes";
      }

      leaf max-send-queue-size {
        type uint32;
        units "byte";
        description
          "Max send queue size in bytes";
      }

      leaf current-receive-queue-packet-size {
        type uint32;
        description
          "Current receive queue size in packets";
      }

      leaf max-receive-queue-packet-size {
        type uint32;
        description
          "Max receive queue size in packets";
      }

      leaf save-queue-size {
        type uint32;
        units "byte";
        description
          "Save queue (out-of seq data) size in bytes";
      }

      leaf send-initial-sequence-num {
        type uint32;
        description
          "Initial send sequence number";
      }

      leaf send-unack-sequence-num {
        type uint32;
        description
          "Sequence number of unacked data";
      }

      leaf send-next-sequence-num {
        type uint32;
        description
          "Sequence number of next data to be sent";
      }

      leaf send-max-sequence-num {
        type uint32;
        description
          "Highest sequence number sent";
      }

      leaf send-window-size {
        type uint32;
        units "byte";
        description
          "Send window size in bytes";
      }

      leaf send-congestion-window-size {
        type uint32;
        units "byte";
        description
          "Send congestion window size in bytes";
      }

      leaf receive-initial-sequence-num {
        type uint32;
        description
          "Initial receive sequence number";
      }

      leaf receive-next-sequence-num {
        type uint32;
        description
          "Next sequence number expected";
      }

      leaf receive-adv-window-size {
        type uint32;
        units "byte";
        description
          "Receive advertised window size in bytes";
      }

      leaf receive-window-size {
        type uint32;
        units "byte";
        description
          "Receive window size in bytes";
      }

      leaf mss {
        type uint32;
        units "byte";
        description
          "Max segment size calculated in bytes";
      }

      leaf peer-mss {
        type uint32;
        units "byte";
        description
          "Max segment size offered by the peer in bytes";
      }

      leaf srtt {
        type uint32;
        description
          "Smoothed round trip time * 8 (msec)";
      }

      leaf rtto {
        type uint32;
        description
          "Round trip timeout (msec)";
      }

      leaf krtt {
        type uint32;
        description
          "Round trip time (karn algorithm) (msec)";
      }

      leaf srtv {
        type uint32;
        description
          "Smoothed round trip time variance * 4 (msec)";
      }

      leaf min-rtt {
        type uint32;
        description "Min RTT (msec)";
      }

      leaf max-rtt {
        type uint32;
        description "Max RTT (msec)";
      }

      leaf retries {
        type uint32;
        description "Number of retries";
      }

      leaf ack-hold-time {
        type uint32;
        description "ACK hold time (msec)";
      }

      leaf giveup-time {
        type uint32;
        description "Giveup time (msec)";
      }

      leaf keep-alive-time {
        type uint32;
        description "Keepalive time (msec)";
      }

      leaf syn-wait-time {
        type uint32;
        description "SYN wait time (msec)";
      }

      leaf rxsy-naclname {
        type string {
          length "0..64";
        }
        description "RX Syn acl name";
      }

      leaf soft-error {
        type int32;
        description
          "Error code from ICMP Notify";
      }

      leaf sock-error {
        type int32;
        description "Socket error code";
      }

      leaf is-retrans-forever {
        type boolean;
        description "Retransimit forever?";
      }

      leaf min-mss {
        type uint32;
        description "Lowest MSS ever used";
      }

      leaf max-mss {
        type uint32;
        description "Highest MSS ever used";
      }

      leaf connect-retries {
        type uint16;
        description
          "Number of times connect will be retried?";
      }

      leaf connect-retry-interval {
        type uint16;
        units "second";
        description
          "Connect retry interval in seconds";
      }

      leaf receive-window-scale {
        type uint32;
        description
          "Window scaling for receive window";
      }

      leaf send-window-scale {
        type uint32;
        description
          "Window scaling for send window";
      }

      leaf request-receive-window-scale {
        type uint32;
        description
          "Requested receive window scale";
      }

      leaf rqst-send-wnd-scale {
        type uint32;
        description
          "Requested send window scale";
      }

      leaf time-stamp-recent {
        type uint32;
        description
          "Timestamp from remote host";
      }

      leaf time-stamp-recent-age {
        type uint32;
        description
          "Timestamp when last updated";
      }

      leaf last-ack-sent {
        type uint32;
        description
          "ACK number of a sent segment";
      }

      leaf sendbuf-lowwat {
        type uint32;
        description
          "Send buffer's low water mark";
      }

      leaf recvbuf-lowwat {
        type uint32;
        description
          "Receive buffer's low water mark";
      }

      leaf sendbuf-hiwat {
        type uint32;
        description
          "Send buffer's high water mark";
      }

      leaf recvbuf-hiwat {
        type uint32;
        description
          "Receive buffer's high water mark";
      }

      leaf sendbuf-notify-thresh {
        type uint32;
        description
          "Send buffer's notify threshold";
      }

      leaf recvbuf-datasize {
        type uint32;
        description
          "Receive buffer's data size";
      }

      leaf queue-length {
        type uint32;
        description
          "Incoming connection queue size";
      }

      leaf queue-zero-length {
        type uint32;
        description
          "Incoming half-connection queue size";
      }

      leaf queue-limit {
        type uint32;
        description
          "Incoming connection queue limit";
      }

      leaf socket-error {
        type uint32;
        description "Socket error status";
      }

      leaf auto-rearm {
        type uint32;
        description
          "Socket auto rearm state";
      }

      leaf send-pdu-count {
        type uint32;
        description
          "# of PDU's in Send Buffer";
      }

      leaf output-ifhandle {
        type uint32;
        description
          "Cached Outgoing interface  handle";
      }

      leaf fib-pd-ctx-size {
        type uint32;
        description
          "Cached fib pd context size";
      }

      leaf num-labels {
        type uint32;
        description
          "Number of labels returned by fib lookup";
      }

      leaf local-app-instance {
        type uint32;
        description
          "Instance number of the local process";
      }

      list fib-pd-ctx {
        max-elements 4;
        description "Cached fib pd context";
        leaf entry {
          type uint32;
          description
            "Cached fib pd context";
        }
      }  // list fib-pd-ctx

      list fib-label-output {
        max-elements 7;
        description "Cached Label stack";
        leaf entry {
          type uint32;
          description "Cached Label stack";
        }
      }  // list fib-label-output

      list timer {
        max-elements 9;
        description "Timers";
        uses TCP-TIMER-BAG;
      }  // list timer

      list sack-blk {
        max-elements 6;
        description
          "Seq nos. of sack blocks";
        uses SACKBLK-BAG;
      }  // list sack-blk

      list send-sack-hole {
        max-elements 6;
        description
          "Sorted list of sack holes";
        uses SACKHOLE-BAG;
      }  // list send-sack-hole
    }  // grouping TCP-SH-TABLE-BAG

    grouping TCP-SH-STATS-BAG {
      description "TCP Statistics";
      leaf syn-cache-count {
        type uint32;
        description
          "Current number of SYN cache entries";
      }

      leaf num-open-sockets {
        type uint32;
        description "Number of Open sockets";
      }

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

      leaf send-packets-dropped {
        type uint32;
        description
          "Total transmit packets dropped due to general
         failures";
      }

      leaf send-auth-packets-dropped {
        type uint32;
        description
          "Total transmit packets dropped due to
         authentication failures";
      }

      leaf data-pakets-sent {
        type uint32;
        description "Data packets sent";
      }

      leaf data-bytes-sent {
        type uint32;
        units "byte";
        description "Data bytes sent";
      }

      leaf packets-retransmitted {
        type uint32;
        description
          "Data packets retransmitted";
      }

      leaf bytes-retransmitted {
        type uint32;
        units "byte";
        description
          "Data bytes retransmitted";
      }

      leaf ack-only-packets-sent {
        type uint32;
        description
          "Ack only packets sent (incl. delay)";
      }

      leaf delay-ack-packets-sent {
        type uint32;
        description "Delay ack packets sent";
      }

      leaf urgent-only-packets-sent {
        type uint32;
        description
          "Urgent only packets sent";
      }

      leaf window-probe-packets-sent {
        type uint32;
        description
          "Window probe packets sent";
      }

      leaf window-update-packets-sent {
        type uint32;
        description
          "Window update packets sent";
      }

      leaf control-packets-sent {
        type uint32;
        description
          "Control (SYN|FIN|RST) packets sent";
      }

      leaf rst-packets-sent {
        type uint32;
        description "RST packets sent";
      }

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

      leaf received-packets-dropped {
        type uint32;
        description
          "Received packets dropped due to general failures";
      }

      leaf synacl-match-pkts-dropped {
        type uint32;
        description
          "Received packets dropped due to ACL DENY on SYN
         pkts";
      }

      leaf received-packets-dropped-stale-c-hdr {
        type uint32;
        description
          "Received packets dropped due to stale cached
         header";
      }

      leaf received-auth-packets-dropped {
        type uint32;
        description
          "Received packets dropped due to authentication
         failures";
      }

      leaf ack-packets-received {
        type uint32;
        description "Ack packets received";
      }

      leaf ackbytes-received {
        type uint32;
        units "byte";
        description
          "Bytes acked by ack packets";
      }

      leaf duplicated-ack-packets-received {
        type uint32;
        description "Duplicate ack packets";
      }

      leaf ack-packets-for-unsent-received {
        type uint32;
        description
          "Ack packets for unsent data";
      }

      leaf data-packets-received-in-sequence {
        type uint32;
        description
          "Data packets received in sequence";
      }

      leaf data-bytes-received-in-sequence {
        type uint32;
        units "byte";
        description
          "Data bytes received in sequence";
      }

      leaf duplicate-packets-received {
        type uint32;
        description
          "Duplicate packets received";
      }

      leaf duplicate-bytes-received {
        type uint32;
        units "byte";
        description
          "Duplicate bytes received";
      }

      leaf partial-duplicate-ack-received {
        type uint32;
        description
          "Packets with partial dup data";
      }

      leaf partial-duplicate-bytes-received {
        type uint32;
        units "byte";
        description
          "Bytes with partial dup data";
      }

      leaf out-of-order-packets-received {
        type uint32;
        description
          "Out-of-order packets received";
      }

      leaf out-of-order-bytes-received {
        type uint32;
        units "byte";
        description
          "Out-of-order bytes received";
      }

      leaf after-window-packets-received {
        type uint32;
        description
          "After-window packets received";
      }

      leaf after-window-bytes-received {
        type uint32;
        units "byte";
        description
          "After-window bytes received";
      }

      leaf window-probe-packets-received {
        type uint32;
        description
          "Window probe packets received";
      }

      leaf window-update-packets-received {
        type uint32;
        description
          "Window update packets received";
      }

      leaf packets-received-after-close-packet {
        type uint32;
        description
          "Packets received after close";
      }

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

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

      leaf malformed-packets-received {
        type uint32;
        description
          "Packets received with malformed header";
      }

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

      leaf connections-requested {
        type uint32;
        description
          "Connection requests sent";
      }

      leaf connections-accepted {
        type uint32;
        description
          "Connection requests accepted";
      }

      leaf connections-established {
        type uint32;
        description
          "Connections established";
      }

      leaf connections-forcibly-closed {
        type uint32;
        description
          "Connections forcibly closed";
      }

      leaf connections-closed {
        type uint32;
        description
          "connections closed (incl. drops)";
      }

      leaf connections-dropped {
        type uint32;
        description "connections dropped";
      }

      leaf embryonic-connection-dropped {
        type uint32;
        description
          "Embryonic connections dropped";
      }

      leaf connections-failed {
        type uint32;
        description "Connections failed";
      }

      leaf established-connections-reset {
        type uint32;
        description
          "Established connections reset";
      }

      leaf retransmit-timeouts {
        type uint32;
        description
          "Retransmit timeouts (incl. data packets)";
      }

      leaf retransmit-dropped {
        type uint32;
        description
          "Connection drops during retransmit timeouts";
      }

      leaf keep-alive-timeouts {
        type uint32;
        description "Keepalive timeouts";
      }

      leaf keep-alive-dropped {
        type uint32;
        description
          "Connection drops due to keepalive timeouts";
      }

      leaf keep-alive-probes {
        type uint32;
        description "Keepalive probes sent";
      }

      leaf paws-dropped {
        type uint32;
        description
          "Segments dropped due to PAWS";
      }

      leaf persist-dropped {
        type uint32;
        description
          "Segments dropped due to window probe";
      }

      leaf try-lock-dropped {
        type uint32;
        description
          "Segments dropped due to trylock fail";
      }

      leaf connection-rate-limited {
        type uint32;
        description
          "Connections rate-limited";
      }

      leaf syn-cache-added {
        type uint32;
        description
          "SYN Cache entries added";
      }

      leaf syn-cache-completed {
        type uint32;
        description
          "SYN Cache connections completed";
      }

      leaf syn-cache-timed-out {
        type uint32;
        description
          "SYN Cache entries timed out";
      }

      leaf syn-cache-overflow {
        type uint32;
        description
          "SYN Cache entries dropped due to overflow";
      }

      leaf syn-cache-reset {
        type uint32;
        description
          "SYN Cache entries dropped due to RST";
      }

      leaf syn-cache-unreach {
        type uint32;
        description
          "SYN Cache entries dropped due to ICMP unreach";
      }

      leaf syn-cache-bucket-oflow {
        type uint32;
        description
          "SYN Cache entries dropped due to bucket overflow";
      }

      leaf syn-cache-aborted {
        type uint32;
        description
          "SYN Cache entries aborted (no mem)";
      }

      leaf syn-cache-duplicate-sy-ns {
        type uint32;
        description
          "SYN Cache duplicate SYNs received";
      }

      leaf syn-cache-dropped {
        type uint32;
        description
          "SYN Cache entries dropped (no route/mem)";
      }

      leaf pulse-errors {
        type uint32;
        description
          "Punt (down to ip) failures";
      }

      leaf socket-layer-packets {
        type uint32;
        description
          "Packets owned by the socket layer";
      }

      leaf reassembly-packets {
        type uint32;
        description
          "Packets owned by TCP reassembly";
      }

      leaf recovered-packets {
        type uint32;
        description
          "Packets freed after starvation";
      }

      leaf packet-failures {
        type uint32;
        description
          "Packet allocation errors";
      }

      leaf mss-up {
        type uint32;
        description
          "Number of times MSS was increased";
      }

      leaf mss-down {
        type uint32;
        description
          "Number of times MSS was decreased";
      }

      leaf truncated-write-iov {
        type uint32;
        description
          "Segments truncated due to insufficient Write I/O
         vectors";
      }

      leaf no-throttle {
        type uint32;
        description
          "Number of times throttle mode was off";
      }

      leaf low-water-mark-throttle {
        type uint32;
        description
          "Number of times low water mark throttle was on";
      }

      leaf high-water-mark-throttle {
        type uint32;
        description
          "Number of times high water mark throttle was on";
      }

      leaf stalled-timer-tickle-count {
        type uint32;
        description
          "Number of times a stalled tcp timer was tickled";
      }

      leaf stalled-timer-tickle-time {
        type uint32;
        description
          "Last timestamp when a stalled tcp timer was
         tickled";
      }

      leaf iq-sock-writes {
        type uint32;
        description
          "Number of write attempts from socket-lib into an
         IQ";
      }

      leaf iq-sock-retries {
        type uint32;
        description
          "Number of retried write attempts";
      }

      leaf iq-sock-aborts {
        type uint32;
        description
          "Number of aborted socket-lib writes";
      }

      leaf iq-ingress-drops {
        type uint32;
        description
          "Number of total ingress dropped packets";
      }

      leaf total-i-qs {
        type uint32;
        description
          "Number of TCP internal queues in use";
      }

      leaf sockbuf-pak-res-cur {
        type uint32;
        description
          "Current number of packets extended for scaled
         sockets";
      }

      leaf sockbuf-pak-res-max {
        type uint32;
        description
          "Maximum number of packets extended for scaled
         sockets";
      }

      leaf sock-async-double-free-prevent-count {
        type uint32;
        description
          "Total number of socket async buffer double free
         prevented";
      }

      list iqs-total-ingpacket {
        max-elements 20;
        description
          "Total Number of Ingress packets on TCP iqs";
        leaf entry {
          type uint32;
          description
            "Total Number of Ingress packets on TCP iqs";
        }
      }  // list iqs-total-ingpacket

      list iqs-total-egpacket {
        max-elements 20;
        description
          "Total Number of Egress packets on TCP iqs";
        leaf entry {
          type uint32;
          description
            "Total Number of Egress packets on TCP iqs";
        }
      }  // list iqs-total-egpacket
    }  // grouping TCP-SH-STATS-BAG

    grouping TCP-ASYNC-SESSION-STATS-BAG {
      description
        "TCP Async Session Statistic";
      leaf async-session {
        type boolean;
        description "Flag of async session";
      }

      list data-write-success-num {
        max-elements 2;
        description
          "Number of successful data write to XIPC";
        leaf entry {
          type uint32;
          description
            "Number of successful data write to XIPC";
        }
      }  // list data-write-success-num

      list data-read-success-num {
        max-elements 2;
        description
          "Number of successful data read from XIPC";
        leaf entry {
          type uint32;
          description
            "Number of successful data read from XIPC";
        }
      }  // list data-read-success-num

      list data-write-error-num {
        max-elements 2;
        description
          "Number of failed data write to XIPC";
        leaf entry {
          type uint32;
          description
            "Number of failed data write to XIPC";
        }
      }  // list data-write-error-num

      list data-read-error-num {
        max-elements 2;
        description
          "Number of failed data read from XIPC";
        leaf entry {
          type uint32;
          description
            "Number of failed data read from XIPC";
        }
      }  // list data-read-error-num

      list control-write-success-num {
        max-elements 5;
        description
          "Number of successful control write to XIPC";
        leaf entry {
          type uint32;
          description
            "Number of successful control write to XIPC";
        }
      }  // list control-write-success-num

      list control-read-success-num {
        max-elements 5;
        description
          "Number of successful control read to XIPC";
        leaf entry {
          type uint32;
          description
            "Number of successful control read to XIPC";
        }
      }  // list control-read-success-num

      list control-write-error-num {
        max-elements 5;
        description
          "Number of failed control write to XIPC";
        leaf entry {
          type uint32;
          description
            "Number of failed control write to XIPC";
        }
      }  // list control-write-error-num

      list control-read-error-num {
        max-elements 5;
        description
          "Number of failed control read from XIPC";
        leaf entry {
          type uint32;
          description
            "Number of failed control read from XIPC";
        }
      }  // list control-read-error-num

      list data-write-byte {
        max-elements 2;
        description
          "Number of bytes data has been written";
        leaf entry {
          type uint64;
          units "byte";
          description
            "Number of bytes data has been written";
        }
      }  // list data-write-byte

      list data-read-byte {
        max-elements 2;
        description
          "Number of bytes data has been read";
        leaf entry {
          type uint64;
          units "byte";
          description
            "Number of bytes data has been read";
        }
      }  // list data-read-byte
    }  // grouping TCP-ASYNC-SESSION-STATS-BAG

    grouping TCP-IO-COUNTS-BAG {
      description "Counts of I/O events";
      leaf io-count {
        type uint32;
        description
          "Number of I/O operations done by application";
      }

      leaf arm-count {
        type uint32;
        description
          "How many times socket was armed by application";
      }

      leaf unarm-count {
        type uint32;
        description
          "How many times socket was unarmed by application";
      }

      leaf autoarm-count {
        type uint32;
        description
          "How many times socket was auto-armed by TCP";
      }
    }  // grouping TCP-IO-COUNTS-BAG

    grouping TCP-SH-PCB-STATS-BAG {
      description "TCP PCB Statistics";
      container read-io-counts {
        description "Read  I/O counts";
        uses TCP-IO-COUNTS-BAG;
      }  // container read-io-counts

      container write-io-counts {
        description "Write I/O counts";
        uses TCP-IO-COUNTS-BAG;
      }  // container write-io-counts

      container async-session-stats {
        description
          "Statistics of Async TCP Sessions";
        uses TCP-ASYNC-SESSION-STATS-BAG;
      }  // container async-session-stats

      leaf pcb {
        type uint64;
        description "PCB Address";
      }

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

      leaf packets-sent {
        type uint64;
        description
          "Packets received from application";
      }

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

      leaf segment-instruction-received {
        type uint32;
        description
          "Segment Instruction received from partner node";
      }

      leaf send-packets-queued {
        type uint64;
        description
          "Packets queued to v4/v6 IO";
      }

      leaf send-packets-queued-net-io {
        type uint64;
        description
          "Packets queued to NetIO";
      }

      leaf send-queue-failed {
        type uint32;
        description
          "Packets failed to be queued to v4/v6 IO";
      }

      leaf send-queue-net-io-failed {
        type uint32;
        description
          "Packets failed to be queued to NetIO";
      }

      leaf packets-received {
        type uint64;
        description
          "Packets received from network";
      }

      leaf receive-queue-failed {
        type uint32;
        description
          "Received packets failed to be queued to
         application";
      }

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

      leaf send-window-shrink-ignored {
        type uint32;
        description
          "No. of times send window shrinkage by peer was
         ignored";
      }

      leaf is-paw-socket {
        type boolean;
        description "PAW or non-PAW socket?";
      }

      leaf read-io-time {
        type uint32;
        description
          "Time at which receive buffer was last read from";
      }

      leaf write-io-time {
        type uint32;
        description
          "Time at which send buffer was last written to";
      }

      leaf min-ttl-dropped {
        type uint64;
        description
          "Received packets dropped due to minttl";
      }
    }  // grouping TCP-SH-PCB-STATS-BAG
  }  // submodule Cisco-IOS-XR-ip-tcp-oper-sub3