<?xml version='1.0' encoding='utf-8'?>
<!-- This template (draft-davies-template-bare-07.xml) is for creating an
Internet Draft using xml2rfc, which is available here:
http://xml.resource.org. -->
<!-- For vocabulary, refer https://tools.ietf.org/html/rfc7991 -->
<!-- $ Id: draft-ietf-mpls-ldp-yang-09.xml 2020-03-20 skraza $ --> version="1.0" encoding="UTF-8"?>
<!DOCTYPE rfc SYSTEM "rfc2629-xhtml.ent">
<?xml-stylesheet type='text/xsl' href='rfc2629.xslt' ?>
<!-- used by XSLT processors -->
<!-- For a complete list and description of processing instructions (PIs),
    please see http://xml.resource.org/authoring/README.html. --> [
  <!ENTITY nbsp    "&#160;">
  <!ENTITY zwsp   "&#8203;">
  <!ENTITY nbhy   "&#8209;">
  <!ENTITY wj     "&#8288;">
]>

<rfc xmlns:xi="http://www.w3.org/2001/XInclude"
      category="std" docName="draft-ietf-mpls-ldp-yang-09" number="9070" ipr="trust200902" obsoletes="" updates="" submissionType="IETF" category="std" consensus="true" xml:lang="en" tocInclude="true" tocDepth="3" symRefs="true" sortRefs="true" version="3">
  <!-- xml2rfc v2v3 conversion 2.38.1 -->
  <!-- category values: std, bcp, info, exp, and historic
       ipr values: trust200902, noModificationTrust200902,
       noDerivativesTrust200902,
       or pre5378Trust200902
    you can add the attributes updates="NNNN" and obsoletes="NNNN"
    they will automatically be output with "(if approved)" -->

 <!-- ***** FRONT MATTER ***** -->

  <front>
    <!-- The abbreviated title is used in the page header - it is only
	 necessary if the full title is longer than 39 characters -->

    <title abbrev="YANG Data Model for MPLS LDP">
    YANG
    <title>YANG Data Model for MPLS LDP</title>

    <seriesInfo name="Internet-Draft" value="draft-ietf-mpls-ldp-yang-09"/>

    <!-- add 'role="editor"' below for the editors if appropriate --> name="RFC" value="9070"/>

    <author fullname="Kamran Raza" initials="K." role="editor" surname="Raza">
      <organization>Cisco Systems</organization>
      <address>
        <postal>
          <street/>
          <!-- Reorder these if your country does things differently -->
         <city/>
         <region/>
	 <code/>
	 <country>CA</country>
	 <country>Canada</country>
        </postal>
        <phone/>
        <email>skraza@cisco.com</email>
      </address>
    </author>

   <author fullname="Rajiv Asati" initials="R." surname="Asati">
      <organization>Cisco Systems</organization>
      <address>
        <postal>
          <street/>
          <!-- Reorder these if your country does things differently -->
         <city/>
         <region/>
	 <code/>
	 <country>USA</country>
	 <country>United States of America</country>
        </postal>
        <email>rajiva@cisco.com</email>
      </address>
   </author>

    <author fullname="Xufeng Liu" initials="X." surname="Liu">
      <organization>Volta Networks</organization>
      <organization>IBM Corporation</organization>
      <address>
        <postal>
          <street/>
          <!-- Reorder these if your country does things differently -->
         <city/>
         <region/>
	 <code/>
	 <country>USA</country>
	 <country>United States of America</country>
        </postal>
        <email>xufeng.liu.ietf@gmail.com</email>
      </address>
    </author>

    <author fullname="Santosh Esale" Easale" initials="S." surname="Esale"> surname="Easale">
      <organization>Juniper Networks</organization>
      <address>
        <postal>
          <street/>
          <!-- Reorder these if your country does things differently -->
         <city/>
         <region/>
	 <code/>
	 <country>USA</country>
	 <country>United States of America</country>
        </postal>

        <email>sesale@juniper.net</email>

        <email>santosh_easale@berkeley.edu</email>
      </address>
    </author>

    <author fullname="Xia Chen" initials="X." surname="Chen">
      <organization>Huawei Technologies</organization>
      <address>
        <postal>
          <street/>
          <!-- Reorder these if your country does things differently -->
         <city/>
         <region/>
	 <code/>
	 <country>China</country>
        </postal>
        <email>jescia.chenxia@huawei.com</email>
      </address>
    </author>

    <author fullname="Himanshu Shah" initials="H." surname="Shah">
      <organization>Ciena Corporation</organization>
      <address>
	<postal>
          <street/>
          <!-- Reorder these if your country does things differently -->
         <city/>
         <region/>
	 <code/>
	 <country>USA</country>
	 <country>United States of America</country>
        </postal>
        <email>hshah@ciena.com</email>
      </address>
    </author>

   <date day="20" month="March" year="2020"/>

   <!-- Meta-data Declarations --> year="2022"/>

   <area>Routing</area>
   <workgroup>MPLS Working Group</workgroup>
   <workgroup>MPLS</workgroup>
   <keyword>MPLS</keyword>
   <keyword>LDP</keyword>
   <keyword>YANG</keyword>

   <abstract>
     <t>This document describes a YANG data model for Multi-Protocol the Multiprotocol Label Switching (MPLS)
     Label Distribution Protocol (LDP). The model also serves as the base model
     to define the Multipoint LDP (mLDP) model. </t>

     <t> The YANG modules in this document conform to the Network Management
   Datastore Architecture (NMDA).
     </t>

   </abstract>
  </front>

  <middle>

    <section numbered="true" toc="default">
    <name>Introduction</name>

      <t>The Network Configuration Protocol (NETCONF) <xref target="RFC6241"/>
      is one of the network management protocols that defines mechanisms to
      manage network devices. YANG <xref target="RFC6020"/> <xref
      target="RFC7950"/> is a modular language that represents data structures
      in an XML tree format, format and is used as a data modelling modeling language for the
      NETCONF.</t>

      <t> This document introduces a YANG data model for the MPLS Label
      Distribution Protocol (LDP) <xref target="RFC5036"/>. This model also
      covers LDP IPv6 <xref target="RFC7552"/> and LDP capabilities capability <xref
      target="RFC5561"/> specifications. </t>

      <t> The data model is defined for the following constructs that are used for managing the protocol: </t>
      <ul>
        <li> Configuration </li>
        <li> Operational State </li>
        <li> Executables (Actions) </li>
        <li> Notifications </li>
      </ul>

      <t> This document is organized to define the data model for each of the above constructs
in the sequence as listed above. </t>

<section numbered="true" toc="default">
  <name>Base and Extended</name>

<t> The configuration and state items are divided into the following two broad categories: </t>
<ul>
  <li> Base </li>
  <li> Extended </li>
</ul>

<t> The "base" category contains the basic and fundamental features that are
covered in LDP base specification <xref target="RFC5036"/> and constitute the
minimum requirements for a typical base LDP deployment. Whereas, deployment, whereas the "extended"
category contains other non-base features. All the items in a base category
are mandatory and hence and, hence, no "if-feature" is allowed under the "base" category.
The base and extended categories are defined in their own modules as described
later. </t>

<t> The example examples of a base feature includes include the configuration of LDP lsr-id,
enabling LDP interfaces, setting password passwords for LDP session sessions, etc., whereas the
examples of an extended feature include inbound/outbound label policies, igp sync IGP
Sync <xref target="RFC5443"/>, downstream-on-demand downstream on demand, etc. It is worth
highlighting that LDP IPv6 <xref target="RFC7552"/> is also categorized as an
extended feature. </t>

<t> While "base" model support will suffice for small deployments, it is expected that large deployments will require both the "base" and "extended" models model support from the vendors. </t>

</section>

    </section>

    <section numbered="true" toc="default">
    <name>Specification of Requirements</name>
      <t> In this document, the word "IP" is used to refer to both IPv4 and IPv6,
      IPv6 unless otherwise explicitly stated. For example, "IP address
      family" should be read as "IPv4 and/or IPv6 address family". </t>
    </section>

    <section numbered="true" toc="default">
      <name>Overview</name>

	<t> This document defines two new modules for LDP YANG support: </t>
	<ul>
	  <li> "ietf-mpls-ldp"

<dl newline="true">

<dt>"ietf-mpls-ldp"
</dt>
<dd>A module that specifies the base LDP features and augments
/rt:routing/rt:control-plane-protocols/rt:control-plane-protocol defined in
<xref target="RFC8349"/>. We define the new identity 'mpls-ldp' for LDP and LDP; the
model allows only a single instance of 'mpls-ldp'. </li>
	  <li> "ietf-mpls-ldp-extended"
</dd>

<dt>"ietf-mpls-ldp-extended"
</dt>
<dd>A module that specifies the extended LDP features and augments the base
LDP module.</li>
	</ul> module.
</dd>

