module Cisco-IOS-XE-l2tp-oper {

    yang-version 1;

    namespace
      "http://cisco.com/ns/yang/Cisco-IOS-XE-l2tp-oper";

    prefix l2tp-ios-xe-oper;

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

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service

     Postal: 170 W Tasman Drive
     San Jose, CA 95134

     Tel: +1 1800 553-NETS

     E-mail: cs-yang@cisco.com";

    description
      "This module contains a collection of YANG definitions
     for L2TP operational data.
     Copyright (c) 2019 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2020-03-01" {
      description "Initial revision";
      reference
        "1.0.0";

    }

    cisco-semver:module-version "1.0.0";

    typedef l2tp-tunnel-state {
      type enumeration {
        enum "l2tp-state-init" {
          value 0;
          description "Init state";
        }
        enum "l2tp-state-idle" {
          value 1;
          description "Idle state";
        }
        enum "l2tp-state-wait-for-sock" {
          value 2;
          description
            "wait for socket state";
        }
        enum "l2tp-state-processing-sccrq" {
          value 3;
          description
            "Processing Start-Control-Connection-Request state";
        }
        enum "l2tp-state-wait-for-sccn" {
          value 4;
          description
            "Wait for Start-Control-Connection-Connected state";
        }
        enum "l2tp-state-processing-scccn" {
          value 5;
          description
            "Processing Start-Control-Connection-Connected state";
        }
        enum "l2tp-state-wait-for-sccrp" {
          value 6;
          description
            "Wait for Start-Control-Connection-Reply state";
        }
        enum "l2tp-state-processing-sccrp" {
          value 7;
          description
            "Processing Start-Control-Connection-Reply state";
        }
        enum "l2tp-state-established" {
          value 8;
          description "Established state";
        }
        enum
          "l2tp-state-established-no-users" {
          value 9;
          description
            "Established with no users state";
        }
        enum "l2tp-state-shutting-down" {
          value 10;
          description "Shutting down state";
        }
        enum "l2tp-state-dead" {
          value 11;
          description "Dead state";
        }
      }
      description "L2TP tunnel state";
    }

    container l2tp-oper-data {
      config false;
      description "L2TP operational data";
      list l2tp-tunnel-info {
        key "local-tunnel-id";
        description
          "L2TP tunnel information";
        leaf local-ip-address {
          type inet:ip-address;
          description
            "Tunnel local end point IP address[ipv4/ipv6]";
        }

        leaf remote-ip-address {
          type inet:ip-address;
          description
            "Tunnel remote end point IP address [ipv4/ipv6]";
        }

        leaf local-tunnel-id {
          type uint32;
          description
            "Local tunnel unique identifier";
        }

        leaf remote-tunnel-id {
          type uint32;
          description
            "Remote tunnel unique identifier";
        }

        leaf tunnel-local-name {
          type string;
          description "Local tunnel name";
        }

        leaf tunnel-remote-name {
          type string;
          description "Remote tunnel name";
        }

        leaf l2tp-class-name {
          type string;
          description
            "L2TP class name for the tunnel";
        }

        leaf tunnel-state {
          type l2tp-tunnel-state;
          description "Tunnel state";
        }

        leaf total-sessions {
          type uint32;
          description
            "Total number of sessions";
        }

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

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

        leaf ip-protocol-type {
          type uint16;
          description "IP protocol number";
        }

        leaf is-path-mtu-enabled {
          type uint16;
          description
            "True if path MTU is set";
        }
      }  // list l2tp-tunnel-info

      list l2tp-tunnel-counter {
        key "local-tunnel-id";
        description "Tunnel packet counters";
        leaf local-tunnel-id {
          type uint32;
          description
            "Local tunnel unique identifier";
        }

        leaf last-state-change-time {
          type yang:date-and-time;
          description
            "Time since the last state change occurred";
        }

        leaf last-counter-clear-time {
          type yang:date-and-time;
          description
            "Time when last clear happened";
        }

        container count-since-clear {
          description
            "Packet counters by taking last clear into account";
          leaf packets-in-ipv4 {
            type uint64;
            units "packets";
            description
              "Incoming IPV4 packets count";
          }

          leaf packets-out-ipv4 {
            type uint64;
            units "packets";
            description
              "Outgoing IPV4 packets count";
          }

          leaf bytes-in-ipv4 {
            type uint64;
            units "bytes";
            description
              "Incoming IPV4 packets";
          }

          leaf bytes-out-ipv4 {
            type uint64;
            units "bytes";
            description
              "Outgoing IPV4 packets";
          }

          leaf packets-in-ipv6 {
            type uint64;
            units "packets";
            description
              "Incoming IPV6 packets count";
          }

          leaf packets-out-ipv6 {
            type uint64;
            units "packets";
            description
              "Outgoing IPV6 packets count";
          }

          leaf bytes-in-ipv6 {
            type uint64;
            units "bytes";
            description
              "Incoming IPV6 packets";
          }

          leaf bytes-out-ipv6 {
            type uint64;
            units "bytes";
            description
              "Outgoing IPV6 packets";
          }
        }  // container count-since-clear

        container count-ignore-clear {
          description
            "Packet counters ignoring the last clear";
          leaf packets-in-ipv4 {
            type uint64;
            units "packets";
            description
              "Incoming IPV4 packets count";
          }

          leaf packets-out-ipv4 {
            type uint64;
            units "packets";
            description
              "Outgoing IPV4 packets count";
          }

          leaf bytes-in-ipv4 {
            type uint64;
            units "bytes";
            description
              "Incoming IPV4 packets";
          }

          leaf bytes-out-ipv4 {
            type uint64;
            units "bytes";
            description
              "Outgoing IPV4 packets";
          }

          leaf packets-in-ipv6 {
            type uint64;
            units "packets";
            description
              "Incoming IPV6 packets count";
          }

          leaf packets-out-ipv6 {
            type uint64;
            units "packets";
            description
              "Outgoing IPV6 packets count";
          }

          leaf bytes-in-ipv6 {
            type uint64;
            units "bytes";
            description
              "Incoming IPV6 packets";
          }

          leaf bytes-out-ipv6 {
            type uint64;
            units "bytes";
            description
              "Outgoing IPV6 packets";
          }
        }  // container count-ignore-clear

        leaf total-resend {
          type uint32;
          units "packets";
          description
            "Total number of packets were resend";
        }

        leaf zlb-acks-sent {
          type uint32;
          units "packets";
          description
            "Zero-Length Body acks sent";
        }

        leaf out-of-order-drops {
          type uint32;
          units "packets";
          description
            "Total number of out of order packets were dropped";
        }

        leaf out-of-order-reorder {
          type uint32;
          units "packets";
          description
            "Total number of out of order packets were reordered";
        }

        leaf peer-authen-failed {
          type uint32;
          units "packets";
          description
            "Peer authentication failed";
        }

        leaf congestion-ctrl-avoid-pkts {
          type uint16;
          units "packets";
          description
            "Packets count in congestion avoidance mode";
        }
      }  // list l2tp-tunnel-counter

      list l2tp-tunnel-parameters {
        key "local-tunnel-id";
        description "Tunnel parameters";
        leaf local-tunnel-id {
          type uint32;
          description
            "Local tunnel unique identifier";
        }

        leaf tx-sequence-number {
          type uint16;
          description "Send sequence number";
        }

        leaf rx-sequence-number {
          type uint16;
          description
            "Receive sequence number";
        }

        leaf local-window-size {
          type uint16;
          units "packets";
          description "Local window size";
        }

        leaf remote-window-size {
          type uint16;
          units "packets";
          description "Remote window size";
        }

        leaf rxed-remote-window-size {
          type uint16;
          units "packets";
          description
            "Received remote window size";
        }

        leaf retransmission-time {
          type uint16;
          units "seconds";
          description "Retransmission time";
        }

        leaf max-retransmission-time {
          type uint16;
          units "seconds";
          description
            "Maximum retransmission time";
        }

        leaf unsent-queue-size {
          type uint16;
          units "packets";
          description "Un-sent queue size";
        }

        leaf max-unsent-queue-size {
          type uint16;
          units "packets";
          description
            "Maximum un-sent queue size";
        }

        leaf resend-queue-size {
          type uint16;
          units "packets";
          description "Resend queue size";
        }

        leaf max-resend-queue-size {
          type uint16;
          units "packets";
          description
            "Maximum resent queue size";
        }

        leaf-list retrans-distr {
          type uint16;
          units "packets";
          ordered-by user;
          description
            "Retransmit time distribution";
        }

        leaf number-of-digests {
          type uint16;
          description
            "Control message authentication is enabled with
how many digest secrets";
        }

        leaf congestion-window-size {
          type uint16;
          units "packets";
          description
            "Congestion control window size";
        }

        leaf slow-start-threshold {
          type uint16;
          units "packets";
          description
            "Threshold limit.The point at which the sending device
switches operation from slow start mode to
congestion avoidance mode";
        }

        leaf is-local-window-size-default {
          type boolean;
          description
            "True if local window size is default";
        }

        leaf is-max-remote-window-size {
          type boolean;
          description
            "True if maximum remote window size is set";
        }

        leaf is-locally-initiated {
          type boolean;
          description
            "True if the tunnel was locally initiated or
False if the tunnel was initiated by the remote end";
        }

        leaf is-congestion-ctrl-slow-start {
          type boolean;
          description
            "True if congestion control mode is slow start";
        }

        leaf is-congestion-ctrl-enabled {
          type boolean;
          description
            "True if congestion control is enabled";
        }

        leaf using-digest-secret2 {
          type boolean;
          description
            "True if control message authentication is enabled";
        }

        leaf is-incomplete-export {
          type boolean;
          description
            "True if unable to export the data";
        }

        leaf queue-check-attempts {
          type uint16;
          description
            "Number of times packet queue check is hit,
before shutting down the tunnel. This delays tunnel shut down,
if control channel has outstanding packets.";
        }

        leaf max-queue-check-attempts {
          type uint16;
          description
            "Maximum number of attempts allowed to check packet queue";
        }
      }  // list l2tp-tunnel-parameters
    }  // container l2tp-oper-data
  }  // module Cisco-IOS-XE-l2tp-oper