</dl>

	<t> It is to be noted that the mLDP YANG data model <xref
	target="I-D.ietf-mpls-mldp-yang"/> augments LDP base and extended
	modules to specify the mLDP specific mLDP-specific base and extended features. </t>

	<t>
	  There are four types of containers in our module(s): </t>
	  <ul>
	    <li> Read-Write Read-write parameters for configuration (<xref target="section_ldp_cfg"/>) </li>
	    <li> Read-only parameters for operational state (<xref target="section_ldp_oper"/>) </li>
	    <li> Notifications for events (<xref target="section_ldp_notif"/>) </li>
	    <li> RPCs for executing commands to perform some action (<xref
	    target="section_ldp_action"/>) </li>
	  </ul>

	<t>
	  The modules in this document conforms conform to the Network Management
	  Datastore Architecture (NMDA) defined in <xref target="RFC8342"/>.
	  The operational state data is combined with the associated
	  configuration data in the same hierarchy <xref target="RFC8407"/>.
	  When protocol states are retrieved from the NMDA operational state
	  datastore, the returned states cover all "config true" (rw) and
	  "config false" (ro) nodes defined in the schema.
	</t>

	<t> Following

	<t>The following diagram depicts high level high-level LDP YANG tree organization and hierarchy: </t>

	<figure anchor="LDPYangTreeHL">
	  <name>LDP YANG tree organization</name>
	  <artwork> Tree Organization</name>
	  <sourcecode type="yangtree">
         +-- rw routing
            +-- rw control-plane-protocols
             +-- rw control-plane-protocol
              +-- rw mpls-ldp
                  +-- rw ...
                      +-- rw ...                 // base
                      |   +-- rw ...
                      |   +-- ro ...
                      |   +--
                      +-- ro ...
                      |   +-- ro ...
                      |   +-- ro ...
                      |   +--
                      +-- rw ldp-ext: ....       // extended
                      |   +-- rw ...
                      |   +-- ro ...
                      |   +--
                      +-- ro ...
                          +-- ro ...
                          +-- ro ...

    rpcs:
       +-- x mpls-ldp-some_action
       +-- x . . . . .

    notifications:
       +--- n mpls-ldp-some_event
       +--- n ...

	  </artwork>
  </sourcecode>
	</figure>

	  <t> Before going into data model details, it is important to take
	  note of the following points: </t>

	  <ul>
	    <li> This model aims to address only the core LDP parameters as
	    per RFC specification, as well as well-known and widely deployed
	    manageability controls (such as label filtering policies to apply
	    filtering rules on the assignment, advertisement, and acceptance
	    for label bindings).  Any vendor specific vendor-specific feature should be
	    defined in a vendor-specific augmentation of this model. </li>

	    <li> Multi-topology LDP <xref target="RFC7307"/> is beyond the scope of this document. </li>

	    <li> This model does not cover any applications running on top of
	    LDP, nor does it cover any OAM Operations, Administration, and
	    Maintenance (OAM) procedures for LDP. </li>

	    <li> This

	    <li>This model is a VPN Routing and Forwarding (VRF)-centric VRF-centric model. It is important to note
	    that <xref target="RFC4364"/> defines VRF VPN Routing and Forwarding
	    (VRF) tables and default forwarding tables as
	    different, however different; however,
	    from a YANG modelling perspective modeling perspective, this introduces unnecessary complications, hence
	    complications; hence, we are treating the default forwarding table
	    as just another VRF. </li>

	    <li> A "network-instance", as defined in <xref target="RFC8529"/>,
	    refers to a VRF instance (both default and non-default) within the
	    scope of this model. </li>

	    <li> This model supports two address-families, namely address families, namely, "ipv4" and "ipv6". </li>

	    <li> This model assumes platform-wide label space (i.e. (i.e., label
	    space Id of zero). However, when Upstream Label upstream label assignment <xref
	    target="RFC6389"/> is in use, an upstream assigned label is looked
	    up in a Context-Specific label space Label Space as defined in <xref
	    target="RFC5331"/>. </li>

	    <li> The label and peer policies (including filters) are defined
	    using prefix-set and neighbor-set respectively neighbor-set, respectively, as defined in the
	    routing-policy model <xref target="I-D.ietf-rtgwg-policy-model"/>. target="RFC9067"/>. </li>

	    <li> <t> This model uses the terms LDP "neighbor"/"adjacency", "neighbor/adjacency",
	    "session", and "peer" with the following semantics: </t>
	    <ul>
	      <li> Neighbor/Adjacency: An LDP enabled LSR
<dl>

<dt>Neighbor/Adjacency:
</dt>
<dd>An LDP-enabled Label Switching Router (LSR) that is discovered through LDP
discovery mechanisms. </li>
	      <li> Session: An
</dd>

<dt>Session:
</dt>
<dd>An LDP neighbor with whom a TCP connection has been established. </li>
	      <li> Peer: An
</dd>

<dt>Peer:
</dt>
<dd>An LDP session which that has successfully progressed beyond its initialization
phase and is either already exchanging the bindings or is ready to do so. </li>
	    </ul>
</dd>

</dl>

 <t>
            It is to be noted that LDP Graceful Restart (GR) mechanisms
            defined in <xref target="RFC3478"/> allow keeping the exchanged
            bindings for some time after a session goes down with a peer. We call
            refer to such a state as belonging to a "stale" peer
	    -- i.e. peer, i.e., keeping peer
            bindings from a peer with whom currently there is either no
            connection established or connection is established but the GR session
            is in recovery state.

	    When used in this document, the above terms will refer strictly to
	    the semantics and definitions defined for them. </t></li>
	  </ul>

	<t>
	  A simplified graphical tree representation of base and extended LDP
	  YANG data
	  model models is presented in <xref target="ConsolidatedTree"/>.
	  The meaning of the symbols in these tree diagrams is defined in
	  <xref target="RFC8340"/>.
	</t>

	<t>
	  The actual YANG specification for base and extended modules is
	  captured in <xref target="YANG"/>.
	</t>

          <t>
	    While presenting the YANG tree view and actual specification, this
	    document assumes readers'
	    familiarity readers are familiar with the concepts of YANG
	    modeling, its presentation presentation, and its compilation.
	  </t>

      </section>

      <section numbered="true" toc="default">
      <name>The Complete Tree</name>
	<t> Following
	<t>The following is a complete tree representation of configuration,
	state, notification, and RPC items under LDP base and extended
	modules. </t>

	<figure anchor="ConsolidatedTree">
	  <name>Complete Tree</name>

	    <artwork>

	    <sourcecode type="yangtree">
module: ietf-mpls-ldp
  augment /rt:routing/rt:control-plane-protocols
            /rt:control-plane-protocol:
    +--rw mpls-ldp
       +--rw global
       |  +--rw capability
       |  |  +--rw ldp-ext:end-of-lib {capability-end-of-lib}?
       |  |  |  +--rw ldp-ext:enabled?   boolean
       |  |  +--rw ldp-ext:typed-wildcard-fec
       |  |  |       {capability-typed-wildcard-fec}?
       |  |  |  +--rw ldp-ext:enabled?   boolean
       |  |  +--rw ldp-ext:upstream-label-assignment
       |  |          {capability-upstream-label-assignment}?
       |  |     +--rw ldp-ext:enabled?   boolean
       |  +--rw graceful-restart
       |  |  +--rw enabled?                  boolean
       |  |  +--rw reconnect-time?           uint16
       |  |  +--rw recovery-time?            uint16
       |  |  +--rw forwarding-holdtime?      uint16
       |  |  +--rw ldp-ext:helper-enabled?   boolean
       |  |          {graceful-restart-helper-mode}?
       |  +--rw lsr-id?
       |  |       rt-types:router-id
       |  +--rw address-families
       |  |  +--rw ipv4!
       |  |  |  +--rw enabled?                           boolean
       |  |  |  +--ro label-distribution-control-mode?   enumeration
       |  |  |  +--ro bindings
       |  |  |  |  +--ro address* [address]
       |  |  |  |  |  +--ro address               inet:ipv4-address
       |  |  |  |  |  +--ro advertisement-type?   advertised-received
       |  |  |  |  |  +--ro peer
       |  |  |  |  |     +--ro lsr-id?           leafref
       |  |  |  |  |     +--ro label-space-id?   leafref
       |  |  |  |  +--ro fec-label* [fec]
       |  |  |  |     +--ro fec     inet:ipv4-prefix
       |  |  |  |     +--ro peer*
       |  |  |  |          [lsr-id label-space-id advertisement-type]
       |  |  |  |        +--ro lsr-id                leafref
       |  |  |  |        +--ro label-space-id        leafref
       |  |  |  |        +--ro advertisement-type
       |  |  |  |        |       advertised-received
       |  |  |  |        +--ro label?
       |  |  |  |        |       rt-types:mpls-label
       |  |  |  |        +--ro used-in-forwarding?   boolean
       |  |  |  +--rw ldp-ext:label-policy
       |  |  |  |  +--rw ldp-ext:advertise
       |  |  |  |  |  +--rw ldp-ext:egress-explicit-null
       |  |  |  |  |  |  +--rw ldp-ext:enabled?   boolean
       |  |  |  |  |  +--rw ldp-ext:prefix-list?
       |  |  |  |  |          prefix-list-ref
       |  |  |  |  +--rw ldp-ext:accept
       |  |  |  |  |  +--rw ldp-ext:prefix-list?   prefix-list-ref
       |  |  |  |  +--rw ldp-ext:assign
       |  |  |  |          {policy-label-assignment-config}?
       |  |  |  |     +--rw ldp-ext:independent-mode
       |  |  |  |     |  +--rw ldp-ext:prefix-list?   prefix-list-ref
       |  |  |  |     +--rw ldp-ext:ordered-mode
       |  |  |  |             {policy-ordered-label-config}?
       |  |  |  |        +--rw ldp-ext:egress-prefix-list?
       |  |  |  |                prefix-list-ref
       |  |  |  +--rw ldp-ext:transport-address?
       |  |  |          inet:ipv4-address
       |  |  +--rw ldp-ext:ipv6!
       |  |     +--rw ldp-ext:enabled?
       |  |     |       boolean
       |  |     +--rw ldp-ext:label-policy
       |  |     |  +--rw ldp-ext:advertise
       |  |     |  |  +--rw ldp-ext:egress-explicit-null
       |  |     |  |  |  +--rw ldp-ext:enabled?   boolean
       |  |     |  |  +--rw ldp-ext:prefix-list?
       |  |     |  |          prefix-list-ref
       |  |     |  +--rw ldp-ext:accept
       |  |     |  |  +--rw ldp-ext:prefix-list?   prefix-list-ref
       |  |     |  +--rw ldp-ext:assign
       |  |     |          {policy-label-assignment-config}?
       |  |     |     +--rw ldp-ext:independent-mode
       |  |     |     |  +--rw ldp-ext:prefix-list?   prefix-list-ref
       |  |     |     +--rw ldp-ext:ordered-mode
       |  |     |             {policy-ordered-label-config}?
       |  |     |        +--rw ldp-ext:egress-prefix-list?
       |  |     |                prefix-list-ref
       |  |     +--rw ldp-ext:transport-address
       |  |     |       inet:ipv6-address
       |  |     +--ro ldp-ext:label-distribution-control-mode?
       |  |     |       enumeration
       |  |     +--ro ldp-ext:bindings
       |  |        +--ro ldp-ext:address* [address]
       |  |        |  +--ro ldp-ext:address
       |  |        |  |       inet:ipv6-address
       |  |        |  +--ro ldp-ext:advertisement-type?
       |  |        |  |       advertised-received
       |  |        |  +--ro ldp-ext:peer
       |  |        |     +--ro ldp-ext:lsr-id?           leafref
       |  |        |     +--ro ldp-ext:label-space-id?   leafref
       |  |        +--ro ldp-ext:fec-label* [fec]
       |  |           +--ro ldp-ext:fec     inet:ipv6-prefix
       |  |           +--ro ldp-ext:peer*
       |  |                [lsr-id label-space-id advertisement-type]
       |  |              +--ro ldp-ext:lsr-id                leafref
       |  |              +--ro ldp-ext:label-space-id        leafref
       |  |              +--ro ldp-ext:advertisement-type
       |  |              |       advertised-received
       |  |              +--ro ldp-ext:label?
       |  |              |       rt-types:mpls-label
       |  |              +--ro ldp-ext:used-in-forwarding?   boolean
       |  +--rw ldp-ext:forwarding-nexthop
       |  |       {forwarding-nexthop-config}?
       |  |  +--rw ldp-ext:interfaces
       |  |     +--rw ldp-ext:interface* [name]
       |  |        +--rw ldp-ext:name              if:interface-ref
       |  |        +--rw ldp-ext:address-family* [afi]
       |  |           +--rw ldp-ext:afi            identityref
       |  |           +--rw ldp-ext:ldp-disable?   boolean
       |  +--rw ldp-ext:igp-synchronization-delay?   uint16
       +--rw discovery
       |  +--rw interfaces
       |  |  +--rw hello-holdtime?   uint16
       |  |  +--rw hello-interval?   uint16
       |  |  +--rw interface* [name]
       |  |     +--rw name
       |  |     |       if:interface-ref
       |  |     +--ro next-hello?                          uint16
       |  |     +--rw address-families
       |  |     |  +--rw ipv4!
       |  |     |  |  +--rw enabled?                     boolean
       |  |     |  |  +--ro hello-adjacencies
       |  |     |  |  |  +--ro hello-adjacency* [adjacent-address]
       |  |     |  |  |     +--ro adjacent-address
       |  |     |  |  |     |       inet:ipv4-address
       |  |     |  |  |     +--ro flag*               identityref
       |  |     |  |  |     +--ro hello-holdtime
       |  |     |  |  |     |  +--ro adjacent?     uint16
       |  |     |  |  |     |  +--ro negotiated?   uint16
       |  |     |  |  |     |  +--ro remaining?    uint16
       |  |     |  |  |     +--ro next-hello?         uint16
       |  |     |  |  |     +--ro statistics
       |  |     |  |  |     |  +--ro discontinuity-time
       |  |     |  |  |     |  |       yang:date-and-time
       |  |     |  |  |     |  +--ro hello-received?
       |  |     |  |  |     |  |       yang:counter64
       |  |     |  |  |     |  +--ro hello-dropped?
       |  |     |  |  |     |          yang:counter64
       |  |     |  |  |     +--ro peer
       |  |     |  |  |        +--ro lsr-id?           leafref
       |  |     |  |  |        +--ro label-space-id?   leafref
       |  |     |  |  +--rw ldp-ext:transport-address?   union
       |  |     |  +--rw ldp-ext:ipv6!
       |  |     |     +--rw ldp-ext:enabled?             boolean
       |  |     |     +--ro ldp-ext:hello-adjacencies
       |  |     |     |  +--ro ldp-ext:hello-adjacency*
       |  |     |     |          [adjacent-address]
       |  |     |     |     +--ro ldp-ext:adjacent-address
       |  |     |     |     |       inet:ipv6-address
       |  |     |     |     +--ro ldp-ext:flag*
       |  |     |     |     |       identityref
       |  |     |     |     +--ro ldp-ext:hello-holdtime
       |  |     |     |     |  +--ro ldp-ext:adjacent?     uint16
       |  |     |     |     |  +--ro ldp-ext:negotiated?   uint16
       |  |     |     |     |  +--ro ldp-ext:remaining?    uint16
       |  |     |     |     +--ro ldp-ext:next-hello?         uint16
       |  |     |     |     +--ro ldp-ext:statistics
       |  |     |     |     |  +--ro ldp-ext:discontinuity-time
       |  |     |     |     |  |       yang:date-and-time
       |  |     |     |     |  +--ro ldp-ext:hello-received?
       |  |     |     |     |  |       yang:counter64
       |  |     |     |     |  +--ro ldp-ext:hello-dropped?
       |  |     |     |     |          yang:counter64
       |  |     |     |     +--ro ldp-ext:peer
       |  |     |     |        +--ro ldp-ext:lsr-id?          leafref
       |  |     |     |        +--ro ldp-ext:label-space-id?  leafref
       |  |     |     +--rw ldp-ext:transport-address?   union
       |  |     +--rw ldp-ext:hello-holdtime?              uint16
       |  |     |       {per-interface-timer-config}?
       |  |     +--rw ldp-ext:hello-interval?              uint16
       |  |     |       {per-interface-timer-config}?
       |  |     +--rw ldp-ext:igp-synchronization-delay?   uint16
       |  |             {per-interface-timer-config}?
       |  +--rw targeted
       |     +--rw hello-holdtime?     uint16
       |     +--rw hello-interval?     uint16
       |     +--rw hello-accept
       |     |  +--rw enabled?                 boolean
       |     |  +--rw ldp-ext:neighbor-list?   neighbor-list-ref
       |     |          {policy-targeted-discovery-config}?
       |     +--rw address-families
       |        +--rw ipv4!
       |        |  +--ro hello-adjacencies
       |        |  |  +--ro hello-adjacency*
       |        |  |          [local-address adjacent-address]
       |        |  |     +--ro local-address       inet:ipv4-address
       |        |  |     +--ro adjacent-address    inet:ipv4-address
       |        |  |     +--ro flag*               identityref
       |        |  |     +--ro hello-holdtime
       |        |  |     |  +--ro adjacent?     uint16
       |        |  |     |  +--ro negotiated?   uint16
       |        |  |     |  +--ro remaining?    uint16
       |        |  |     +--ro next-hello?         uint16
       |        |  |     +--ro statistics
       |        |  |     |  +--ro discontinuity-time
       |        |  |     |  |       yang:date-and-time
       |        |  |     |  +--ro hello-received?
       |        |  |     |  |       yang:counter64
       |        |  |     |  +--ro hello-dropped?
       |        |  |     |          yang:counter64
       |        |  |     +--ro peer
       |        |  |        +--ro lsr-id?           leafref
       |        |  |        +--ro label-space-id?   leafref
       |        |  +--rw target* [adjacent-address]
       |        |     +--rw adjacent-address    inet:ipv4-address
       |        |     +--rw enabled?            boolean
       |        |     +--rw local-address?      inet:ipv4-address
       |        +--rw ldp-ext:ipv6!
       |           +--ro ldp-ext:hello-adjacencies
       |           |  +--ro ldp-ext:hello-adjacency*
       |           |          [local-address adjacent-address]
       |           |     +--ro ldp-ext:local-address
       |           |     |       inet:ipv6-address
       |           |     +--ro ldp-ext:adjacent-address
       |           |     |       inet:ipv6-address
       |           |     +--ro ldp-ext:flag*
       |           |     |       identityref
       |           |     +--ro ldp-ext:hello-holdtime
       |           |     |  +--ro ldp-ext:adjacent?     uint16
       |           |     |  +--ro ldp-ext:negotiated?   uint16
       |           |     |  +--ro ldp-ext:remaining?    uint16
       |           |     +--ro ldp-ext:next-hello?         uint16
       |           |     +--ro ldp-ext:statistics
       |           |     |  +--ro ldp-ext:discontinuity-time
       |           |     |  |       yang:date-and-time
       |           |     |  +--ro ldp-ext:hello-received?
       |           |     |  |       yang:counter64
       |           |     |  +--ro ldp-ext:hello-dropped?
       |           |     |          yang:counter64
       |           |     +--ro ldp-ext:peer
       |           |        +--ro ldp-ext:lsr-id?           leafref
       |           |        +--ro ldp-ext:label-space-id?   leafref
       |           +--rw ldp-ext:target* [adjacent-address]
       |              +--rw ldp-ext:adjacent-address
       |              |       inet:ipv6-address
       |              +--rw ldp-ext:enabled?            boolean
       |              +--rw ldp-ext:local-address?
       |                      inet:ipv6-address
       +--rw peers
          +--rw authentication
          |  +--rw (authentication-type)?
          |     +--:(password)
          |     |  +--rw key?                 string
          |     |  +--rw crypto-algorithm?    identityref
          |     +--:(ldp-ext:key-chain) {key-chain}?
          |        +--rw ldp-ext:key-chain?   key-chain:key-chain-ref
          +--rw session-ka-holdtime?                       uint16
          +--rw session-ka-interval?                       uint16
          +--rw peer* [lsr-id label-space-id]
          |  +--rw lsr-id                         rt-types:router-id
          |  +--rw label-space-id                 uint16
          |  +--rw authentication
          |  |  +--rw (authentication-type)?
          |  |     +--:(password)
          |  |     |  +--rw key?                 string
          |  |     |  +--rw crypto-algorithm?    identityref
          |  |     +--:(ldp-ext:key-chain) {key-chain}?
          |  |        +--rw ldp-ext:key-chain?
          |  |                key-chain:key-chain-ref
          |  +--rw address-families
          |  |  +--rw ipv4!
          |  |  |  +--ro hello-adjacencies
          |  |  |  |  +--ro hello-adjacency*
          |  |  |  |          [local-address adjacent-address]
          |  |  |  |     +--ro local-address       inet:ipv4-address
          |  |  |  |     +--ro adjacent-address    inet:ipv4-address
          |  |  |  |     +--ro flag*               identityref
          |  |  |  |     +--ro hello-holdtime
          |  |  |  |     |  +--ro adjacent?     uint16
          |  |  |  |     |  +--ro negotiated?   uint16
          |  |  |  |     |  +--ro remaining?    uint16
          |  |  |  |     +--ro next-hello?         uint16
          |  |  |  |     +--ro statistics
          |  |  |  |     |  +--ro discontinuity-time
          |  |  |  |     |  |       yang:date-and-time
          |  |  |  |     |  +--ro hello-received?
          |  |  |  |     |  |       yang:counter64
          |  |  |  |     |  +--ro hello-dropped?
          |  |  |  |     |          yang:counter64
          |  |  |  |     +--ro interface?          if:interface-ref
          |  |  |  +--rw ldp-ext:label-policy
          |  |  |     +--rw ldp-ext:advertise
          |  |  |     |  +--rw ldp-ext:prefix-list?   prefix-list-ref
          |  |  |     +--rw ldp-ext:accept
          |  |  |        +--rw ldp-ext:prefix-list?   prefix-list-ref
          |  |  +--rw ldp-ext:ipv6!
          |  |     +--ro ldp-ext:hello-adjacencies
          |  |     |  +--ro ldp-ext:hello-adjacency*
          |  |     |          [local-address adjacent-address]
          |  |     |     +--ro ldp-ext:local-address
          |  |     |     |       inet:ipv6-address
          |  |     |     +--ro ldp-ext:adjacent-address
          |  |     |     |       inet:ipv6-address
          |  |     |     +--ro ldp-ext:flag*
          |  |     |     |       identityref
          |  |     |     +--ro ldp-ext:hello-holdtime
          |  |     |     |  +--ro ldp-ext:adjacent?     uint16
          |  |     |     |  +--ro ldp-ext:negotiated?   uint16
          |  |     |     |  +--ro ldp-ext:remaining?    uint16
          |  |     |     +--ro ldp-ext:next-hello?         uint16
          |  |     |     +--ro ldp-ext:statistics
          |  |     |     |  +--ro ldp-ext:discontinuity-time
          |  |     |     |  |       yang:date-and-time
          |  |     |     |  +--ro ldp-ext:hello-received?
          |  |     |     |  |       yang:counter64
          |  |     |     |  +--ro ldp-ext:hello-dropped?
          |  |     |     |          yang:counter64
          |  |     |     +--ro ldp-ext:interface?
          |  |     |             if:interface-ref
          |  |     +--rw ldp-ext:label-policy
          |  |        +--rw ldp-ext:advertise
          |  |        |  +--rw ldp-ext:prefix-list?   prefix-list-ref
          |  |        +--rw ldp-ext:accept
          |  |           +--rw ldp-ext:prefix-list?   prefix-list-ref
          |  +--ro label-advertisement-mode
          |  |  +--ro local?        label-adv-mode
          |  |  +--ro peer?         label-adv-mode
          |  |  +--ro negotiated?   label-adv-mode
          |  +--ro next-keep-alive?               uint16
          |  +--ro received-peer-state
          |  |  +--ro graceful-restart
          |  |  |  +--ro enabled?          boolean
          |  |  |  +--ro reconnect-time?   uint16
          |  |  |  +--ro recovery-time?    uint16
          |  |  +--ro capability
          |  |     +--ro end-of-lib
          |  |     |  +--ro enabled?   boolean
          |  |     +--ro typed-wildcard-fec
          |  |     |  +--ro enabled?   boolean
          |  |     +--ro upstream-label-assignment
          |  |        +--ro enabled?   boolean
          |  +--ro session-holdtime
          |  |  +--ro peer?         uint16
          |  |  +--ro negotiated?   uint16
          |  |  +--ro remaining?    uint16
          |  +--ro session-state?                 enumeration
          |  +--ro tcp-connection
          |  |  +--ro local-address?    inet:ip-address
          |  |  +--ro local-port?       inet:port-number
          |  |  +--ro remote-address?   inet:ip-address
          |  |  +--ro remote-port?      inet:port-number
          |  +--ro up-time?
          |  |       rt-types:timeticks64
          |  +--ro statistics
          |  |  +--ro discontinuity-time          yang:date-and-time
          |  |  +--ro received
          |  |  |  +--ro total-octets?          yang:counter64
          |  |  |  +--ro total-messages?        yang:counter64
          |  |  |  +--ro address?               yang:counter64
          |  |  |  +--ro address-withdraw?      yang:counter64
          |  |  |  +--ro initialization?        yang:counter64
          |  |  |  +--ro keepalive?             yang:counter64
          |  |  |  +--ro label-abort-request?   yang:counter64
          |  |  |  +--ro label-mapping?         yang:counter64
          |  |  |  +--ro label-release?         yang:counter64
          |  |  |  +--ro label-request?         yang:counter64
          |  |  |  +--ro label-withdraw?        yang:counter64
          |  |  |  +--ro notification?          yang:counter64
          |  |  +--ro sent
          |  |  |  +--ro total-octets?          yang:counter64
          |  |  |  +--ro total-messages?        yang:counter64
          |  |  |  +--ro address?               yang:counter64
          |  |  |  +--ro address-withdraw?      yang:counter64
          |  |  |  +--ro initialization?        yang:counter64
          |  |  |  +--ro keepalive?             yang:counter64
          |  |  |  +--ro label-abort-request?   yang:counter64
          |  |  |  +--ro label-mapping?         yang:counter64
          |  |  |  +--ro label-release?         yang:counter64
          |  |  |  +--ro label-request?         yang:counter64
          |  |  |  +--ro label-withdraw?        yang:counter64
          |  |  |  +--ro notification?          yang:counter64
          |  |  +--ro total-addresses?            uint32
          |  |  +--ro total-labels?               uint32
          |  |  +--ro total-fec-label-bindings?   uint32
          |  +--rw ldp-ext:admin-down?            boolean
          |  |       {per-peer-admin-down}?
          |  +--rw ldp-ext:graceful-restart
          |  |       {per-peer-graceful-restart-config}?
          |  |  +--rw ldp-ext:enabled?          boolean
          |  |  +--rw ldp-ext:reconnect-time?   uint16
          |  |  +--rw ldp-ext:recovery-time?    uint16
          |  +--rw ldp-ext:session-ka-holdtime?   uint16
          |  |       {per-peer-session-attributes-config}?
          |  +--rw ldp-ext:session-ka-interval?   uint16
          |          {per-peer-session-attributes-config}?
          +--rw ldp-ext:session-downstream-on-demand
          |       {session-downstream-on-demand-config}?
          |  +--rw ldp-ext:enabled?     boolean
          |  +--rw ldp-ext:peer-list?   peer-list-ref
          +--rw ldp-ext:dual-stack-transport-preference
                  {peers-dual-stack-transport-preference}?
             +--rw ldp-ext:max-wait?      uint16
             +--rw ldp-ext:prefer-ipv4!
                +--rw ldp-ext:peer-list?   peer-list-ref

  rpcs:
    +---x mpls-ldp-clear-peer
    |   +---w input
    |       +---w protocol-name?    leafref
    |       +---w lsr-id?           leafref
    |       +---w label-space-id?   leafref
    +---x mpls-ldp-clear-hello-adjacency
    |   +---w input
    |       +---w hello-adjacency
    |           +---w protocol-name?    leafref
    |           +---w (hello-adjacency-type)?
    |               +--:(targeted)
    |               |  +---w targeted!
    |               |      +---w target-address?   inet:ip-address
    |               +--:(link)
    |                  +---w link!
    |                      +---w next-hop-interface?  leafref
    |                      +---w next-hop-address?    inet:ip-address
    +---x mpls-ldp-clear-peer-statistics
        +---w input
            +---w protocol-name?    leafref
            +---w lsr-id?           leafref
            +---w label-space-id?   leafref

  notifications:
    +---n mpls-ldp-peer-event
    |   +--ro event-type?   oper-status-event-type
    |   +--ro peer
    |      +--ro protocol-name?    leafref
    |      +--ro lsr-id?           leafref
    |      +--ro label-space-id?   leafref
    +---n mpls-ldp-hello-adjacency-event
    |   +--ro event-type?       oper-status-event-type
    |   +--ro protocol-name?    leafref
    |   +--ro (hello-adjacency-type)?
    |      +--:(targeted)
    |      |  +--ro targeted
    |      |     +--ro target-address?   inet:ip-address
    |      +--:(link)
    |         +--ro link
    |            +--ro next-hop-interface?   if:interface-ref
    |            +--ro next-hop-address?     inet:ip-address
    +---n mpls-ldp-fec-event
        +--ro event-type?      oper-status-event-type
        +--ro protocol-name?   leafref
        +--ro fec?             inet:ip-prefix

	    </artwork>
    </sourcecode>

	  </figure>
      </section>

      <section anchor="section_ldp_cfg" numbered="true" toc="default">
      <name>Configuration</name>

	<t> This specification defines the configuration parameters for base
	LDP as specified in <xref target="RFC5036"/> and LDP IPv6 <xref
	target="RFC7552"/>. Moreover, it incorporates provisions to enable LDP
	Capabilities <xref target="RFC5561"/>, target="RFC5561"/> and defines some of the most
	significant and commonly used capabilities such as Typed Wildcard
	FEC <xref target="RFC5918"/>, End-of-LIB
	<xref target="RFC5919"/>, and LDP Upstream
	Label Assignment <xref target="RFC6389"/>. </t>

	<t> This model augments /rt:routing/rt:control-plane-protocols/rt:control-plane-protocol that
	/rt:routing/rt:control-plane-protocols/rt:control-plane-protocol,
	which is defined in <xref target="RFC8349"/> and follows NMDA as
	mentioned earlier.
	</t>

	<t> Following

	<t>The following is the high-level configuration organization for the
	base LDP module: </t>

	<figure anchor="LDPCfgOrgHL">
	  <name>Base Configuration organization</name>
	  <artwork> Organization</name>
          <sourcecode type="yangtree">
        augment /rt:routing/rt:control-plane-protocols:
                  /rt:control-plane-protocol:
          +-- mpls-ldp
              +-- global
              |   +-- ...
              |   +-- ...
              |   +-- address-families
              |   |   +-- ipv4
              |   |       +-- . . .
              |   |       +-- . . .
              |   +-- capability
              |       +-- ...
              |       +-- ...
              +-- discovery
              |   +-- interfaces
              |   |   +-- ...
              |   |   +-- ...
              |   |   +-- interface* [interface]
              |   |       +-- ...
              |   |       +-- address-families
              |   |           +-- ipv4
              |   |               +-- ...
              |   |               +-- ...
              |   +-- targeted
              |       +-- ...
              |       +-- address-families
              |           +-- ipv4
              |                +-               +-- target* [adjacent-address]
              |                  +-                   +-- ...
              |                  +-                   +-- ...
              +-- peers
                  +-- ...
                  +-- ...
                  +-- peer* [lsr-id label-space-id]
                      +-- ...
                      +-- ...

	  </artwork>
  </sourcecode>
	</figure>

	<t> Following

	<t>The following is the high-level configuration organization for the
	extended LDP: LDP module: </t>

	<figure anchor="LDPCfgExtOrgHL">
	  <name>Extended Configuration organization</name>
	  <artwork> Organization</name>

	  <sourcecode type="yangtree">
augment /rt:routing/rt:control-plane-protocols/rt:control-plane-protocol /rt:routing/rt:control-plane-protocols
          /rt:control-plane-protocol
  +-- mpls-ldp
      +-- global
      |   +-- ...
      |   +-- ...
      |   +-- address-families
      |   |   +-- ipv4
      |   |   |   +-- . . .
      |   |   |   +-- . . .
      |   |   |   +-- label-policy
      |   |   |       +-- ...
      |   |   |       +-- ...
      |   |   +-- ipv6
      |   |       +-- . . .
      |   |       +-- . . .
      |   |       +-- label-policy
      |   |           +-- ...
      |   |           +-- ...
      |   +-- capability
      |   |   +-- ...
      |   |   +-- ...
      |   +-- discovery
      |       +-- interfaces
      |       |   +-- ...
      |       |   +-- ...
      |       |   +-- interface* [interface]
      |       |       +-- ...
      |       |       +-- address-families
      |       |           +-- ipv4
      |       |           |   +-- ...
      |       |           |   +-- ...
      |       |           +-- ipv6
      |       |               +-- ...
      |       |               +-- ...
      |       +-- targeteted targeted
      |           +-- ...
      |           +-- address-families
      |               +-- ipv6
      |                   +- target* [adjacent-address]
      |                      +- ...
      |                      +- ...
      +-- forwarding-nexthop
      |   +-- ...
      |   +-- ...
      +-- peers
          +-- ...
          +-- ...
          +-- peer*
              +-- ...
              +-- ...
              +-- label-policy
              |   +-- ..
              +-- address-families
                  +-- ipv4
                  |   +-- ...
                  +-- ipv6
                      +-- ...

	  </artwork>
  </sourcecode>
	</figure>

	<t> Given

	<t>Given the configuration hierarchy, the model allows inheritance
	such that an item in a child tree is able to derive value from a
	similar or related item in one of the parents. For instance, hello Hello
	holdtime can be configured per-VRF per VRF or per-VRF-interface, per VRF interface, thus allowing
	inheritance as well flexibility to override with a different value at
	any child level. </t>

	<section numbered="true" toc="default">
	<name>Configuration Hierarchy</name>

	 <t>

	 <t>The LDP module resides under a network-instance and the scope of
	 any LDP configuration defined under this tree is per network-instance
	 (per-VRF). This configuration is further divided into sub categories
	 as follows. </t> follows:</t>

	 <ul>
	   <li>Global parameters</li>
	   <li>Per-address-family parameters</li>
	   <li>LDP Capabilities parameters</li>
	   <li>
	     <t>Hello Discovery parameters</t>
	     <ul>
	       <li>
		 <t>interfaces</t>
		 <ul>
		   <li>Global</li>
		   <li>Per-interface: Global</li>
		   <li>Per-interface: Per-address-family</li>
		 </ul>
	       </li>
	       <li>
		 <t>targeted</t>
		 <ul>
		   <li>Global</li>
		   <li>Per-address-family: Per-target</li>
		 </ul>
	       </li>
	     </ul>
	   </li>
	   <li>
	     <t>Peer parameters</t>
	     <ul>
	       <li>Global</li>
	       <li>Per-peer: Global</li>
	       <li>Per-peer: Per-address-family</li>
	     </ul>
	   </li>
	   <li>Forwarding parameters</li>
	 </ul>

	  <t> Following

	 <t>The following subsections briefly explain these configuration areas. </t>

	    <section numbered="true" toc="default">
	    <name>Global parameters</name> Parameters</name>
	      <t> There are configuration items that are available directly
	      under a VRF instance and do not fall under any other sub tree. Example subtree. An
	      example of such a parameter is an LDP LSR Id that is typically
	      configured per VRF. To keep legacy LDP features and applications
	      working in an LDP IPv4 networks network with this model, this document
	      recommends an operator to pick a routable IPv4 unicast address
	      (within a routing domain) as an LSR Id. </t>
	    </section>

	    <section numbered="true" toc="default">
	    <name>Capabilities parameters</name> Parameters</name>
	      <t> This container falls under the global tree and holds the LDP
	      capabilities that are to be enabled for certain features.  By
	      default, an LDP capability is disabled unless explicitly
	      enabled. These capabilities are typically used to negotiate with
	      LDP peer(s) the support/non-support related to a feature and its
	      parameters. The scope of a capability enabled under this
	      container applies to all LDP peers in the given VRF
	      instance. There is also a peer level peer-level capability container that
	      is provided to override a capability that is enabled/specified
	      at VRF level. </t>
	    </section>

	    <section numbered="true" toc="default">
	    <name>Per-Address-Family parameters</name> Parameters</name>
	      <t> Any LDP configuration parameter related to an IP address
	      family (AF) whose scope is VRF wide is configured under this
	      tree. The examples of per-AF parameters include enabling LDP for
	      an address family, prefix-list based prefix-list-based label policies, and LDP
	      transport address. </t>
	    </section>

	    <section numbered="true" toc="default">
	    <name>Hello Discovery parameters</name> Parameters</name>
	      <t> This container is used to hold LDP configuration related to
	      the Hello and discovery process for both basic (link) and extended
	      (targeted) discovery. </t>

	      <t> The "interfaces" is a container is used to configure parameters
	      related to VRF interfaces. There are parameters that apply to
	      all interfaces (such as hello timers), Hello timers) as well as parameters
	      that can be configured per-interface. per interface. Hence, an interface list
	      is defined under the "interfaces" container. The model defines
	      parameters to configure per-interface non AF related items, non-AF-related items as
	      well as per-interface per-AF items. The example of the former is
	      interface hello Hello timers, and an example of the latter is enabling
	      hellos for a given AF under an interface. </t>

	      <t> The "targeted" container under a VRF instance allows for the
	      configuration of parameters related to configure LDP targeted discovery related parameters.
	      discovery. Within this container, the "target" list provides a
	      means to configure multiple target addresses to perform extended
	      discovery to a specific destination target, as well as to fine-tune
	      fine tune the per-target parameters. </t>
	    </section>

	    <section numbered="true" toc="default">
	    <name>Peer parameters</name> Parameters</name>

<t>

  This container is used to hold LDP configuration related to LDP sessions and
  peers under a VRF instance.

This container allows to configure for the configuration of parameters that either apply on VRF's to
all peers or a subset (peer-list) of VRF peers. peers in a given VRF.

	      The example of such parameters include includes authentication password,
	      passwords, session KA timers KeepAlive (KA) timers, etc. Moreover, the
	      model also allows per-peer parameter tuning by specifying a
	      "peer" list under the "peers" container. A peer is uniquely
	      identified by its LSR Id. </t>

	      <t> Like per-interface parameters, some per-peer parameters are AF-agnostic (i.e. either non
	      AF agnostic (i.e., either non-AF related or apply to both IP
	      address families), and some that belong to an AF. The example of
	      the former is per-peer session password configuration, whereas
	      the example of the latter is prefix-list based prefix-lis-based label policies
	      (inbound and outbound) that apply to a given peer. </t>
	    </section>

	    <section numbered="true" toc="default">
	    <name>Forwarding parameters</name> Parameters</name>

<t> This container is used to hold configuration used to control LDP
forwarding behavior under a VRF instance.

One example of a configuration under this container is when a user wishes to
enable LDP neighbor discovery on an interface but wishes to disable use of the
same interface as for forwarding nexthop. MPLS packets.

	      This example configuration makes sense only when there are more
	      than one LDP enabled LDP-enabled interfaces towards the a neighbor. </t>
	    </section>

	  </section>

	</section>

      <section anchor="section_ldp_oper" numbered="true" toc="default">
      <name>Operational State</name>

	<t> Operational

	<t>The operational state of LDP can be queried and obtained from
	read-only state containers that fall under the same tree
	(/rt:routing/rt:control-plane-protocols/rt:control-plane-protocol) as
	the configuration. </t>

	  <t> Following

	  <t>The following are main areas for which LDP operational state is defined: </t>

	  <ul>
	    <li> Neighbor Adjacencies </li>
	    <li> Peer </li>
	    <li> Bindings (FEC-label (FEC-Label and address) </li>
	    <li> Capabilities </li>
	  </ul>

	  <section numbered="true" toc="default">
	  <name>Adjacency state</name> State</name>
	    <t> Neighbor adjacencies are per address-family hello per-address-family Hello adjacencies
	    that are formed with neighbors as a result of LDP basic or
	    extended discovery. In terms of organization, there is a source of
	    discovery (e.g. (e.g., interface or target address) along with its
	    associated parameters and one or more discovered neighbors along
	    with neighbor discovery related neighbor-discovery-related parameters. For the basic
	    discovery, there could be more than one discovered neighbor for a
	    given source (interface), whereas there is at most one discovered
	    neighbor for an extended discovery source (local-address and
	    target-address).  It is also to be noted that the reason for a
	    targeted neighbor adjacency could be either an active source
	    (locally configured targeted) or passive source (to allow any
	    incoming extended/targeted hellos). A neighbor/adjacency record
	    also contains session-state session state that helps highlight whether a given
	    adjacency has progressed to the subsequent session level or to
	    eventual peer level. </t>

	    <t> Following

	    <t>The following captures high level high-level tree hierarchy for neighbor
	    adjacency state. The tree is shown for ipv4 address-family only; a
	    similar tree exists for ipv6 address-family as well. </t>

	    <figure anchor="LDPAdjState">

	      <name>Adjacency state</name>
	      <artwork> State</name>
	      <sourcecode type="yangtree">
+--rw mpls-ldp!
   +--rw discovery
      +--rw interfaces
      |  +--rw interface* [interface]
      |     +--rw address-families
      |        +--rw ipv4
      |           +--ro hello-adjacencies
      |              +--ro hello-adjacencies* [adjacent-address]
      |                 +--ro adjacent-address
      |                    . . . .
      |                    . . . .
      +--rw targeted
         +--rw address-families
            +--rw ipv4
               +--ro hello-adjacencies
                  +--ro hello-adjacencies*
                  |                  [local-address adjacent-address]
                  +--ro local-address
                     +--ro adjacent-address
                        . . . .
                        . . . .

	      </artwork>
              </sourcecode>
	    </figure>

	  </section>

	  <section numbered="true" toc="default">
	  <name>Peer state</name>
	    <t> Peer related State</name>

	    <t>Peer-related state is presented under a peers tree. This is one
	    of the core state states that provides info on the session related session-related
	    parameters (mode, authentication, KA timeout timeout, etc.), TCP connection
	    info, hello Hello adjacencies for the peer, statistics related to
	    messages and bindings, and capabilities exchange info. </t>

	    <t> Following

	    <t>The following captures high level high-level tree hierarchy for peer
	    state. The peer's hello Hello adjacencies tree is shown for ipv4
	    address-family only; a similar tree exists for ipv6 address-family
	    as well.</t>

	    <figure anchor="LDPPeerState">
	      <name>Peer state</name>
	      <artwork> State</name>
	      <sourcecode type="yangtree">
+--rw mpls-ldp!
   +--rw peers
      +--rw peer* [lsr-id label-space-id]
         +--rw lsr-id
         +--rw label-space-id
         +--ro label-advertisement-mode
         +--ro session-state
         +--ro tcp-connection
         +--ro session-holdtime?
         +--ro up-time
         +-- . . . .
         +--ro address-families
         |  +--ro ipv4
         |     +--ro hello-adjacencies
         |        +--ro hello-adjacencies*
         |                        [local-address adjacent-address]
         |           . . . .
         |           . . . .
         +--ro received-peer-state
         |  +--ro . . . .
         |  +--ro capability
         |     +--ro . . . .
         +--ro statistics
            +-- . . . .
            +-- received
            |   +-- ...
            +-- sent
                +-- ...

	      </artwork>
      </sourcecode>
	    </figure>

	  </section>

	  <section numbered="true" toc="default">
	  <name>Bindings state</name> State</name>
	    <t> Binding Bindings state provides information on LDP FEC-label FEC-Label bindings
	    as well as address binding bindings for both inbound (received) as well as
	    outbound (advertised) direction. FEC-label FEC-Label bindings are presented as
	    in a FEC-centric view, and address bindings are presented as in an
	    address-centric view: </t>

	    <figure anchor="ExampleBndg">
	      <name>Example Bindings</name>
	      <artwork>
      <sourcecode>
     FEC-Label bindings:
         FEC 203.0.113.1/32:
           advertised: local-label 16000
             peer 192.0.2.1:0
             peer 192.0.2.2:0
             peer 192.0.2.3:0
           received:
             peer 192.0.2.1:0, label 16002, used-in-forwarding=Yes
             peer 192.0.2.2:0, label 17002, used-in-forwarding=No
         FEC 203.0.113.2/32:
            . . . .
         FEC 198.51.100.0/24:
            . . . .
         FEC 2001:db8:0:2::
            . . . .
         FEC 2001:db8:0:3::
            . . . .

     Address bindings:
         Addr 192.0.2.10:
            advertised
         Addr 2001:db8:0:10::
            advertised

         Addr 192.0.2.1:
           received, peer 192.0.2.1:0
         Addr 192.0.2.2:
           received, peer 192.0.2.2:0
         Addr 192.0.2.3:
           received, peer 192.0.2.3:0
         Addr 2001:db8:0:2::
           received, peer 192.0.2.2:0
         Addr 2001:db8:0:3::
           received, peer 192.0.2.3:0

	      </artwork>
              </sourcecode>
	    </figure>

	    <t> Note that all local addresses are advertised to all peers and hence peers;
	    hence, there is no need to provide per-peer information for local address
	    advertisement. Furthermore, note that it is easy to derive a
	    peer-centric view for the bindings from the information already
	    provided in this model.
	    </t>

	    <t> Following

	    <t>The following captures high level high-level tree hierarchy for bindings
	    state. The tree shown below is for ipv4 address-family only; a
	    similar tree exists for ipv6 address-family as well. </t>

	    <figure anchor="LDPBndgState">
	      <name>Bindings state</name>
	      <artwork> State</name>
	      <sourcecode type="yangtree">
+--rw mpls-ldp!
   +--rw global
      +--rw address-families
         +--rw ipv4
            +--ro bindings
               +--ro address* [address]
               |  +--ro address (ipv4-address or ipv6-address)
               |  +--ro advertisement-type?   advertised-received
               |  +--ro peer?        leafref
               +--ro fec-label* [fec]
                  +--ro fec     (ipv4-prefix or ipv6-prefix)
                  +--ro peer* [peer advertisement-type]
                     +--ro peer                  leafref
                     +--ro advertisement-type? advertised-received
                     +--ro label?                mpls:mpls-label
                     +--ro used-in-forwarding?   boolean

	      </artwork>
      </sourcecode>
    </figure>

	  </section>

	  <section numbered="true" toc="default">
	  <name>Capabilities state</name> State</name>
	    <t> LDP capabilities state comprise comprises two types of information - information:
	    global information (such as timer etc.), timer, etc.) and per-peer
	    information. </t>

	    <t> Following

	    <t>The following captures high level high-level tree hierarchy for LDP capabilities state. </t>
	    <figure anchor="LDPCapState">
	      <name>Capabilities state</name>
	      <artwork> State</name>
	      <sourcecode type="yangtree">
   +--rw mpls-ldp!
      +--rw peers
         +--rw peer* [lsr-id label-space-id]
            +--rw lsr-id    yang:dotted-quad
            +--rw label-space-id
            +--ro received-peer-state
               +--ro capability
                  +--ro . . . .
                  +--ro . . . .

	      </artwork>
      </sourcecode>
	    </figure>

	  </section>
	</section>

	<section anchor="section_ldp_notif" numbered="true" toc="default">
      <name>Notifications</name>
	<t> This model defines a list of notifications to inform the client of
	important events detected during the protocol operation.  These events
	include events related to changes in the operational state of an LDP
	peer, hello Hello adjacency, and FEC FEC, etc. It is to be noted that an LDP FEC
	is treated as operational (up) as long as it has at least 1 NHLFE (Next one Next Hop
	Label Forwarding Entry) Entry (NHLFE) with an outgoing label. </t>

	<t> A simplified graphical representation of the data model for LDP notifications is shown in <xref target="ConsolidatedTree"/>. </t>

      </section>

      <section anchor="section_ldp_action" numbered="true" toc="default">
      <name>Action</name>

	<t> This model defines a list of rpcs that allow performing an action
	or executing a command on the protocol. For example, it allows to clear (reset) for the
	clearing (resetting) of LDP peers, hello-adjacencies, and
	statistics. The model makes an effort to provide a different level of
	control so that a user is able to either clear all, or clear all for a
	given type, or clear a specific entity. </t>

	<t> A simplified graphical representation of the data model for LDP actions is shown in <xref target="ConsolidatedTree"/>. </t>
      </section>

      <section anchor="YANG" numbered="true" toc="default">
      <name>YANG Specification</name>
	<t> Following
	<t>The following sections specify the actual YANG (module) specification
	for LDP constructs defined earlier in the document. </t>

	<section anchor="base_yang" numbered="true" toc="default">
	<name>Base</name>

	  <t>
	    This YANG module imports types defined in <xref
	    target="RFC6991"/>, <xref target="RFC8349"/>, target="RFC8177"/>, <xref
	    target="RFC8294"/>, <xref target="RFC8343"/>, <xref
	    target="RFC8344"/>, <xref target="RFC8349"/>, and <xref target="RFC8344"/>.
	    target="RFC9067"/>.
	  </t>

	  <figure anchor="BASE-YANG-FILE">
	    <name>LDP base module</name>
	  <artwork>

<![CDATA[
<CODE BEGINS> file "ietf-mpls-ldp@2020-02-25.yang"

// RFC Editor: replace the above date 2020-02-25 with the date of
// publication and remove this note. Base Module</name>

	  <sourcecode name="ietf-mpls-ldp@2022-03-07.yang" type="yang" markers="true"><![CDATA[
module ietf-mpls-ldp {
  yang-version 1.1;
  namespace "urn:ietf:params:xml:ns:yang:ietf-mpls-ldp";
  prefix "ldp"; ldp;

  import ietf-inet-types {
    prefix "inet"; inet;
    reference
      "RFC 6991: Common YANG Data Types";
  }
  import ietf-yang-types {
    prefix "yang"; yang;
    reference
      "RFC 6991: Common YANG Data Types";
  }
  import ietf-routing {
    prefix "rt"; rt;
    reference
      "RFC 8349: A YANG Data Model for Routing Management (NMDA
       version)";
  }
  import ietf-routing-types {
    prefix "rt-types"; rt-types;
    reference
      "RFC 8294: Common YANG Data Types for the Routing Area";
  }
  import ietf-interfaces {
    prefix "if"; if;
    reference
      "RFC 8343: A YANG Data Model for Interface Management";
  }
  import ietf-ip {
    prefix "ip"; ip;
    reference
      "RFC 7277: 8344: A YANG Data Model for IP Management";
  }
  import ietf-key-chain {
    prefix "key-chain"; key-chain;
    reference
      "RFC 8177: YANG Data Model for Key Chains";
  }

  organization
    "IETF MPLS Working Group";
  contact
    "WG Web:   <http://tools.ietf.org/wg/mpls/>   <https://datatracker.ietf.org/wg/mpls/>
     WG List:  <mailto:mpls@ietf.org>

     Editor:   Kamran Raza
               <mailto:skraza@cisco.com>

     Editor:

     Author:   Rajiv Asati
               <mailto:rajiva@cisco.com>

     Editor:

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

     Editor:

     Author:   Santosh Esale
               <mailto:sesale@juniper.net>

     Editor: Easale
               <mailto:santosh_easale@berkeley.edu>

     Author:   Xia Chen
               <mailto:jescia.chenxia@huawei.com>

     Editor:

     Author:   Himanshu Shah
               <mailto:hshah@ciena.com>";
  description
    "This YANG module defines the essential components for the
     management of Multi-Protocol Multiprotocol Label Switching (MPLS) Label
     Distribution Protocol (LDP).  It is also the base model to
     be augmented for Multipoint LDP (mLDP).

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

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

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

     // RFC Editor: replace XXXX with actual RFC number and remove
     // this note

  revision 2020-02-25 2022-03-7 {
    description
      "Initial revision.";
    reference
      "RFC XXXX: 9070: YANG Data Model for MPLS LDP.";
      // RFC Editor: replace XXXX with actual RFC number and remove
      // this note LDP";
  }

  /*
   * Typedefs
   */

  typedef advertised-received {
    type enumeration {
      enum advertised {
        description
          "Advertised information.";
      }
      enum received {
        description
          "Received information.";
      }
    }
    description
      "Received or advertised.";
  }

  typedef downstream-upstream {
    type enumeration {
      enum downstream {
        description
          "Downstream information.";
      }
      enum upstream {
        description
          "Upstream information.";
      }
    }
    description
      "Downstream or upstream.";
  }

  typedef label-adv-mode {
    type enumeration {
      enum downstream-unsolicited {
        description
          "Downstream Unsolicited.";
      }
      enum downstream-on-demand {
        description
          "Downstream on Demand.";
      }
    }
    description
      "Label Advertisement Mode.";
  }

  typedef oper-status-event-type {
    type enumeration {
      enum up {
        value 1;
        description
          "Operational status changed to up.";
      }
      enum down {
        value 2;
        description
          "Operational status changed to down.";
      }
    }
    description
      "Operational status event type for notifications.";
  }

  /*
   * Identities
   */

  identity mpls-ldp {
    base rt:control-plane-protocol;
    description
      "LDP protocol.";
    reference
      "RFC 5036: LDP Specification";
  }

  identity adjacency-flag-base {
    description
      "Base type for adjacency flags.";
  }

  identity adjacency-flag-active {
    base adjacency-flag-base;
    description
      "This adjacency is configured and actively created.";
  }

  identity adjacency-flag-passive {
    base adjacency-flag-base;
    description
      "This adjacency is not configured and passively accepted.";
  }

  /*
   * Groupings
   */

  grouping adjacency-state-attributes {
    description
      "The operational state attributes of an LDP Hello adjacency,
       which can used for basic and extended discoveris, discoveries, in IPv4 and
       IPv6 address families.";
    leaf-list flag {
      type identityref {
        base adjacency-flag-base;
      }
      description
        "On
        "One or more flags to indicate whether the adjacency is
         actively created, passively accepted, or both.";
    }
    container hello-holdtime {
      description
        "Containing Hello holdtime state information.";
      leaf adjacent {
        type uint16;
        units seconds; "seconds";
        description
          "The holdtime value learned from the adjacent LSR.";
      }
      leaf negotiated {
        type uint16;
        units seconds; "seconds";
        description
          "The holdtime negotiated between this LSR and the adjacent
           LSR.";
      }
      leaf remaining {
        type uint16;
        units seconds; "seconds";
        description
          "The time remaining until the holdtime timer expires.";
      }
    }
    leaf next-hello {
      type uint16;
      units seconds; "seconds";
      description
        "The time when the next Hello message will be sent.";
    }
    container statistics {
      description
        "Statistics objects.";
      leaf discontinuity-time {
        type yang:date-and-time;
        mandatory true;
        description
          "The time on the most recent occasion at which any one or
           more of this interface's counters suffered a
           discontinuity.  If no such discontinuities have occurred
           since the last re-initialization of the local management
           subsystem, then this node contains the time the local
           management subsystem re-initialized itself.";
      }
      leaf hello-received {
        type yang:counter64;
        description
          "The number of Hello messages received.";
      }
      leaf hello-dropped {
        type yang:counter64;
        description
          "The number of Hello messages dropped.";
      }
    } // statistics
  } // adjacency-state-attributes

  grouping basic-discovery-timers {
    description
      "The timer attributes for basic discovery, used in the
       per-interface setting and in the all-interface setting.";
    leaf hello-holdtime {
      type uint16 {
        range 15..3600; "15..3600";
      }
      units seconds; "seconds";
      description
        "The time interval for which a an LDP link Hello adjacency
         is maintained in the absence of link Hello messages from
         the LDP neighbor.
         This leaf may be configured at the per-interface level or
         the global level, with precedence given to the value at the
         per-interface level.  If the leaf is not configured at
         either level, the default value at the global level is
         used.";
    }
    leaf hello-interval {
      type uint16 {
        range 5..1200; "5..1200";
      }
      units seconds; "seconds";
      description
        "The interval between consecutive LDP link Hello messages
         used in basic LDP discovery.
         This leaf may be configured at the per-interface level or
         the global level, with precedence given to the value at the
         per-interface level.  If the leaf is not configured at
         either level, the default value at the global level is
         used.";
    }
  } // basic-discovery-timers

  grouping binding-address-state-attributes {
    description
      "Operational state attributes of an address binding, used in
       IPv4 and IPv6 address families.";
    leaf advertisement-type {
      type advertised-received;
      description
        "Received or advertised.";
    }
    container peer {
      when "../advertisement-type = 'received'" {
        description
          "Applicable for received address.";
      }
      description
        "LDP peer from which this address is received.";
      uses ldp-peer-ref-from-binding;
    }
  } // binding-address-state-attributes

  grouping binding-label-state-attributes {
    description
      "Operational state attributes for a FEC-label FEC-Label binding, used in
       IPv4 and IPv6 address families.";
    list peer {
      key "lsr-id label-space-id advertisement-type";
      description
        "List of advertised and received peers.";
      uses ldp-peer-ref-from-binding {
        description
          "The LDP peer from which this binding is received, or to
           which this binding is advertised.
           The peer is identified by its LDP ID, which consists of
           the LSR ID Id and the Label Space ID."; label space Id.";
      }
      leaf advertisement-type {
        type advertised-received;
        description
          "Received or advertised.";
      }
      leaf label {
        type rt-types:mpls-label;
        description
          "Advertised (outbound) or received (inbound)
           label.";
      }
      leaf used-in-forwarding {
        type boolean;
        description
          "'true' if the label is used in forwarding.";
      }
    } // peer
  } // binding-label-state-attributes

  grouping graceful-restart-attributes-per-peer {
    description
      "Per peer
      "Per-peer graceful restart attributes.
       On the local side, these attributes are configuration and
       operational state data. One  On the peer side, these attributes
       are operational state data received from the peer.";
    container graceful-restart {
      description
        "Attributes for graceful restart.";
      leaf enabled {
        type boolean;
        description
          "Enable or disable graceful restart.
           This leaf may be configured at the per-peer level or the
           global level, with precedence given to the value at the
           per-peer level.  If the leaf is not configured at either
           level, the default value at the global level is used.";
      }
      leaf reconnect-time {
        type uint16 {
          range 10..1800; "10..1800";
        }
        units seconds; "seconds";
        description
          "Specifies the time interval that the remote LDP peer
           must wait for the local LDP peer to reconnect after the
           remote peer detects the LDP communication failure.
           This leaf may be configured at the per-peer level or the
           global level, with precedence given to the value at the
           per-peer level.  If the leaf is not configured at either
           level, the default value at the global level is used.";
      }
      leaf recovery-time {
        type uint16 {
          range 30..3600; "30..3600";
        }
        units seconds; "seconds";
        description
          "Specifies the time interval, in seconds, that the remote
           LDP peer preserves its MPLS forwarding state after
           receiving the Initialization message from the restarted
           local LDP peer.
           This leaf may be configured at the per-peer level or the
           global level, with precedence given to the value at the
           per-peer level.  If the leaf is not configured at either
           level, the default value at the global level is used.";
      }
    } // graceful-restart
  } // graceful-restart-attributes-per-peer

  grouping ldp-interface-ref {
    description
      "Defining a reference to an LDP interface.";
    leaf name {
      type if:interface-ref;
      must "(/if:interfaces/if:interface[if:name=current()]/ip:ipv4)" '(/if:interfaces/if:interface[if:name=current()]/ip:ipv4)'
         + " ' or " '
         + "(/if:interfaces/if:interface[if:name=current()]/ip:ipv6)" '(/if:interfaces/if:interface[if:name=current()]/ip:ipv6)'
      {
        description
          "Interface is IPv4 or IPv6.";
      }
      description
        "The name of an LDP interface.";
    }
  }

  grouping ldp-peer-ref-absolute {
    description
      "An absolute reference to an LDP peer, by the LDP ID, which
       consists of the LSR ID Id and the Label Space ID."; label space Id.";
    leaf protocol-name {
      type leafref {
        path "/rt:routing/rt:control-plane-protocols/"
           + "rt:control-plane-protocol/rt:name";
      }
      description
        "The name of the LDP protocol instance.";
    }
    leaf lsr-id {
      type leafref {
        path "/rt:routing/rt:control-plane-protocols/"
           + "rt:control-plane-protocol"
           + "[rt:name=current()/../protocol-name]/"
           + "ldp:mpls-ldp/ldp:peers/ldp:peer/ldp:lsr-id";
      }
      description
        "The LSR ID Id of the peer, as a portion of the peer LDP ID.";
    }
    leaf label-space-id {
      type leafref {
        path "/rt:routing/rt:control-plane-protocols/"
           + "rt:control-plane-protocol"
           + "[rt:name=current()/../protocol-name]/"
           + "ldp:mpls-ldp/ldp:peers/"
           + "ldp:peer[ldp:lsr-id=current()/../lsr-id]/"
           + "ldp:label-space-id";
      }
      description
        "The Label Space ID label space Id of the peer, as a portion of the peer
         LDP ID.";
    }
  } // ldp-peer-ref-absolute

  grouping ldp-peer-ref-from-binding {
    description
      "A relative reference to an LDP peer, by the LDP ID, which
       consists of the LSR ID Id and the Label Space ID."; label space Id.";
    leaf lsr-id {
      type leafref {
        path "../../../../../../../ldp:peers/ldp:peer/ldp:lsr-id";
      }
      description
        "The LSR ID Id of the peer, as a portion of the peer LDP ID.";
    }
    leaf label-space-id {
      type leafref {
        path "../../../../../../../ldp:peers/"
           + "ldp:peer[ldp:lsr-id=current()/../lsr-id]/"
           + "ldp:label-space-id";
      }
      description
        "The Label Space ID label space Id of the peer, as a portion of the peer
         LDP ID.";
    }
  } // ldp-peer-ref-from-binding

  grouping ldp-peer-ref-from-interface {
    description
      "A relative reference to an LDP peer, by the LDP ID, which
       consists of the LSR ID Id and the Label Space ID."; label space Id.";
    container peer {
      description
        "Reference to an LDP peer, by the LDP ID, which consists of
         the LSR ID Id and the Label Space ID."; label space Id.";
      leaf lsr-id {
        type leafref {
          path "../../../../../../../../../ldp:peers/ldp:peer/"
             + "ldp:lsr-id";
        }
        description
          "The LSR ID Id of the peer, as a portion of the peer LDP ID.";
      }
      leaf label-space-id {
        type leafref {
          path "../../../../../../../../../ldp:peers/"
             + "ldp:peer[ldp:lsr-id=current()/../lsr-id]/"
             + "ldp:label-space-id";
        }
        description
          "The Label Space ID label space Id of the peer, as a portion of the peer
           LDP ID.";
      }
    } // peer
  } // ldp-peer-ref-from-interface

  grouping ldp-peer-ref-from-target {
    description
      "A relative reference to an LDP peer, by the LDP ID, which
       consists of the LSR ID Id and the Label Space ID."; label space Id.";
    container peer {
      description
        "Reference to an LDP peer, by the LDP ID, which consists of
         the LSR ID Id and the Label Space ID."; label space Id.";
      leaf lsr-id {
        type leafref {
          path "../../../../../../../../ldp:peers/ldp:peer/"
             + "ldp:lsr-id";
        }
        description
          "The LSR ID Id of the peer, as a portion of the peer LDP ID.";
      }
      leaf label-space-id {
        type leafref {
          path "../../../../../../../../ldp:peers/"
             + "ldp:peer[ldp:lsr-id=current()/../lsr-id]/"
             + "ldp:label-space-id";
        }
        description
          "The Label Space ID label space Id of the peer, as a portion of the peer
           LDP ID.";
      }
    } // peer
  } // ldp-peer-ref-from-target

  grouping peer-attributes {
    description
      "Peer configuration attributes, used in the per-peer setting
       can in the all-peer setting.";
    leaf session-ka-holdtime {
      type uint16 {
        range 45..3600; "45..3600";
      }
      units seconds; "seconds";
      description
        "The time interval after which an inactive LDP session
         terminates and the corresponding TCP session closes.
         Inactivity is defined as not receiving LDP packets from the
         peer.
         This leaf may be configured at the per-peer level or the
         global level, with precedence given to the value at the
         per-peer level.  If the leaf is not configured at either
         level, the default value at the global level is used.";
    }
    leaf session-ka-interval {
      type uint16 {
        range 15..1200; "15..1200";
      }
      units seconds; "seconds";
      description
        "The interval between successive transmissions of keepalive KeepAlive
         packets.  Keepalive packets are only sent in the absence of
         other LDP packets transmitted over the LDP session.
         This leaf may be configured at the per-peer level or the
         global level, with precedence given to the value at the
         per-peer level.  If the leaf is not configured at either
         level, the default value at the global level is used.";
    }
  } // peer-attributes

  grouping peer-authentication {
    description
      "Peer authentication container, used in the per-peer setting
       can in the all-peer setting.";
    container authentication {
      description
        "Containing authentication information.";
      choice authentication-type {
        description
          "Choice of authentication.";
        case password {
          leaf key {
            type string;
            description
              "This leaf specifies the authentication key.  The
               length of the key may be dependent on the
               cryptographic algorithm.";
          }
          leaf crypto-algorithm {
            type identityref {
              base key-chain:crypto-algorithm;
            }
            description
              "Cryptographic algorithm associated with key.";
          }
        }
      }
    }
  } // peer-authentication

  grouping peer-state-derived {
    description
      "The peer state information derived from the LDP protocol
       operations.";
    container label-advertisement-mode {
      config false;
      description
        "Label advertisement mode state.";
      leaf local {
        type label-adv-mode;
        description
          "Local Label Advertisement Mode.";
      }
      leaf peer {
        type label-adv-mode;
        description
          "Peer Label Advertisement Mode.";
      }
      leaf negotiated {
        type label-adv-mode;
        description
          "Negotiated Label Advertisement Mode.";
      }
    }
    leaf next-keep-alive {
      type uint16;
      units seconds; "seconds";
      config false;
      description
        "Time duration from now until sending the next KeepAlive
         message.";
    }
    container received-peer-state {
      config false;
      description
        "Operational state information learned from the peer.";
      uses graceful-restart-attributes-per-peer;
      container capability {
        description
          "Peer capability information.";
        container end-of-lib {
          description
            "Peer's end-of-lib capability.";
          leaf enabled {
            type boolean;
            description
              "'true' if peer's end-of-lib capability is enabled.";
          }
        }
        container typed-wildcard-fec {
          description
            "Peer's typed-wildcard-fec capability.";
          leaf enabled {
            type boolean;
            description
              "'true' if peer's typed-wildcard-fec capability is
                enabled.";
          }
        }
        container upstream-label-assignment {
          description
            "Peer's upstream label assignment capability.";
          leaf enabled {
            type boolean;
            description
              "'true' if peer's upstream label assignment is
               enabled.";
          }
        }
      } // capability
    } // received-peer-state
    container session-holdtime {
      config false;
      description
        "Session holdtime state.";
      leaf peer {
        type uint16;
        units seconds; "seconds";
        description
          "Peer holdtime.";
      }
      leaf negotiated {
        type uint16;
        units seconds; "seconds";
        description
          "Negotiated holdtime.";
      }
      leaf remaining {
        type uint16;
        units seconds; "seconds";
        description
          "Remaining holdtime.";
      }
    } // session-holdtime
    leaf session-state {
      type enumeration {
        enum non-existent {
          description
            "NON EXISTENT state.  Transport disconnected.";
        }
        enum initialized {
          description
            "INITIALIZED state.";
        }
        enum openrec {
          description
            "OPENREC state.";
        }
        enum opensent {
          description
            "OPENSENT state.";
        }
        enum operational {
          description
            "OPERATIONAL state.";
        }
      }
      config false;
      description
        "Representing the operational status of the LDP session.";
      reference
        "RFC5036,
        "RFC 5036: LDP Specification, Sec. 2.5.4.";
    }
    container tcp-connection {
      config false;
      description
        "TCP connection state.";
      leaf local-address {
        type inet:ip-address;
        description
          "Local address.";
      }
      leaf local-port {
        type inet:port-number;
        description
          "Local port number.";
      }
      leaf remote-address {
        type inet:ip-address;
        description
          "Remote address.";
      }
      leaf remote-port {
        type inet:port-number;
        description
          "Remote port number.";
      }
    } // tcp-connection
    leaf up-time {
      type rt-types:timeticks64;
      config false;
      description
        "The number of time ticks (hundredths of a second) since the
         the
         state of the session with the peer changed to
         OPERATIONAL.";
    }
    container statistics {
      config false;
      description
        "Statistics objects.";
      leaf discontinuity-time {
        type yang:date-and-time;
        mandatory true;
        description
          "The time on the most recent occasion at which any one or
           more of this interface's counters suffered a
           discontinuity.  If no such discontinuities have occurred
           since the last re-initialization of the local management
           subsystem, then this node contains the time the local
           management subsystem re-initialized itself.";
      }
      container received {
        description
          "Inbound statistics.";
        uses statistics-peer-received-sent;
      }
      container sent {
        description
          "Outbound statistics.";
        uses statistics-peer-received-sent;
      }
      leaf total-addresses {
        type uint32;
        description
          "The number of learned addresses.";
      }
      leaf total-labels {
        type uint32;
        description
          "The number of learned labels.";
      }
      leaf total-fec-label-bindings {
        type uint32;
        description
          "The number of learned label-address bindings.";
      }
    } // statistics
  } // peer-state-derived

  grouping statistics-peer-received-sent {
    description
      "Inbound and outbound statistic counters.";
    leaf total-octets {
      type yang:counter64;
      description
        "The total number of octets sent or received.";
    }
    leaf total-messages {
      type yang:counter64;
      description
        "The number of messages sent or received.";
    }
    leaf address {
      type yang:counter64;
      description
        "The number of address Address messages sent or received.";
    }
    leaf address-withdraw {
      type yang:counter64;
      description
        "The number of address-withdraw messages sent or received.";
    }
    leaf initialization {
      type yang:counter64;
      description
        "The number of initialization Initialization messages sent or received.";
    }
    leaf keepalive {
      type yang:counter64;
      description
        "The number of keepalive KeepAlive messages sent or received.";
    }
    leaf label-abort-request {
      type yang:counter64;
      description
        "The number of label-abort-request messages sent or
         received.";
    }
    leaf label-mapping {
      type yang:counter64;
      description
        "The number of label-mapping messages sent or received.";
    }
    leaf label-release {
      type yang:counter64;
      description
        "The number of label-release messages sent or received.";
    }
    leaf label-request {
      type yang:counter64;
      description
        "The number of label-request messages sent or received.";
    }
    leaf label-withdraw {
      type yang:counter64;
      description
        "The number of label-withdraw messages sent or received.";
    }
    leaf notification {
      type yang:counter64;
      description
        "The number of notification messages sent or received.";
    }
  } // statistics-peer-received-sent

  /*
   * Configuration data and operational state data nodes
   */

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol" {
    when "derived-from-or-self(rt:type, 'ldp:mpls-ldp')" {
      description
        "This augmentation is only valid for a control-plane control plane
         protocol instance of LDP (type 'mpls-ldp').";
    }
    description
      "LDP augmentation to routing control-plane control plane protocol
       configuration and state.";
    container mpls-ldp {
      must "not (../../rt:control-plane-protocol"
         + "[derived-from-or-self(rt:type, 'ldp:mpls-ldp')]"
         + "[rt:name!=current()/../rt:name])" {
        description
          "Only one LDP instance is allowed.";
      }
      description
        "Containing configuration and operational data for the LDP
         protocol.";
      container global {
        description
          "Global attributes for LDP.";
        container capability {
          description
            "Containing the LDP capability data.  The container is
             used for augmentations.";
          reference
            "RFC5036:
            "RFC 5036: LDP Specification, Sec. 1.5.";
        }
        container graceful-restart {
          description
            "Attributes for graceful restart.";
          leaf enabled {
            type boolean;
            default false; "false";
            description
              "Enable or disable graceful restart.";
          }
          leaf reconnect-time {
            type uint16 {
              range 10..1800; "10..1800";
            }
            units seconds; "seconds";
            default 120; "120";
            description
              "Specifies the time interval that the remote LDP peer
               must wait for the local LDP peer to reconnect after
               the remote peer detects the LDP communication
               failure.";
          }
          leaf recovery-time {
            type uint16 {
              range 30..3600; "30..3600";
            }
            units seconds; "seconds";
            default 120; "120";
            description
              "Specifies the time interval, in seconds, that the
               remote LDP peer preserves its MPLS forwarding state
               after receiving the Initialization message from the
               restarted local LDP peer.";
          }
          leaf forwarding-holdtime {
            type uint16 {
              range 30..3600; "30..3600";
            }
            units seconds; "seconds";
            default 180; "180";
            description
              "Specifies the time interval, in seconds, before the
               termination of the recovery phase.";
          }
        } // graceful-restart
        leaf lsr-id {
          type rt-types:router-id;
          description
            "Specify
            "Specifies the value to act as the LDP LSR ID. Id.
             If this attribute is not specified, LDP uses the router
             ID as determined by the system.";
        }
        container address-families {
          description
            "Per address family confgiration
            "Per-address-family configuration and operational state.
             The address family can be either IPv4 or IPv6.";
          container ipv4 {
            presence "Present if IPv4 is enabled, unless the
                      'enabled' leaf is set to 'false'"; 'false'.";
            description
              "Containing data related to the IPv4 address family.";
            leaf enabled {
              type boolean;
              default true; "true";
              description
                "'false' to disable the address family.";
            }
            leaf label-distribution-control-mode {
              type enumeration {
                enum independent {
                  description
                    "Independent label distribution control.";
                }
                enum ordered {
                  description
                    "Ordered label distribution control.";
                }
              }
              config false;
              description
                "Label distribution control mode.";
              reference
                "RFC5036:
                "RFC 5036: LDP Specification. Sec Specification, Sec. 2.6.";
            }
            // ipv4 bindings
            container bindings {
              config false;
              description
                "LDP address and label binding information.";
              list address {
                key "address";
                description
                  "List of address bindings learned by LDP.";
                leaf address {
                  type inet:ipv4-address;
                  description
                    "The IPv4 address learned from an Address
                     message received from or advertised to a peer.";
                }
                uses binding-address-state-attributes;
              }
              list fec-label {
                key "fec";
                description
                  "List of FEC-label bindings learned by LDP.";
                leaf fec {
                  type inet:ipv4-prefix;
                  description
                    "The prefix FEC value in the FEC-label FEC-Label binding,
                     learned in a Label Mapping message received from
                     or advertised to a peer.";
                }
                uses binding-label-state-attributes;
              }
            } // bindings
          } // ipv4
        } // address-families
      } // global
      container discovery {
        description
          "Neighbor discovery
          "Neighbor-discovery configuration and operational state.";
        container interfaces {
          description
            "A list of interfaces for LDP Basic Discovery.";
          reference
            "RFC5036:
            "RFC 5036: LDP Specification. Sec Specification, Sec. 2.4.1.";
          uses basic-discovery-timers {
            refine "hello-holdtime" {
              default 15; "15";
            }
            refine "hello-interval" {
              default 5; "5";
            }
          }
          list interface {
            key "name";
            description
              "List of LDP interfaces used for LDP Basic Discovery.";
            uses ldp-interface-ref;
            leaf next-hello {
              type uint16;
              units seconds; "seconds";
              config false;
              description
                "Time to send the next Hello message.";
            }
            container address-families {
              description
                "Container for address families.";
              container ipv4 {
                presence "Present if IPv4 is enabled, unless the
                          'enabled' leaf is set to 'false'"; 'false'.";
                description
                  "IPv4 address family.";
                leaf enabled {
                  type boolean;
                  default true; "true";
                  description
                    "Set to false to disable the address family on
                     the interface.";
                }
                container hello-adjacencies {
                  config false;
                  description
                    "Containing a list of Hello adjacencies.";
                  list hello-adjacency {
                    key "adjacent-address";
                    config false;
                    description
                      "List of Hello adjacencies.";
                    leaf adjacent-address {
                      type inet:ipv4-address;
                      description
                        "Neighbor address of the Hello adjacency.";
                    }
                    uses adjacency-state-attributes;
                    uses ldp-peer-ref-from-interface;
                  }
                }
              } // ipv4
            } // address-families
          } // interface
        } // interfaces
        container targeted {
          description
            "A list of targeted neighbors for extended discovery.";
          leaf hello-holdtime {
            type uint16 {
              range 15..3600; "15..3600";
            }
            units seconds; "seconds";
            default 45; "45";
            description
              "The time interval for which an LDP targeted Hello
               adjacency is maintained in the absence of targeted
               Hello messages from an LDP neighbor.";
          }
          leaf hello-interval {
            type uint16 {
              range 5..3600; "5..3600";
            }
            units seconds; "seconds";
            default 15; "15";
            description
              "The interval between consecutive LDP targeted Hello
               messages used in extended LDP discovery.";
          }
          container hello-accept {
            description
              "LDP policy to control the acceptance of extended
               neighbor discovery
               neighbor-discovery Hello messages.";
            leaf enabled {
              type boolean;
              default false; "false";
              description
                "'true' to accept; 'false' to deny.";
            }
          }
          container address-families {
            description
              "Container for address families.";
            container ipv4 {
              presence "Present if IPv4 is enabled.";
              description
                "IPv4 address family.";
              container hello-adjacencies {
                config false;
                description
                  "Containing a list of Hello adjacencies.";
                list hello-adjacency {
                  key "local-address adjacent-address";
                  description
                    "List of Hello adjacencies.";
                  leaf local-address {
                    type inet:ipv4-address;
                    description
                      "Local address of the Hello adjacency.";
                  }
                  leaf adjacent-address {
                    type inet:ipv4-address;
                    description
                      "Neighbor address of the Hello adjacency.";
                  }
                  uses adjacency-state-attributes;
                  uses ldp-peer-ref-from-target;
                }
              }
              list target {
                key "adjacent-address";
                description
                  "Targeted discovery params.";
                leaf adjacent-address {
                  type inet:ipv4-address;
                  description
                    "Configures a remote LDP neighbor for the
                     extended LDP discovery.";
                }
                leaf enabled {
                  type boolean;
                  default true; "true";
                  description
                    "'true' to enable the target.";
                }
                leaf local-address {
                  type inet:ipv4-address;
                  description
                    "The local address used as the source address to
                     send targeted Hello messages.
                     If the value is not specified, the
                     transport-address
                     transport address is used as the source
                     address.";
                }
              } // target
            } // ipv4
          } // address-families
        } // targeted
      } // discovery
      container peers {
        description
          "Peers configuration attributes.";
        uses peer-authentication;
        uses peer-attributes {
          refine session-ka-holdtime "session-ka-holdtime" {
            default 180; "180";
          }
          refine session-ka-interval "session-ka-interval" {
            default 60; "60";
          }
        }
        list peer {
          key "lsr-id label-space-id";
          description
            "List of peers.";
          leaf lsr-id {
            type rt-types:router-id;
            description
              "The LSR ID Id of the peer, used to identify the globally
               unique LSR.  This is the first four octets of the LDP
               ID.  This leaf is used together with the leaf
               'label-space-id' to form the LDP ID.";
            reference
              "RFC5036. Sec
              "RFC 5036: LDP Specification, Sec. 2.2.2.";
          }
          leaf label-space-id {
            type uint16;
            description
              "The Label Space ID label space Id of the peer, used to identify a
               specific label space within the LSR.  This is the last
               two octets of the LDP ID.  This leaf is used together
               with the leaf 'lsr-id' to form the LDP ID.";
            reference
              "RFC5036. Sec
              "RFC 5036: LDP Specification, Sec. 2.2.2.";
          }
          uses peer-authentication;
          container address-families {
            description
              "Per-vrf per-af params.";
            container ipv4 {
              presence "Present if IPv4 is enabled.";
              description
                "IPv4 address family.";
              container hello-adjacencies {
                config false;
                description
                  "Containing a list of Hello adjacencies.";
                list hello-adjacency {
                  key "local-address adjacent-address";
                  description
                    "List of Hello adjacencies.";
                  leaf local-address {
                    type inet:ipv4-address;
                    description
                      "Local address of the Hello adjacency.";
                  }
                  leaf adjacent-address {
                    type inet:ipv4-address;
                    description
                      "Neighbor address of the Hello adjacency.";
                  }
                  uses adjacency-state-attributes;
                  leaf interface {
                    type if:interface-ref;
                    description
                      "Interface for this adjacency.";
                  }
                }
              }
            } // ipv4
          } // address-families
          uses peer-state-derived;
        } // list peer
      } // peers
    } // container mpls-ldp
  }

  /*
   * RPCs
   */

  rpc mpls-ldp-clear-peer {
    description
      "Clears the session to the peer.";
    input {
      uses ldp-peer-ref-absolute {
        description
          "The LDP peer to be cleared.  If this is not provided provided,
           then all peers are cleared.
           The peer is identified by its LDP ID, which consists of
           the LSR ID Id and the Label Space ID."; label space Id.";
      }
    }
  }

  rpc mpls-ldp-clear-hello-adjacency {
    description
      "Clears the hello adjacency"; Hello adjacency.";
    input {
      container hello-adjacency {
        description
          "Link adjacency or targettted targeted adjacency.  If this is not
           provided
           provided, then all Hello adjacencies are cleared"; cleared.";
        leaf protocol-name {
          type leafref {
            path "/rt:routing/rt:control-plane-protocols/"
               + "rt:control-plane-protocol/rt:name";
          }
          description
            "The name of the LDP protocol instance.";
        }
        choice hello-adjacency-type {
          description
            "Adjacency type.";
          case targeted {
            container targeted {
              presence "Present to clear targeted adjacencies.";
              description
                "Clear targeted adjacencies.";
              leaf target-address {
                type inet:ip-address;
                description
                  "The target address.  If this is not provided provided, then
                   all targeted adjacencies are cleared"; cleared.";
              }
            }
          }
          case link {
            container link {
              presence "Present to clear link adjacencies.";
              description
                "Clear link adjacencies.";
              leaf next-hop-interface {
                type leafref {
                  path "/rt:routing/rt:control-plane-protocols/"
                     + "rt:control-plane-protocol/mpls-ldp/discovery/" "rt:control-plane-protocol/mpls-ldp/"
                     + "interfaces/interface/name"; "discovery/interfaces/interface/name";
                }
                description
                  "Interface connecting to next-hop. a next hop.  If this is
                   not
                   provided provided, then all link adjacencies are
                   cleared.";
              }
              leaf next-hop-address {
                type inet:ip-address;
                must "../next-hop-interface" '../next-hop-interface' {
                  description
                    "Applicable when an interface is specified.";
                }
                description
                  "IP address of next-hop. a next hop.  If this is not provided
                   provided, then adjacencies to all next-hops next hops on the
                   given interface are cleared.";
              }
            }
          }
        } // hello-adjacency-type
      } // hello-adjacency
    } // input
  } // mpls-ldp-clear-hello-adjacency

  rpc mpls-ldp-clear-peer-statistics {
    description
      "Clears protocol statistics (e.g. (e.g., sent and received
       counters).";
    input {
      uses ldp-peer-ref-absolute {
        description
          "The LDP peer whose statistics are to be cleared.
           If this is not provided provided, then all peers' statistics are
           cleared.
           The peer is identified by its LDP ID, which consists of
           the LSR ID Id and the Label Space ID."; label space Id.";
      }
    }
  }

  /*
   * Notifications
   */

  notification mpls-ldp-peer-event {
    description
      "Notification event for a change of LDP peer operational
       status.";
    leaf event-type {
      type oper-status-event-type;
      description
        "Event type.";
    }
    container peer {
      description
        "Reference to an LDP peer, by the LDP ID, which consists of
         the LSR ID Id and the Label Space ID."; label space Id.";
      uses ldp-peer-ref-absolute;
    }
  }

  notification mpls-ldp-hello-adjacency-event {
    description
      "Notification event for a change of LDP adjacency operational
       status.";
    leaf event-type {
      type oper-status-event-type;
      description
        "Event type.";
    }
    leaf protocol-name {
      type leafref {
        path "/rt:routing/rt:control-plane-protocols/"
           + "rt:control-plane-protocol/rt:name";
      }
      description
        "The name of the LDP protocol instance.";
    }
    choice hello-adjacency-type {
      description
        "Interface or targeted adjacency.";
      case targeted {
        container targeted {
          description
            "Targeted adjacency through LDP extended discovery.";
          leaf target-address {
            type inet:ip-address;
            description
              "The target adjacent address adjacent-address learned.";
          }
        }
      }
      case link {
        container link {
          description
            "Link adjacency through LDP basic discovery.";
          leaf next-hop-interface {
            type if:interface-ref;
            description
              "The interface connecting to the adjacent next hop.";
          }
          leaf next-hop-address {
            type inet:ip-address;
            must "../next-hop-interface" '../next-hop-interface' {
              description
                "Applicable when an interface is specified.";
            }
            description
              "IP address of the next hop. This can be IPv4 or IPv6
               address.";
          }
        }
      }
    } // hello-adjacency-type
  } // mpls-ldp-hello-adjacency-event

  notification mpls-ldp-fec-event {
    description
      "Notification event for a change of FEC status.";
    leaf event-type {
      type oper-status-event-type;
      description
        "Event type.";
    }
    leaf protocol-name {
      type leafref {
        path "/rt:routing/rt:control-plane-protocols/"
           + "rt:control-plane-protocol/rt:name";
      }
      description
        "The name of the LDP protocol instance.";
    }
    leaf fec {
      type inet:ip-prefix;
      description
        "The address prefix element of the FEC whose status
         has changed.";
    }
  }
}

<CODE ENDS>
]]>

	  </artwork>
  </sourcecode>
	</figure>
	</section>

	<section numbered="true" toc="default">
	<name>Extended</name>

	  <t>
	    This YANG module imports types defined in <xref
	    target="RFC5036"/>, <xref target="RFC6991"/>, <xref
	    target="RFC8349"/>, <xref target="RFC8177"/>, <xref
	    target="RFC8343"/>, and <xref target="RFC8343"/>. target="RFC9067"/>.
	  </t>

	  <figure anchor="EXT-YANG-FILE">
	    <name>LDP extended module</name>
	  <artwork>

<![CDATA[
<CODE BEGINS> file "ietf-mpls-ldp-extended@2020-02-25.yang"

// RFC Editor: replace the above date 2020-02-25  with the date of
// publication and remove this note. Extended Module</name>
	  <sourcecode name="ietf-mpls-ldp-extended@2022-03-07.yang" type="yang" markers="true"><![CDATA[
module ietf-mpls-ldp-extended {
  yang-version 1.1;
  namespace "urn:ietf:params:xml:ns:yang:ietf-mpls-ldp-extended";
  prefix "ldp-ext"; ldp-ext;

  import ietf-inet-types {
    prefix "inet"; inet;
    reference
      "RFC 6991: Common YANG Data Types";
  }
  import ietf-routing {
    prefix "rt"; rt;
    reference
      "RFC 8349: A YANG Data Model for Routing Management (NMDA
       version)";
  }
  import ietf-key-chain {
    prefix "key-chain"; key-chain;
    reference
      "RFC 8177: YANG Data Model for Key Chains";
  }
  import ietf-mpls-ldp {
    prefix "ldp"; ldp;
    reference
      "RFC XXXX: 9070: YANG Data Model for MPLS LDP";
    // RFC Editor: replace XXXX with actual RFC number and remove
    // this note
  }
  import ietf-interfaces {
    prefix "if"; if;
    reference
      "RFC 8343: A YANG Data Model for Interface Management";
  }
  import ietf-routing-policy {
    prefix rt-pol;
    reference
      "I-D.ietf-rtgwg-policy-model:
      "RFC 9067: A YANG Data Model for Routing
       Policy Management"; Policy";
  }

  organization
    "IETF MPLS Working Group";
  contact
    "WG Web:   <http://tools.ietf.org/wg/mpls/>   <https://datatracker.ietf.org/wg/mpls/>
     WG List:  <mailto:mpls@ietf.org>

     Editor:   Kamran Raza
               <mailto:skraza@cisco.com>

     Editor:

     Author:   Rajiv Asati
               <mailto:rajiva@cisco.com>

     Editor:

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

     Editor:

     Author:   Santosh Esale
               <mailto:sesale@juniper.net>

     Editor: Easale
               <mailto:santosh_easale@berkeley.edu>

     Author:   Xia Chen
               <mailto:jescia.chenxia@huawei.com>

     Editor:

     Author:   Himanshu Shah
               <mailto:hshah@ciena.com>";
  description
    "This YANG module defines the extended components for the
     management of Multi-Protocol Multiprotocol Label Switching (MPLS) Label
     Distribution Protocol (LDP).  It is also the model to
     be augmented for extended Multipoint LDP (mLDP).

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

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

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

     // RFC Editor: replace XXXX with actual RFC number and remove
     // this note

  revision 2020-02-25 2022-03-07 {
    description
      "Initial revision.";
    reference
      "RFC XXXX: 9070: YANG Data Model for MPLS LDP.";

      // RFC Editor: replace XXXX with actual RFC number and remove
      // this note LDP";
  }

  /*
   * Features
   */

  feature capability-end-of-lib {
    description
      "This feature indicates that the system allows to configure for the
       configuration of LDP end-of-lib capability.";
  }

  feature capability-typed-wildcard-fec {
    description
      "This feature indicates that the system allows to configure for the
       configuration of LDP typed-wildcard-fec capability.";
  }

  feature capability-upstream-label-assignment {
    description
      "This feature indicates that the system allows to configure for the
       configuration of LDP upstream label assignment capability.";
  }

  feature forwarding-nexthop-config {
    description
      "This feature indicates that the system allows to configure for controlling
       MPLS forwarding nexthop on interfaces."; an LDP interface.";
  }

  feature graceful-restart-helper-mode {
    description
      "This feature indicates that the system supports graceful
       restart helper mode.  We call an LSR to be operating in GR
       helper mode when it advertises 0 as its FT Reconnect Timeout
       in the FT Session TLV.
       Please refer RFC3478 section to Section 2 of RFC 3478 for details.";
  }

  feature key-chain {
    description
      "This feature indicates that the system supports keychain key-chain for
       authentication.";
  }

  feature peers-dual-stack-transport-preference {
    description
      "This feature indicates that the system allows to configure for the
       configuration of the transport connection preference in a
       dual-stack setup for peers.";
  }

  feature per-interface-timer-config {
    description
      "This feature indicates that the system allows to configure for the
       configuration of interface Hello timers at the per-interface
       level.";
  }

  feature per-peer-admin-down {
    description
      "This feature indicates that the system allows to
       administratively disable for the
       administrative disabling of a peer.";
  }

  feature per-peer-graceful-restart-config {
    description
      "This feature indicates that the system allows to configure for the
       configuration of graceful restart at the per-peer level.";
  }

  feature per-peer-session-attributes-config {
    description
      "This feature indicates that the system allows to configure for the
       configuration of session attributes at the per-peer level.";
  }

  feature policy-label-assignment-config {
    description
      "This feature indicates that the system allows to configure for the
       configuration of policies to assign labels according to
       certain prefixes.";
  }

  feature policy-ordered-label-config {
    description
      "This feature indicates that the system allows to configure for the
       configuration of ordered label policies.";
  }

  feature policy-targeted-discovery-config {
    description
      "This feature indicates that the system allows to configure for the
       configuration of policies to control the acceptance of
       targeted neighbor
       discovery neighbor-discovery Hello messages.";
  }

  feature session-downstream-on-demand-config {
    description
      "This feature indicates that the system allows to configure for the
       configuration of session downstream-on-demand"; downstream on demand.";
  }

  /*
   * Typedefs
   */

  typedef neighbor-list-ref {
    type leafref {
      path "/rt-pol:routing-policy/rt-pol:defined-sets/"
         + "rt-pol:neighbor-sets/rt-pol:neighbor-set/rt-pol:name";
    }
    description
      "A type for a reference to a neighbor address list.
       The string value is the name identifier for uniquely
       identifying the referenced address list, which contains a list
       of addresses that a routing policy can applied.";
    reference
      "I-D.ietf-rtgwg-policy-model:
      "RFC 9067: A YANG Data Model for Routing
       Policy Management"; Policy";
  }

  typedef prefix-list-ref {
    type leafref {
      path "/rt-pol:routing-policy/rt-pol:defined-sets/"
         + "rt-pol:prefix-sets/rt-pol:prefix-set/rt-pol:name";
    }
    description
      "A type for a reference to a prefix list.
       The string value is the name identifier for uniquely
       identifying the referenced prefix set, which contains a list
       of prefixes that a routing policy can applied.";
    reference
      "I-D.ietf-rtgwg-policy-model:
      "RFC 9067: A YANG Data Model for Routing
       Policy Management"; Policy";
  }

  typedef peer-list-ref {
    type leafref {
      path "/rt-pol:routing-policy/rt-pol:defined-sets/"
         + "rt-pol:neighbor-sets/rt-pol:neighbor-set/rt-pol:name";
    }
    description
      "A type for a reference to a peer address list.
       The string value is the name identifier for uniquely
       identifying the referenced address list, which contains a list
       of addresses that a routing policy can applied.";
    reference
      "I-D.ietf-rtgwg-policy-model:
      "RFC 9067: A YANG Data Model for Routing
       Policy Management"; Policy";
  }

  /*
   * Identities
   */
  /*
   * Groupings
   */

  grouping address-family-ipv4-augment {
    description
      "Augmentation to address family IPv4.";
    uses policy-container;
    leaf transport-address {
      type inet:ipv4-address;
      description
        "The transport address advertised in LDP Hello messages.
         If this value is not specified, the LDP LSR ID Id is used as
         the transport address.";
      reference
        "RFC5036.
        "RFC 5036: LDP Specification, Sec. 3.5.2.";
    }
  }

  grouping authentication-keychain-augment {
    description
      "Augmentation to authentication to add keychain."; key-chain.";
    leaf key-chain {
      type key-chain:key-chain-ref;
      description
        "key-chain name.
         If not specified, no key chain is used.";
    }
  }

  grouping capability-augment {
    description
      "Augmentation to capability.";
    container end-of-lib {
      if-feature capability-end-of-lib; "capability-end-of-lib";
      description
        "Configure end-of-lib capability.";
      leaf enabled {
        type boolean;
        default false; "false";
        description
          "'true' to enable end-of-lib capability.";
      }
    }
    container typed-wildcard-fec {
      if-feature capability-typed-wildcard-fec; "capability-typed-wildcard-fec";
      description
        "Configure typed-wildcard-fec capability.";
      leaf enabled {
        type boolean;
        default false; "false";
        description
          "'true' to enable typed-wildcard-fec capability.";
      }
    }
    container upstream-label-assignment {
      if-feature capability-upstream-label-assignment; "capability-upstream-label-assignment";
      description
        "Configure upstream label assignment capability.";
      leaf enabled {
        type boolean;
        default false; "false";
        description
          "'true' to enable upstream label assignment.";
      }
    }
  } // capability-augment

  grouping global-augment {
    description
      "Augmentation to global attributes.";
    leaf igp-synchronization-delay {
      type uint16 {
        range "0 | 3..300";
      }
      units seconds; "seconds";
      default 0; "0";
      description
        "Sets the interval that the LDP waits before notifying the
         Interior Gateway Protocol (IGP) that label exchange is
         completed so that IGP can start advertising the normal
         metric for the link.
         If the value is not specified, there is no delay.";
    }
  }

  grouping global-forwarding-nexthop-augment {
    description
      "Augmentation to at the global level for controlling MPLS
       forwarding nexthop on LDP interfaces.";
    container forwarding-nexthop {
      if-feature forwarding-nexthop-config; "forwarding-nexthop-config";
      description
        "Configuration for controlling MPLS forwarding nexthop."; on LDP
         interfaces.";
      container interfaces {
        description
          "Containing a list of interfaces on which forwarding can be
           disabled.";
        list interface {
          key "name";
          description
            "List of LDP interfaces on which forwarding can be
             disabled.";
          uses ldp:ldp-interface-ref;
          list address-family {
            key "afi";
            description
              "Per-vrf per-af params.";
            leaf afi {
              type identityref {
                base rt:address-family;
              }
              description
                "Address family type value.";
            }
            leaf ldp-disable {
              type boolean;
              default false; "false";
              description
                "'true' to disable LDP forwarding on the interface.";
            }
          }
        } // interface
      } // interfaces
    } // forwarding-nexthop
  } // global-forwarding-nexthop-augment

  grouping graceful-restart-augment {
    description
      "Augmentation to graceful restart.";
    leaf helper-enabled {
      if-feature graceful-restart-helper-mode; "graceful-restart-helper-mode";
      type boolean;
      default false; "false";
      description
        "Enable or disable graceful restart helper mode.";
    }
  }

  grouping interface-address-family-ipv4-augment {
    description
      "Augmentation to interface address family IPv4.";
    leaf transport-address {
      type union {
        type enumeration {
          enum "use-global-transport-address" use-global-transport-address {
            description
              "Use the transport address set at the global level
               common for all interfaces for this address family.";
          }
          enum "use-interface-address" use-interface-address {
            description
              "Use interface address as the transport address.";
          }
        }
        type inet:ipv4-address;
      }
      default "use-global-transport-address";
      description
        "IP address to be advertised as the LDP transport address.";
    }
  }

  grouping interface-address-family-ipv6-augment {
    description
      "Augmentation to interface address family IPv6.";
    leaf transport-address {
      type union {
        type enumeration {
          enum "use-global-transport-address" use-global-transport-address {
            description
              "Use the transport address set at the global level
               common for all interfaces for this address family.";
          }
          enum "use-interface-address" use-interface-address {
            description
              "Use interface address as the transport address.";
          }
        }
        type inet:ipv6-address;
      }
      default "use-global-transport-address";
      description
        "IP address to be advertised as the LDP transport address.";
    }
  }

  grouping interface-augment {
    description
      "Augmentation to interface.";
    uses ldp:basic-discovery-timers {
      if-feature per-interface-timer-config; "per-interface-timer-config";
    }
    leaf igp-synchronization-delay {
      if-feature per-interface-timer-config; "per-interface-timer-config";
      type uint16 {
        range "0 | 3..300";
      }
      units seconds; "seconds";
      description
        "Sets the interval that the LDP waits before notifying the
         Interior Gateway Protocol (IGP) that label exchange is
         completed so that IGP can start advertising the normal
         metric for the link.
         This leaf may be configured at the per-interface level or
         the global level, with precedence given to the value at the
         per-interface level.  If the leaf is not configured at
         either level, the default value at the global level is
         used.";
    }
  }

  grouping peer-af-policy-container {
    description
      "LDP policy attribute container under peer address-family."; address family.";
    container label-policy {
      description
        "Label policy attributes.";
      container advertise {
        description
          "Label advertising policies.";
        leaf prefix-list {
          type prefix-list-ref;
          description
            "Applies the prefix list to filter outgoing label
             advertisements.
             If the value is not specified, no prefix filter
             is applied.";
        }
      }
      container accept {
        description
          "Label advertisement acceptance policies.";
        leaf prefix-list {
          type prefix-list-ref;
          description
            "Applies the prefix list to filer incoming label
             advertisements.
             If the value is not specified, no prefix filter
             is applied.";
        }
      }
    }
  } // peer-af-policy-container

  grouping peer-augment {
    description
      "Augmentation to each peer list entry.";
    leaf admin-down {
      if-feature per-peer-admin-down; "per-peer-admin-down";
      type boolean;
      default false; "false";
      description
        "'true' to disable the peer.";
    }
    uses ldp:graceful-restart-attributes-per-peer {
      if-feature per-peer-graceful-restart-config; "per-peer-graceful-restart-config";
    }
    uses ldp:peer-attributes {
      if-feature per-peer-session-attributes-config; "per-peer-session-attributes-config";
    }
  }

  grouping peers-augment {
    description
      "Augmentation to peers container.";
    container session-downstream-on-demand {
      if-feature session-downstream-on-demand-config; "session-downstream-on-demand-config";
      description
        "Session downstream-on-demand attributes.";
      leaf enabled {
        type boolean;
        default false; "false";
        description
          "'true' if session downstream-on-demand downstream on demand is enabled.";
      }
      leaf peer-list {
        type peer-list-ref;
        description
          "The name of a peer ACL, to be applied to the
           downstream-on-demand sessions.
           If this value is not specified, no filter is applied to
           any downstream-on-demand sessions.";
      }
    }
    container dual-stack-transport-preference {
      if-feature peers-dual-stack-transport-preference; "peers-dual-stack-transport-preference";
      description
        "The settings of peers to establish TCP connection in a
         dual-stack setup.";
      leaf max-wait {
        type uint16 {
          range "0..60";
        }
        default 30; "30";
        description
          "The maximum wait time in seconds for preferred transport
           connection establishment.  0 indicates no preference.";
      }
      container prefer-ipv4 {
        presence "Present if IPv4 is prefered preferred for transport
                  connection establishment, subject to the
                  'peer-list' in this container.";
        description
          "Uses IPv4 as the prefered preferred address family for transport
           connection establishment, subject to the 'peer-list' in
           this container.
           If this container is not present, as a default, IPv6 is
           the prefered preferred address family for transport connection
           establishment.";
        leaf peer-list {
          type peer-list-ref;
          description
            "The name of a peer ACL, to be applied to the IPv4
             transport connections.
             If this value is not specified, no filter is applied,
             and the IPv4 is prefered preferred for all peers.";
        }
      }
    }
  } // peers-augment

  grouping policy-container {
    description
      "LDP policy attributes.";
    container label-policy {
      description
        "Label policy attributes.";
      container advertise {
        description
          "Label advertising policies.";
        container egress-explicit-null {
          description
            "Enables an egress router to advertise an
             explicit null label (value 0) in place of an
             implicit null label (value 3) to the
             penultimate hop router.";
          leaf enabled {
            type boolean;
            default false; "false";
            description
              "'true' to enable explicit null.";
          }
        }
        leaf prefix-list {
          type prefix-list-ref;
          description
            "Applies the prefix list to filter outgoing label
             advertisements.
             If the value is not specified, no prefix filter
             is applied.";
        }
      }
      container accept {
        description
          "Label advertisement acceptance policies.";
        leaf prefix-list {
          type prefix-list-ref;
          description
            "Applies the prefix list to filter incoming label
             advertisements.
             If the value is not specified, no prefix filter
             is applied.";
        }
      }
      container assign {
        if-feature policy-label-assignment-config; "policy-label-assignment-config";
        description
          "Label assignment policies"; policies.";
        container independent-mode {
          description
            "Independent label policy attributes.";
          leaf prefix-list {
            type prefix-list-ref;
            description
              "Assign labels according to certain prefixes.
               If the value is not specified, no prefix filter
               is applied (labels are assigned to all learned
               routes).";
          }
        }
        container ordered-mode {
          if-feature policy-ordered-label-config; "policy-ordered-label-config";
          description
            "Ordered label policy attributes.";
          leaf egress-prefix-list {
            type prefix-list-ref;
            description
              "Assign labels according to certain prefixes for
               egress LSR.";
          }
        }
      } // assign
    } // label-policy
  } // policy-container

  /*
   * Configuration and state data nodes
   */
  // Forwarding nexthop augmentation to the global tree

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:global" {
    description
      "Forwarding nexthop augmentation.";
    uses global-forwarding-nexthop-augment;
  }

  // global/address-families/ipv6

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:global/"
        + "ldp:address-families" {
    description
      "Global IPv6 augmentation.";
    container ipv6 {
      presence "Present if IPv6 is enabled, unless the 'enabled'
                leaf is set to 'false'"; 'false'.";
      description
        "Containing data related to the IPv6 address family.";
      leaf enabled {
        type boolean;
        default true; "true";
        description
          "'false' to disable the address family.";
      }
      uses policy-container;
      leaf transport-address {
        type inet:ipv6-address;
        mandatory true;
        description
          "The transport address advertised in LDP Hello messages.";
      }
      leaf label-distribution-control-mode {
        type enumeration {
          enum independent {
            description
              "Independent label distribution control.";
          }
          enum ordered {
            description
              "Ordered label distribution control.";
          }
        }
        config false;
        description
          "Label distribution control mode.";
        reference
          "RFC5036:
          "RFC 5036: LDP Specification. Sec Specification, Sec. 2.6.";
      }
      // ipv6 bindings
      container bindings {
        config false;
        description
          "LDP address and label binding information.";
        list address {
          key "address";
          description
            "List of address bindings learned by LDP.";
          leaf address {
            type inet:ipv6-address;
            description
              "The IPv6 address learned from an Address
               message received from or advertised to a peer.";
          }
          uses ldp:binding-address-state-attributes;
        }
        list fec-label {
          key "fec";
          description
            "List of FEC-label bindings learned by LDP.";
          leaf fec {
            type inet:ipv6-prefix;
            description
              "The prefix FEC value in the FEC-label FEC-Label binding,
               learned in a Label Mapping message received from
               or advertised to a peer.";
          }
          uses ldp:binding-label-state-attributes;
        }
      } // bindings
    } // ipv6
  }

  // discovery/interfaces/interface/address-families/ipv6

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:discovery/"
        + "ldp:interfaces/ldp:interface/"
        + "ldp:address-families" {
    description
      "Interface IPv6 augmentation.";
    container ipv6 {
      presence "Present if IPv6 is enabled, unless the 'enabled'
                leaf is set to 'false'"; 'false'.";
      description
        "IPv6 address family.";
      leaf enabled {
        type boolean;
        default true; "true";
        description
          "'false' to disable the address family on the interface.";
      }
      container hello-adjacencies {
        config false;
        description
          "Containing a list of Hello adjacencies.";
        list hello-adjacency {
          key "adjacent-address";
          config false;
          description
            "List of Hello adjacencies.";
          leaf adjacent-address {
            type inet:ipv6-address;
            description
              "Neighbor address of the Hello adjacency.";
          }
          uses ldp:adjacency-state-attributes;
          uses ldp:ldp-peer-ref-from-interface;
        }
      }
    } // ipv6
  }

  // discovery/targeted/address-families/ipv6

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:discovery/"
        + "ldp:targeted/ldp:address-families" {
    description
      "Targeted discovery IPv6 augmentation.";
    container ipv6 {
      presence "Present if IPv6 is enabled.";
      description
        "IPv6 address family.";
      container hello-adjacencies {
        config false;
        description
          "Containing a list of Hello adjacencies.";
        list hello-adjacency {
          key "local-address adjacent-address";
          config false;
          description
            "List of Hello adjacencies.";
          leaf local-address {
            type inet:ipv6-address;
            description
              "Local address of the Hello adjacency.";
          }
          leaf adjacent-address {
            type inet:ipv6-address;
            description
              "Neighbor address of the Hello adjacency.";
          }
          uses ldp:adjacency-state-attributes;
          uses ldp:ldp-peer-ref-from-target;
        }
      }
      list target {
        key "adjacent-address";
        description
          "Targeted discovery params.";
        leaf adjacent-address {
          type inet:ipv6-address;
          description
            "Configures a remote LDP neighbor for the
             extended LDP discovery.";
        }
        leaf enabled {
          type boolean;
          default true; "true";
          description
            "'true' to enable the target.";
        }
        leaf local-address {
          type inet:ipv6-address;
          description
            "The local address used as the source address to send
             targeted Hello messages.
             If the value is not specified, the transport-address transport address
             is used as the source address.";
        }
      } // target
    } // ipv6
  }

  // /peers/peer/state/address-families/ipv6

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/"
        + "ldp:peer/ldp:address-families" {
    description
      "Peer state IPv6 augmentation.";
    container ipv6 {
      presence "Present if IPv6 is enabled.";
      description
        "IPv6 address family.";
      container hello-adjacencies {
        config false;
        description
          "Containing a list of Hello adjacencies.";
        list hello-adjacency {
          key "local-address adjacent-address";
          description
            "List of Hello adjacencies.";
          leaf local-address {
            type inet:ipv6-address;
            description
              "Local address of the Hello adjacency.";
          }
          leaf adjacent-address {
            type inet:ipv6-address;
            description
              "Neighbor address of the Hello adjacency.";
          }
          uses ldp:adjacency-state-attributes;
          leaf interface {
            type if:interface-ref;
            description
              "Interface for this adjacency.";
          }
        }
      }
    } // ipv6
  }

  /*
   * Configuration data and operational state data nodes
   */

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:global" {
    description
      "Graceful restart augmentation.";
    uses global-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:global/"
        + "ldp:capability" {
    description
      "Capability augmentation.";
    uses capability-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:global/"
        + "ldp:graceful-restart" {
    description
      "Graceful restart augmentation.";
    uses graceful-restart-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:global/"
        + "ldp:address-families/ldp:ipv4" {
    description
      "Address family IPv4 augmentation.";
    uses address-family-ipv4-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:discovery/"
        + "ldp:interfaces/ldp:interface" {
    description
      "Interface augmentation.";
    uses interface-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:discovery/"
        + "ldp:interfaces/ldp:interface/ldp:address-families/"
        + "ldp:ipv4" {
    description
      "Interface address family IPv4 augmentation.";
    uses interface-address-family-ipv4-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:discovery/"
        + "ldp:interfaces/ldp:interface/ldp:address-families/"
        + "ldp-ext:ipv6" {
    description
      "Interface address family IPv6 augmentation.";
    uses interface-address-family-ipv6-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:discovery/"
        + "ldp:targeted/ldp:hello-accept" {
    description
      "Targeted discovery augmentation.";
    leaf neighbor-list {
      if-feature policy-targeted-discovery-config; "policy-targeted-discovery-config";
      type neighbor-list-ref;
      description
        "The name of a neighbor ACL, used to accept Hello messages
         from LDP peers as permitted by the neighbor-list policy.
         If this value is not specified, targeted Hello messages
         from any source are accepted.";
    }
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers" {
    description
      "Peers augmentation.";
    uses peers-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/"
        + "ldp:authentication/ldp:authentication-type" {
    if-feature key-chain; "key-chain";
    description
      "Peers authentication augmentation.";
    case key-chain {
      uses authentication-keychain-augment;
    }
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/ldp:peer" "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/"
        + "ldp:peer" {
    description
      "Peer list entry augmentation.";
    uses peer-augment;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/ldp:peer/" "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/"
        + "ldp:authentication/ldp:authentication-type" "ldp:peer/ldp:authentication/ldp:authentication-type" {
    if-feature key-chain; "key-chain";
    description
      "Peer list entry authentication augmentation.";
    case key-chain {
      uses authentication-keychain-augment;
    }
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/ldp:peer/" "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/"
        + "ldp:address-families/ldp:ipv4" "ldp:peer/ldp:address-families/ldp:ipv4" {
    description
      "Peer list entry IPv4 augmentation.";
    uses peer-af-policy-container;
  }

  augment "/rt:routing/rt:control-plane-protocols/"
        + "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/ldp:peer/" "rt:control-plane-protocol/ldp:mpls-ldp/ldp:peers/"
        + "ldp:address-families/ldp-ext:ipv6" "ldp:peer/ldp:address-families/ldp-ext:ipv6" {
    description
      "Peer list entry IPv6 augmentation.";
    uses peer-af-policy-container;
  }
}

<CODE ENDS>
 ]]>

	  </artwork>  </sourcecode>
</figure>

</section>
</section>

<section numbered="true" toc="default">

      <name>Security Considerations</name>

<t> This specification inherits the security
	considerations captured in <xref target="RFC5920"/> and the LDP protocol specification documents, namely base LDP
	<xref target="RFC5036"/>, LDP IPv6 <xref target="RFC7552"/>, LDP Capabilities
	<xref target="RFC5561"/>, Typed Wildcard FEC <xref target="RFC5918"/>, LDP End-of-LIB
	<xref target="RFC5919"/>, and LDP Upstream Label Assignment
	<xref target="RFC6389"/>.
	</t>

	<section numbered="true" toc="default">
	<name>YANG model</name> Data Model</name>

<t> The YANG modules specified in this document defines define a schema for data that is designed to be accessed via network management protocols such as NETCONF <xref target="RFC6241"/> or RESTCONF <xref target="RFC8040"/>. The lowest NETCONF layer is the secure transport layer, and the mandatory-to-implement secure transport is Secure Shell (SSH) <xref target="RFC6242"/>. The lowest RESTCONF layer is HTTPS, and the mandatory-to-implement secure transport is TLS <xref target="RFC8446"/>. </t>

<t> The Network Configuration Access Control Model (NACM) <xref target="RFC8341"/> provides the means to restrict access for particular NETCONF or RESTCONF users to a preconfigured subset of all available NETCONF or RESTCONF protocol operations and content. </t>

<section numbered="true" toc="default">
<name>Writable nodes</name> Nodes</name>
<t> There are a number of data nodes defined in this these YANG module modules that are writable/creatable/deletable (i.e., config true, which is the default). These data nodes may be considered sensitive or vulnerable in some network environments. Write operations (e.g., edit-config) to these data nodes without proper protection can have a negative effect on network operations. </t>

<t> For LDP, the ability to modify MPLS LDP configuration may allow the entire MPLS LDP domain to be compromised including forming LDP adjacencies and/or peer sessions with unauthorized
routers to mount a massive Denial-of-Service (DoS) attack. In particular, folling the following are the subtrees and data nodes that are sensitivite sensitive and vulnerable: </t>

<ul>
  <li> /mpls-ldp/discovery/interfaces/interface: Adding

<dl>
  <dt>/mpls-ldp/discovery/interfaces/interface:
  </dt>
  <dd>Adding LDP on any unprotected interface could allow an LDP hello Hello adjacency
  to be formed with an unauthorized and malicious neighbor. Once an hello a Hello
  adjacency is formed, a peer session could progress with this neighbor. </li>
  <li> /mpls-ldp/discovery/targeted/hello-accept:
  </dd>

  <dt>/mpls-ldp/discovery/targeted/hello-accept:
  </dt>
  <dd> Allowing acceptance of targeted-hellos could open LDP to DoS attacks
  related to incoming targeted hellos from malicious sources. </li>
  <li> /mpls-ldp/peers/authentication: Allowing
  </dd>

  <dt>/mpls-ldp/peers/authentication:
  </dt>
  <dd>Allowing a peer session establishement establishment is typically controlled via LDP
  authentication where a proper and secure authentication password/key
  management is warranted.</li>
  <li> /mpls-ldp/peers/peer/authentication: Same warranted.
  </dd>

  <dt>/mpls-ldp/peers/peer/authentication:
  </dt>
  <dd>Same as above. </li>
</ul>
  </dd>

</dl>

</section>

<section numbered="true" toc="default">
<name>Readable nodes</name> Nodes</name>

<t> Some of the readable data nodes in this these YANG module modules may be considered sensitive or vulnerable in some network environments. It is thus important to control read access (e.g., via get, get-config, or notification) to these data nodes. These are the subtrees and data nodes and their sensitivity/vulnerability: </t>

<t>The exposure of LDP databases (such as hello Hello adjacencies, peers, address bindings, and fec-label FEC-Label bindings) beyond the scope of the LDP admin domain may be undesirable. The relevant subtrees and data nodes are as follows: </t>
  <ul>
    <li> /mpls-ldp/global/address-families/ipv4/bindings/address </li>
    <li> /mpls-ldp/global/address-families/ipv6/bindings/address </li>
    <li> /mpls-ldp/global/address-families/ipv4/bindings/fec-label</li>
    <li> /mpls-ldp/global/address-families/ipv6/bindings/fec-label</li>
    <li> /mpls-ldp/discovery/interfaces/interface/address-families/ipv4/hello-adjacencies </li>
    <li> /mpls-ldp/discovery/interfaces/interface/address-families/ipv6/hello-adjacencies </li>
    <li> /mpls-ldp/discovery/targeted/address-families/ipv4/hello-adjacencies </li>
    <li> /mpls-ldp/discovery/targeted/address-families/ipv6/hello-adjacencies </li>
    <li> /mpls-ldp/peers</li>
  </ul>

<t> The configuration for LDP peer authentication is supported via the
specification of
key-chain specification <xref target="RFC8040"/>, target="RFC8177"/> or via direct
specification of a key associated with a crypto algorithm (such as MD5).
The relevant subtrees and data nodes are as follows: </t>
   <ul>
       <li> /mpls-ldp/peers/authentication </li>
       <li> /mpls-ldp/peers/peer/authentication </li>
   </ul>

<t> The actual authentication key data (whether locally specified or part of a
key-chain) is sensitive and needs to be kept secret from unauthorized parties.
For key-chain based key-chain-based authentication, this model inherits the security
considerations of <xref target="RFC8040"/> (that includes the considerations
with respect to the local storage and handling of authentication keys). A
similar procedure for storage and access to direct key keys is warranted.
</t>

</section>

<section numbered="true" toc="default">
<name>RPC operations</name> Operations</name>
<t>Some of the RPC operations in this these YANG module modules may be considered sensitive or vulnerable in some network environments. It is thus important to control access to these operations otherwise operations; otherwise, control plane flaps, network outages, and DoS attacks are possible. The RPC operations are: </t>

<ul>
  <li> mpls-ldp-clear-peer</li>
  <li> mpls-ldp-clear-hello-adjacency</li>
</ul>

</section>

<section numbered="true" toc="default">
<name>Notifications</name>
  <t> The model describes several notifications. The implementations must rate-limit the generation of these notifications to avoid creating
  significant notification load and possible side effects on the system stability.
  </t>
</section>
</section>

      </section>

      <section numbered="true" toc="default">
      <name>IANA Considerations</name>

      <t> This document requests the registration of

      <t>Per this document, the following URIs have been registered in the IETF "XML
      registry"
      Registry" <xref target="RFC3688"/>: </t>
      <table>
	<name>URIs</name>
	<thead>
            <tr>
              <th align="left">URI</th>
	      <th align="left">Registrant</th>
	      <th align="left">XML</th>
	    </tr>
	</thead>
	<tbody>
	  <tr>
	    <td align="left">urn:ietf:params:xml:ns:yang:ietf-mpls-ldp</td>
	    <td align="left">The IESG</td>
	    <td align="left">N/A</td>
	  </tr>
	  <tr>
	    <td align="left">urn:ietf:params:xml:ns:yang:ietf-mpls-ldp-extended</td>
	    <td align="left">The IESG</td>
	    <td align="left">N/A</td>
	  </tr>
	</tbody>
      </table>

      <t> This document requests the registration of

<dl spacing="compact">
<dt>URI:
</dt>
<dd>urn:ietf:params:xml:ns:yang:ietf-mpls-ldp
</dd>

<dt>Registrant:
</dt>
<dd>The IESG
</dd>

<dt>XML:
</dt>
<dd>N/A
</dd>

</dl>

<dl spacing="compact">

<dt>URI:
</dt>
<dd>urn:ietf:params:xml:ns:yang:ietf-mpls-ldp-extended
</dd>

<dt>Registrant:
</dt>
<dd>The IESG
</dd>

<dt>XML:
</dt>
<dd>N/A
</dd>

</dl>

      <t>Per this document, the following YANG modules have been registered in the
      "YANG Module Names" registry <xref target="RFC6020"/>: </t>

      <table>
	<name>YANG Modules</name>
	<thead>
            <tr>
              <th align="left">Name</th>
	      <th align="left">Namespace</th>
	      <th align="left">Prefix</th>
	      <th align="left">Reference</th>
	    </tr>
	</thead>
	<tbody>
	  <tr>
	    <td align="left">ietf-mpls-ldp</td>
	    <td align="left">urn:ietf:params:xml:ns:yang:ietf-mpls-ldp</td>
	    <td align="left">ldp</td>
	    <td align="left">This document</td>
	  </tr>
	  <tr>
	    <td align="left">ietf-mpls-ldp-extended</td>
	    <td align="left">urn:ietf:params:xml:ns:yang:ietf-mpls-ldp-extended</td>
	    <td align="left">ldp-ext</td>
	    <td align="left">This document</td>
	  </tr>
	</tbody>
      </table>

      <t> -- RFC Editor: Replace "this document" with the document RFC number at time of publication,
      and remove this note.
      </t>

      </section>

      <section numbered="true" toc="default">
      <name>Acknowledgments</name>
	<t>The authors would like to acknowledge Eddie Chami, Nagendra Kumar, Mannan Venkatesan, and
	Pavan Beeram for their contribution to this document. </t>

	<t> We also acknowledge Ladislav Lhotka, Jan Lindblad, Tom Petch, Yingzhen Qu, and Benjamin Kaduk for their detailed review of the model during WG and IESG.</t>

      </section>

<section numbered="true" toc="default">
<name>Contributors</name>

    <artwork>

Danial Johari
Cisco Systems
Email: dajohari@cisco.com

Loa Andersson
Huawei Technologies
Email: loa@pi.nu

Jeff Tantsura
Apstra
Email: jefftant.ietf@gmail.com

Matthew Bocci
Nokia
Email: matthew.bocci@nokia.com

Reshad Rahman
Cisco Systems
Email: rrahman@cisco.com

Stephane Litkowski
Cisco Systems
Email: slitkows@cisco.com

    </artwork>

      <dl spacing="compact">

	<dt>Name:
	</dt>
	<dd>ietf-mpls-ldp
	</dd>

	<dt>Namespace:
	</dt>
	<dd>urn:ietf:params:xml:ns:yang:ietf-mpls-ldp
	</dd>

	<dt>Prefix:
	</dt>
	<dd>ldp
	</dd>

	<dt>Reference:
	</dt>
	<dd>RFC 9070
	</dd>
      </dl>

      <dl spacing="compact">

	<dt>Name:
	</dt>
	<dd>ietf-mpls-ldp-extended
	</dd>

	<dt>Namespace:
	</dt>
	<dd>urn:ietf:params:xml:ns:yang:ietf-mpls-ldp-extended
	</dd>

	<dt>Prefix:
	</dt>
	<dd>ldp-ext
	</dd>

	<dt>Reference:
	</dt>
	<dd>RFC 9070
	</dd>

      </dl>

      </section>

    </middle>

    <!--  *****BACK MATTER ***** -->

    <back>

   <!-- References split into informative and normative -->

   <!-- There are 2 ways to insert reference entries from the citation libraries:
    1. define an ENTITY at the top, and use "ampersand character"RFC2629; here (as shown)
    2. simply use a PI "less than character"?rfc include="reference.RFC.2119.xml"?> here
       (for I-Ds: include="reference.I-D.narten-iana-considerations-rfc2434bis.xml")

    Both are cited textually in the same manner: by using xref elements.
    If you use the PI option, xml2rfc will, by default, try to find included files in the same
    directory as the including file. You can also define the XML_LIBRARY environment variable
    with a value containing a set of directories to search.  These can be either in the local
    filing system or remote ones accessed by http (http://domain/dir/... ).-->

<displayreference target="I-D.ietf-mpls-mldp-yang" to="MPLS-MLDP-YANG"/>

      <references title="Normative References">
	<?rfc include="reference.RFC.3688.xml"?>
	<?rfc include="reference.RFC.3478.xml"?>
	<?rfc include="reference.RFC.5036.xml"?>
	<?rfc include="reference.RFC.5331.xml"?>
	<?rfc include="reference.RFC.5443.xml"?>
	<?rfc include="reference.RFC.5561.xml"?>
	<?rfc include="reference.RFC.5918.xml"?>
	<?rfc include="reference.RFC.5919.xml"?>
	<?rfc include="reference.RFC.5920.xml"?>
	<?rfc include="reference.RFC.6020.xml"?>
	<?rfc include="reference.RFC.7950.xml"?>
	<?rfc include="reference.RFC.6241.xml"?>
	<?rfc include="reference.RFC.6242.xml"?>
	<?rfc include="reference.RFC.6389.xml"?>
	<?rfc include="reference.RFC.6991.xml"?>
	<?rfc include="reference.RFC.8344.xml"?>
	<?rfc include="reference.RFC.7277.xml"?>
	<?rfc include="reference.RFC.7552.xml"?>
	<?rfc include="reference.RFC.8040.xml"?>
	<?rfc include="reference.RFC.8177.xml"?>
	<?rfc include="reference.RFC.8446.xml"?>
	<?rfc include="reference.RFC.8294.xml"?>
	<?rfc include="reference.RFC.8341.xml"?>
	<?rfc include="reference.RFC.8342.xml"?>
	<?rfc include="reference.RFC.8343.xml"?>
	<?rfc include="reference.RFC.8349.xml"?>
	<?rfc include="reference.RFC.8407.xml"?>
	<?rfc include="reference.RFC.8529.xml"?>
	<?rfc include="reference.I-D.ietf-rtgwg-policy-model.xml"?>

<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.3688.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.3478.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5036.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5331.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5443.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5561.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5918.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5919.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.5920.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.6020.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.7950.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.6241.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.6242.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.6389.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.6991.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8344.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.7552.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8040.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8177.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8446.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8294.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8341.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8342.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8343.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8349.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8407.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8529.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.9067.xml"/>

      </references>

      <references title="Informative References">
	<?rfc include="reference.RFC.4364.xml"?>
	<?rfc include="reference.RFC.7307.xml"?>
	<?rfc include="reference.RFC.7951.xml"?>
	<?rfc include="reference.RFC.8340.xml"?>
	<?rfc include="reference.I-D.ietf-mpls-mldp-yang.xml"?>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.4364.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.7307.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.7951.xml"/>
<xi:include href="https://xml2rfc.ietf.org/public/rfc/bibxml/reference.RFC.8340.xml"/>

<reference anchor='I-D.ietf-mpls-mldp-yang'>
<front>
<title>YANG Data Model for MPLS mLDP</title>
<author initials='K' surname='Raza' fullname='Kamran Raza' role="editor">
<organization />
</author>
<author initials='X' surname='Liu' fullname='Xufeng Liu'>
<organization />
</author>
<author initials='S' surname='Esale' fullname='Santosh Esale'>
<organization />
</author>
<author initials='L' surname='Andersson' fullname='Loa Andersson'>
<organization />
</author>
<author initials='J' surname='Tantsura' fullname='Jeff Tantsura'>
<organization />
</author>
<author initials='S' surname='Krishnaswamy' fullname='Sowmya Krishnaswamy'>
<organization />
</author>
<date year='2021' month='November' day='11' />
</front>
<seriesInfo name='Internet-Draft' value='draft-ietf-mpls-mldp-yang-10'/>
<format type='TXT' target='https://www.ietf.org/internet-drafts/draft-ietf-mpls-mldp-yang-10.txt'/>
</reference>

      </references>

      <section numbered="true" toc="default">
<name>Data Tree Example</name>
 <t>
   This section contains an example of an instance data tree in the JSON
   encoding <xref target="RFC7951"/>, containing both configuration and
   state data.
 </t>

 <figure>

 <figure anchor="ex_top">
   <name>Example topology</name> Topology</name>
   <artwork>
                  +---------------------+
                  |                     |
                  | Router 203.0.113.1  |
                  |                     |
                  +----------+----------+
                             |eth1
                             |2001:db8:0:1::1/64
                             |
                             |
                             |2001:db8:0:1::2/64
                  +----------+----------+
                  |                     |         |
                  |   Another Router    +---------| 2001:db8:0:2::/64
                  |                     |         |
                  +---------------------+
 </artwork></figure>

 <t>
   The configuration instance data tree for Router 203.0.113.1 in the
   above figure <xref
   target="ex_top"/> could be as follows:
 </t>

 <figure>
   <name>Example Configuration data Data in JSON</name>
   <artwork>
   <sourcecode type="json">

{
  "ietf-interfaces:interfaces": {
    "interface": [
      {
        "name": "eth1",
        "description": "An interface with LDP enabled.",
        "type": "iana-if-type:ethernetCsmacd",
        "ietf-ip:ipv6": {
          "address": [
            {
              "ip": "2001:db8:0:1::1",
              "prefix-length": 64
            }
          ],
          "forwarding": true
        }
      }
    ]
  },
  "ietf-routing:routing": {
    "router-id": "203.0.113.1",
    "control-plane-protocols": {
      "control-plane-protocol": [
        {
          "type": "ietf-mpls-ldp:mpls-ldp",
          "name": "ldp-1",
          "ietf-mpls-ldp:mpls-ldp": {
            "global": {
              "address-families": {
                "ietf-mpls-ldp-extended:ipv6": {
                  "enabled": true,
                  "transport-address": "2001:db8:0:1::1"
                }
              }
            },
            "discovery": {
              "interfaces": {
                "interface": [
                  {
                    "name": "eth1",
                    "address-families": {
                      "ietf-mpls-ldp-extended:ipv6": {
                        "enabled": true
                      }
                    }
                  }
                ]
              }
            }
          }
        }
      ]
    }
  }
}

 </artwork></figure>

 </sourcecode></figure>

 <t>
   The corresponding operational state data for Router 203.0.113.1
   could be as follows:
 </t>

 <figure>
   <name>Example Operational data Data in JSON</name>
   <artwork>
   <sourcecode type="json">
{
  "ietf-interfaces:interfaces": {
    "interface": [
      {
        "name": "eth1",
        "description": "An interface with LDP enabled.",
        "type": "iana-if-type:ethernetCsmacd",
        "phys-address": "00:00:5e:00:53:01",
        "oper-status": "up",
        "statistics": {
          "discontinuity-time": "2018-09-10T15:16:27-05:00"
        },
        "ietf-ip:ipv6": {
          "forwarding": true,
          "mtu": 1500,
          "address": [
            {
              "ip": "2001:db8:0:1::1",
              "prefix-length": 64,
              "origin": "static",
              "status": "preferred"
            },
            {
              "ip": "fe80::200:5eff:fe00:5301",
              "prefix-length": 64,
              "origin": "link-layer",
              "status": "preferred"
            }
          ],
          "neighbor": [
            {
              "ip": "2001:db8:0:1::2",
              "link-layer-address": "00:00:5e:00:53:02",
              "origin": "dynamic",
              "is-router": [null],
              "state": "reachable"
            },
            {
              "ip": "fe80::200:5eff:fe00:5302",
              "link-layer-address": "00:00:5e:00:53:02",
              "origin": "dynamic",
              "is-router": [null],
              "state": "reachable"
            }
          ]
        }
      }
    ]
  },
  "ietf-routing:routing": {
    "router-id": "203.0.113.1",
    "interfaces": {
      "interface": [
        "eth1"
      ]
    },
    "control-plane-protocols": {
      "control-plane-protocol": [
        {
          "type": "ietf-mpls-ldp:mpls-ldp",
          "name": "ldp-1",
          "ietf-mpls-ldp:mpls-ldp": {
            "global": {
              "address-families": {
                "ietf-mpls-ldp-extended:ipv6": {
                  "enabled": true,
                  "transport-address": "2001:db8:0:1::1"
                }
              }
            },
            "discovery": {
              "interfaces": {
                "interface": [
                  {
                    "name": "eth1",
                    "address-families": {
                      "ietf-mpls-ldp-extended:ipv6": {
                        "enabled": true,
                        "hello-adjacencies": {
                          "hello-adjacency": [
                            {
                              "adjacent-address":
                              "fe80::200:5eff:fe00:5302",
                              "flag": ["adjacency-flag-active"],
                              "hello-holdtime": {
                                "adjacent": 15,
                                "negotiated": 15,
                                "remaining": 9
                              },
                              "next-hello": 3,
                              "statistics": {
                                "discontinuity-time":
                                "2018-09-10T15:16:27-05:00"
                              },
                              "peer": {
                                "lsr-id": "203.0.113.2",
                                "label-space-id": 0
                              }
                            }
                          ]
                        }
                      }
                    }
                  }
                ]
              }
            },
            "peers": {
              "peer": [
                {
                  "lsr-id": "203.0.113.2",
                  "label-space-id": 0,
                  "label-advertisement-mode": {
                    "local": "downstream-unsolicited",
                    "peer": "downstream-unsolicited",
                    "negotiated": "downstream-unsolicited"
                  },
                  "next-keep-alive": 5,
                  "session-holdtime": {
                    "peer": 180,
                    "negotiated": 180,
                    "remaining": 78
                  },
                  "session-state": "operational",
                  "tcp-connection": {
                    "local-address": "fe80::200:5eff:fe00:5301",
                    "local-port": 646,
                    "remote-address": "fe80::200:5eff:fe00:5302",
                    "remote-port": 646
                  },
                  "up-time": 3438100,
                  "statistics": {
                    "discontinuity-time": "2018-09-10T15:16:27-05:00"
                  }
                }
              ]
            }
          }
        }
      ]
    }
  }
}

 </artwork></figure>
 </sourcecode></figure>

</section>

 <!-- Change Log
  v08 2020-02-27  KR

      <section numbered="false" toc="default">
      <name>Acknowledgments</name>
	<t>The authors would like to acknowledge <contact
	fullname="Eddie Chami"/>, <contact fullname="Nagendra
	Kumar"/>, <contact fullname="Mannan Venkatesan"/>, and <contact
	fullname="Pavan Beeram"/> for their contribution to this
	document. </t>

	<t> We also acknowledge <contact fullname="Ladislav Lhotka"/>,
	<contact fullname="Jan Lindblad"/>, <contact fullname="Tom
	Petch"/>, <contact fullname="Yingzhen Qu"/>, and <contact
	fullname="Benjamin Kaduk"/> for their detailed review of the
	model during WG and IESG Review
 --> processes.</t>

      </section>

<section numbered="false" toc="default">
<name>Contributors</name>

<contact fullname="Danial Johari">
  <organization>Cisco Systems</organization>
  <address>
    <email>dajohari@cisco.com</email>
  </address>
</contact>

<contact fullname="Loa Andersson">
  <organization>Huawei Technologies</organization>
  <address>
    <email>loa@pi.nu</email>
  </address>
</contact>

<contact fullname="Jeff Tantsura">
<organization>Apstra</organization>
<address>
  <email>jefftant.ietf@gmail.com</email>
</address>
</contact>

<contact fullname="Matthew Bocci">
  <organization>Nokia</organization>
  <address>
    <email> matthew.bocci@nokia.com</email>
  </address>
</contact>

<contact fullname="Reshad Rahman">

  <address>
    <email>reshad@yahoo.com</email>

  </address>
</contact>

<contact fullname="Stephane Litkowski">
  <organization>Cisco Systems</organization>
  <address>
    <email>slitkows@cisco.com</email>
  </address>
</contact>

</section>

</back>

</rfc>