<?xml version="1.0" encoding="US-ASCII"?>
<!DOCTYPE rfc SYSTEM "rfc2629.dtd">
<?rfc toc="yes"?>
<?rfc tocompact="yes"?>
<?rfc tocdepth="3"?>
<?rfc tocindent="yes"?>
<?rfc symrefs="yes"?>
<?rfc sortrefs="yes"?>
<?rfc comments="yes"?>
<?rfc inline="yes"?>
<?rfc compact="yes"?>
<?rfc subcompact="no"?>
<rfc category="std"
     docName="draft-chen-spring-sr-bind-protect-arch-01"
     ipr="trust200902">
  <front>
    <title abbrev="SR Binding Protection">SR Path Binding Protection Architecture</title>
 


     <author initials="H" surname="Chen" fullname="Huaimo Chen">
      <organization>Futurewei</organization>
      <address>
        <postal>
          <street></street>
          <city>Boston, MA</city>
          <region></region>
          <code></code>
          <country>USA</country>
        </postal>
        <email>hchen.ietf@gmail.com</email>
      </address>
    </author>

<!--
    <author initials="B" fullname="Bruno Decraene" 
            surname="Decraene">
      <organization> Orange </organization>
      <address>
        <postal>
          <street></street>
          <city></city>
          <region></region>
          <country>France</country>
        </postal>
        <email>bruno.decraene@orange.com</email>
      </address>
     </author>

   <author fullname="Andrew Stone" initials="A. " surname="Stone">
      <organization>Nokia</organization>
      <address>
        <postal>
          <street>600 March Road</street>
          <city>Kanata, Ontario</city>
          <code> </code>
          <country>Canada</country>
        </postal>
        <email>andrew.stone@nokia.com</email>
      </address>
    </author>
-->
   <author fullname="Zhibo Hu" initials="Z. " surname="Hu">
      <organization>Huawei Technologies</organization>
      <address>
        <postal>
          <street>Huawei Bld., No.156 Beiqing Rd.</street>
          <city>Beijing</city>
          <code>100095</code>
          <country>China</country>
        </postal>
        <email>huzhibo@huawei.com</email>
      </address>
    </author>

    <author initials="W" fullname="Weiqiang Cheng" 
            surname="Cheng">
      <organization> China Mobile </organization>
      <address>
        <postal>
          <street></street>
          <city></city>
          <region></region>
          <country>China</country>
        </postal>
        <email>chengweiqiang@chinamobile.com</email>
      </address>
     </author>

     <author initials="A" fullname="Aijun Wang" 
            surname="Wang">
      <organization>China Telecom</organization>
      <address>
        <postal>
          <street>Beiqijia Town, Changping District</street>
          <city>Beijing</city>
          <region> </region>
          <code>102209</code>
          <country>China</country>
        </postal>
        <email>wangaj3@chinatelecom.cn</email>
      </address>
    </author>
	
    <author fullname="Gyan S. Mishra" initials="G" surname="Mishra">
      <organization>Verizon</organization>
      <address>
        <postal>
          <street>13101 Columbia Pike</street>
          <city>Silver Spring</city>
          <code>MD 20904</code>
          <country>USA</country>
        </postal>
        <phone> 301 502-1347</phone>
        <email>gyan.s.mishra@verizon.com</email>
      </address>
    </author>

	
    <date year="2024"/>

    <abstract>
      <t>
	  This document describes a architecture of 
          fast re-route protection for binding SIDs 
          on SR paths including SRv6 paths and SR-MPLS paths. 
          The SR paths are in a single domain or
          cross two domains. 
          The two domains are administrated by one provider
          or two different providers.
      </t>

      <t/>
    </abstract>

    <note title="Requirements Language">
      <t>The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
      "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this
      document are to be interpreted as described in <xref
      target="RFC2119"/> <xref target="RFC8174"/>
      when, and only when, they appear in all capitals, as shown here.</t>
    </note>
  </front>

  <middle>
    <section title="Introduction">
      <t><xref target="I-D.ietf-rtgwg-segment-routing-ti-lfa"/> describes 
	  a segment routing (SR) fast re-route (FRR) mechanism that provides 
          FRR protection for a node SID and adjacency SID 
 	  of a node on an SR path by the direct
 	  neighbor or say point of local repair (PLR) to the failure.
  
          <xref target="I-D.hu-spring-segment-routing-proxy-forwarding"/> 
	  proposes a mechanism that provides FRR protection for 
          a binding SID of a transit node on a SR path within a single
          domain. 
       </t>
	  
       <t>
	  This document describes a architecture of 
          fast re-route protection for binding SIDs 
          on SR paths including SRv6 paths and SR-MPLS paths. 
          The SR paths are in a single domain or
          cross two domains. 
          The two domains are administrated by one provider
          or two different providers.</t>
<!--
     <section title="Terminology">
     <t>
     <list style="hanging" hangIndent="4">
     <t hangText="SR:">Segment Routing.</t>
     <t hangText="PLR:">Point of Local Repair.</t>
     <t hangText="LSP:">Link State Protocol Data Unit (PDU) in IS-IS.</t>
     <t hangText="LSA:">Link State Advertisement in OSPF.</t>
     <t hangText="LS:">Link State, which is LSP or LSA.</t>
     </list></t>
     </section>
-->
 <!-- Terminology -->
    </section>

    <section title="Example SR Path Binding Protections">     
       <t>This section illustrates the FRR protection
          for binding SIDs of nodes on SR paths 
          through examples.
          It shows the procedure on every node on two SR paths 
          without any failure in three cases below:
          <list style="numbers">
            <t>Single Domain.</t>
            <t>One Administrative Domain (OAD): 
               One provider Administrates two Domains.</t>
            <t>Two Administrative Domains (TAD): 
               Two differnt providers Administrate two Domains. </t>
          </list>
          In addition, when the node with binding SIDs fails,
          the procedure on each of the related node
          is illustrated in different cases 
          for two different time periods.</t>

      <section anchor="network1d-sr-path"  
               title="Example Single Domain Network with SR Paths">
        <t><xref target="SR-Protect-Bind-A-1d"/> shows an example 
        single domain network with two SR paths. 
        It is used to explain the
        mechanism of SR path binding protection in single domain.
         <figure
            anchor="SR-Protect-Bind-A-1d"
            title="Single Domain Network with SR Paths with Binding SIDs">
            <artwork><![CDATA[
      !                                             !
      !    [P1]-----[P3]----[B1]----[Q1]----[Q3]    !
      !    / | \   / | \   / | \   / | \   / | \    ! 
      !   /  |  \ /  |  \ /  |  \ /  |  \ /  |  \   !
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \2 |  / \  |  / \  |  /   ! 
      !    \ | /   \ | /   \ | /   \ | /   \ | /    ! SID-X:
      !    [P2]-----[P4]----[B2]----[Q2]-----[Q4]   !   node SID of X
      !                                             ! SID-X-Y:
      ! <------------    Domain 1    -------------> !  Adj SID of X-Y
      !                                             !
SR Path 1: A->P1->B1->BSID-B1(->Q1->Q3->C);BSID-B1 w/ SID-list 1
SR Path 2: A->P1->P3->B1->BSID2-B1(->Q1->Q3->C);BSID2-B1 w/ SID-list 3
SID-list 1: {SID-Q1,SID-Q3,SID-C};    SID-list 2: {SID-Q1,SID-Q3,SID-C}
SID-list 3: {SID-B1-Q1,SID-Q3,SID-C}; SID-list 4: {SID-Q1,SID-Q3,SID-C}
SID-list 5: {SID-B2,SID-Q1,SID-Q3,SID-C} - backup path for B1 on Path 1 
SID-list 6: {SID-B2,SID-Q1,SID-Q3,SID-C} - backup path for B1 on Path 2
]]></artwork>
          </figure> 

        The cost of each link is 1 by default, except for
        the cost of the link between P3 and B2 is 2 indicated by
        number 2 on the link.
  
        SR path 1 uses node SIDs. 

         A Binding SID (BSID) of node B1, named BSID-B1, is associated
         with SID-list 1 {SID-Q1, SID-Q3, SID-C}.

        The path segment from node A to node B1 is represented by 
        SID-P1 and SID-B1.
        The path segment from node B1 to node C is represented by 
        BSID-B1 and SID-list 1  
        with which BSID-B1 is associated.
         </t>

       <t>SR path 2 uses adjacency SIDs. 

         Another Binding SID of B1, named BSID2-B1, is associated
         with SID-list 3 {SID-B1-Q1, SID-Q3, SID-C}. 
         Note: BSID2-B1 is different from BSID-B1.
         The first SID in SID-list 3 is the adjacency SID of 
         the adjacency from B1 to Q1.

        The path segment from node A to node B1 is represented by 
        SID-A-P1, SID-P1-P3 and SID-P3-B1.
        The path segment from node B1 to node C is represented by 
        BSID2-B1 and SID-list 3  
        with which BSID2-B1 is associated.
         </t>

      </section> 
<!-- Example One domain Network with SR Paths  -->

      <section anchor="network-sr-path"  
               title="Example Two Domain Network with SR Paths">
        <t><xref target="SR-Protect-Bind-A"/> shows an example 
        two domain network with two SR paths. 
        It is used to explain the
        mechanism of SR path across domains binding protection.
         <figure
            anchor="SR-Protect-Bind-A"
            title="Two domain Network with SR Paths with Binding SIDs of Borders">
            <artwork><![CDATA[
      !                      !       !              !
      !    [P1]-----[P3]----[B1]----[B3]----[Q3]    !
      !    / | \   / | \   / | \   / | \   / | \    ! 
      !   /  |  \ /  |  \ /  |  \ /  |  \ /  |  \   !
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \2 |  / \  |  / \  |  /   ! 
      !    \ | /   \ | /   \ | /   \ | /   \ | /    ! SID-X:
      !    [P2]-----[P4]----[B2]----[B4]-----[Q4]   !   node SID of X
      !                      !       !              ! SID-X-Y:
      ! <--- Domain 1 -----> !       !<- Domain 2 ->!  Adj SID of X-Y
      !                      !       !              !
SR Path 1: A->P1->B1->B3->BSID-B3(->Q3->C);BSID-B3 w/ SID-list 1
SR Path 2: A->P1->P3->B1->B3->BSID2-B3(->Q3->C);BSID2-B3 w/ SID-list 3
SID-list 1: {SID-Q3,SID-C};    BSID-B4  w/ SID-list 2: {SID-Q3,SID-C}
SID-list 3: {SID-B3-Q3,SID-C}; BSID2-B4 w/ SID-list 4: {SID-Q3,SID-C}
SID-list 5: {SID-B4,SID-Q3,SID-C} -backup bath for B3 on Path 1 in OAD
SID-list 6: {SID-B4,SID-Q3,SID-C} -backup bath for B3 on Path 2 in OAD
SID-list 7: {SID-B4,BSID-B4}  - backup bath for B3 on Path 1 in TAD
SID-list 8: {SID-B4,BSID2-B4} - backup bath for B3 on Path 2 in TAD]]></artwork>
          </figure> 

        The cost of each link is 1 by default, except for
        the cost of the link between P3 and B2 is 2 indicated by
        number 2 on the link.
  
        SR path 1 crosses two domains 
        (Domain 1 and Domain 2) and uses node SIDs. 

         A Binding SID of border node B3, named BSID-B3, is associated
         with SID-list 1.

        The path segment from node A to node B3 is represented by 
        SID-P1, SID-B1 and SID-B3.
        The path segment from node B3 to node C is represented by 
        BSID-B3 and SID-list 1  
        with which BSID-B3 is associated.
         </t>

       <t>For BSID-B3 associated with SID-list 1 
          on border node B3 along SR path 1,
          there is an alternate border node B4 corresponding to B3.</t>

       <t>SR path 2 crosses two domains 
        (Domain 1 and Domain 2) and uses adjacency SIDs. 

         Another Binding SID of border node B3, named BSID2-B3, 
         is associated with SID-list 3. 
         Note: BSID2-B3 is different from BSID-B3.
         The first SID in SID-list 3 is the adjacency SID of 
         the adjacency from B3 to Q3.

        The path segment from node A to node B3 is represented by 
        SID-A-P1, SID-P1-P3, SID-P3-B1 and SID-B1-B3.
        The path segment from node B3 to node C is represented by 
        BSID2-B3 and SID-list 3  
        with which BSID2-B3 is associated.
         </t>

       <t>For BSID2-B3 associated with SID-list 3 
          on B3 for SR path 2,
          there is an alternate border node B4 corresponding to B3.</t>

      </section> 
<!-- Example Network with SR Paths  -->

      <section anchor="info-distribution"  
               title="Binding Protection Information Distribution">
       <t>
          This section describes the binding protection information 
          distribution 
          for three cases: Single Domain, OAD and TAD.</t>

      <section anchor="one-domain"  
               title="Single Domain">
       <t>
          One piece of information, which represents a backup path
          for the failure of node B1 with a BSID, is distributed.</t>

        <t>For SR path 1, this one piece is BSID-B1,
          SID-list 5 and 
          ID-B1 (i.e., Identifier (ID) of B1).

          SID-list 5 contains the SIDs for the backup path, which   
          includes SID-B2 and SIDs for the path segment 
          corresponding to SID-list 1 with which 
          BSID-B1 is associated on B1.

          SID-list 5 is SID-B2 prepending SID-list 1 
          since the first SID in SID-list 1 is a node SID.
          SID-list 5 is {SID-B2, SID-Q1, SID-Q3, SID-C}.</t>

       <t>This one piece (i.e., BSID-B1, SID-list 5 
           and ID-B1) is sent to 
          the upstream neighbor (i.e., P3 on SR path 1) of B1.
          It is also sent to the closest upstream endpoint node 
          (i.e., P1 on SR path 1) of B1 since B1 is a loose hop 
          on SR path 1, which is indicated by node SID of B1 
          (i.e., SID-B1) on SR path 1.
       </t>

        <t>For SR path 2, this one piece is BSID2-B1,
           SID-list 6 and 
          ID-B1 (i.e., Identifier (ID) of B1).

          SID-list 6 contains the SIDs for the backup path, which   
          includes SID-B2 and SIDs for the path segment 
          corresponding to SID-list 3 with which 
          BSID2-B1 is associated on B1.

          The first SID in SID-list 3
          is the adjacency SID of the adjacency from B1 to Q1. 
          SID-B2, SID-Q1 (the node SID of the remote node of 
          the adjacency SID-B1-Q1),
          and the other SIDs in SID-list 3 constitutes SID-list 6,
          which is {SID-B2, SID-Q1, SID-Q3, SID-C}.</t>

       <t>This one piece (i.e., BSID2-B1, SID-list 6 
           and ID-B1) is sent to 
          the upstream neighbor (i.e., P3 on SR path 2) of B1.
          It is not sent to any other upstream node since 
          B1 is not a loose hop on SR path 2.
       </t>
      </section> 
<!-- Single Domain -->

      <section anchor="one-provider"  
               title="One Administrative Domain">
       <t>
          When domain 1 and domain 2 are administrated by one provider,
          one piece of information is distributed.
          This one piece of information represents a backup path
          for the failure of border node B3.</t>

        <t>For SR path 1, this one piece is BSID-B3,
          SID-list 5 and 
          ID-B3 (i.e., Identifier (ID) of B3).

          SID-list 5 represents a backup path
          for the failure of B3.
          It contains the SIDs for the path segment  
          to border node B4 and the path segment 
          corresponding to SID-list 1 with which 
          BSID-B3 is associated on B3.

          SID-list 5 is SID-B4 prepending SID-list 1 
          since the first SID in SID-list 1 is a node SID.
          It is {SID-B4, SID-Q3, SID-C}.</t>

       <t>This one piece (i.e., BSID-B3, SID-list 5 
           and ID-B3) is sent to 
          the upstream neighbor (i.e., B1 on SR path 1) of B3.
          The closest upstream endpoint node of B3 is 
          B1 on SR path 1. 
          The piece is not sent to B1 again.
       </t>

        <t>For SR path 2, this one piece is BSID2-B3,
           SID-list 6 and 
          ID-B3 (i.e., Identifier (ID) of B3).

          SID-list 6 represents a backup path
          for the failure of B3. 
          It contains the SIDs for the path segment  
          to border node B4 and the path segment 
          corresponding to SID-list 3 with which 
          BSID2-B3 is associated on B3.

          The first SID in SID-list 3
          is the adjacency SID of the adjacency from B3 to Q3. 
          SID-B4, SID-Q3 (the node SID of the remote node of 
          the adjacency SID-B3-Q3),
          and the other SIDs in SID-list 3 constitutes SID-list 6,
          which is {SID-B4, SID-Q3, SID-C}.</t>

       <t>This one piece (i.e., BSID2-B3, SID-list 6 
           and ID-B3) is sent to 
          the upstream neighbor (i.e., B1 on SR path 2) of B3.
       </t>

      </section>  
      <!-- "Two domains belong to one provider" -->

      <section anchor="two-providers"  
               title="Two Administrative Domains">
       <t>
          When domain 1 and domain 2 are administrated 
          by two different providers,
          the SIDs in domain 2 can not be distributed to any node 
          in domain 1 except for the SIDs of border nodes 
          such as B3 and B4 in domain 2.

          Thus SID-list 1 
          associated with
          BSID-B3 in SR path 1, which contains the SIDs in domain 2, 
          can not be distributed to any node in domain 1.
 
          In this case, two pieces of information are distributed.
          These two pieces of information represent a backup path
          for the failure of border node B3 on SR path 1.</t>

       <t>One piece is a binding SID of border node B4 (BSID-B4)
          associated with SID-list 2 
          corresponding to SID-list 1 with which 
          BSID-B2 in SR path 1 is associated.
          SID-list 2 is SID-list 1 since the first SID in SID-list 1
          is a node SID.
          This one piece (i.e., BSID-B4 and SID-list 2) 
          is sent to alternate border node B4 corresponding to B3.</t>

       <t>
          The other piece is BSID-B3, SID list 7  
          and ID-B3 (i.e., Identifier (ID) of B3).
          This other piece (i.e., BSID-B3, SID list 7 and ID-B3) 
          is sent to 
          the upstream neighbor (e.g., B1 on SR path 1) of B3.
          In addition, it is sent to
          the closest upstream endpoint node 
          (e.g., B1 on SR path 1) of B3
          if B3 is a loose hop and the endpoint node is not neighbor of B3.
       </t>

       <t>BSID2-B3 in SR path 2 is associated with SID-list 3
          {SID-B1-Q3, SID-C}.
          The two pieces of information representing a backup path
          for the failure of border node B3 on SR path 2 are as follows.</t>

       <t>One piece is another binding SID of border node B4 (BSID2-B4)
          associated with SID-list 4 
          corresponding to SID-list 3.

          The first SID in SID-list 3
          is the adjacency SID of the adjacency from B3 to Q3. 
          The node SID of the remote node of the adjacency (SID-Q3)
          and the other SIDs in SID-list 3 constitutes SID-list 4,
          which is {SID-Q3, SID-C}.
          This one piece (i.e., BSID2-B4 and SID-list 4) 
          is sent to alternate border node B4 corresponding to B3.</t>

       <t>
          The other piece is BSID2-B3, SID-list 8 
          and ID-B3 (i.e., Identifier (ID) of B3).
          This piece (i.e., BSID2-B3, SID-list 8 and ID-B3) 
          is sent to 
          the upstream neighbor (e.g., B1 on SR path 2) of B3.
          Since B3 is not a loose hop on SR path 2,
          this other piece is not sent to any other upstream node of B3 
          on SR path 2.
       </t>

      </section>  
      <!-- "Two domains owned by two providers" -->
      </section> 
<!-- Binding Protection Information Distribution  -->

      <section anchor="without-failure"  
               title="Without Any Failure">
       <t>This section illustrates the procedure and 
          the result of the procedure 
          on every node on each of SR path 1 using node SIDs 
          and SR path 2 using adjacency SIDs.

          Note: the path itself does not need to make up of all of 
          the same type of SIDs, but rather the difference in behavior is on 
          the point of repair if the top SID before the BSID is 
          node SID or adjacency SID. The SID type preceding the SID before 
          the BSID in the path is not relevant.</t>


      <section anchor="without-failure-1d"  
               title="Single Domain">

      <section anchor="without-failure-path1-1d"  
               title="SR Path using Node SIDs">
       <t><xref target="SR-Protect-Bind-path1-normal-1d"/> shows the 
          result of the procedure on every node on SR path 1   
          in single domain using node SIDs
          without any failure. 

         <figure
            anchor="SR-Protect-Bind-path1-normal-1d"
            title="SR Path 1 in Single Domain in Normal Operations">
            <artwork><![CDATA[ 2.{SID-B1,BSID-B1}Pkt
                |  3.{SID-B1,BSID-B1}Pkt
                |        |    4.{SID-Q1,SID-Q3,SID-C}Pkt 
                |        |       |    5.{SID-Q3,SID-C}Pkt
                |        |       |       |
      !         v        v       v       v          !
      !    [P1]-----[P3]----[B1]----[Q1]----[Q3]    !
      !    /                                   \ 6.{SID-C}Pkt
     Pkt  /1.{SID-P1,SID-B1,BSID-B1}Pkt         \   !
[CE1]---[A]                                     [C]---[CE2]
      !   \                                     /  7.Pkt
      :                                             :
      ! <------------    Domain 1    -------------> !
SR Path 1: A->P1->B1->BSID-B1(->Q1->Q3->C);BSID-B1 w/ SID-list 1
SID-list 1: {SID-Q1,SID-Q3,SID-C}; SID-list 2: {SID-Q1,SID-Q3,SID-C}]]></artwork>
          </figure>  

          The procedure on each node is below:
          <list style="numbers">
            <t>Node A as ingress of SR path 1 adds SID-P1, 
            SID-B1 and BSID-B1 (binding SID (BSID) of B1)
            into a packet (Pkt) received from CE1 and sends the packet 
            with the SIDs to node P1. 
            The packet sent to P1 is represented by
              "1. {SID-P1, SID-B1, BSID-B1}Pkt".
            </t>
            <t>Node P1 pops its SID-P1 from the packet received,
               sends the packet with top SID (SID-B1) to P3 
               along the IGP shortest path to B1 
               according to its FIB entry for SID-B1.
               The packet sent to P3 is represented by
              "2. {SID-B1, BSID-B1}Pkt".
            </t>
            <t>Node P3 
               sends the packet with top SID (SID-B1) to B1
               along the IGP shortest path to B1.
               The packet sent to B1 is represented by
              "3. {SID-B1, BSID-B1}Pkt".
            </t>
            <t>Node B1 pops its SID-B1 from the packet received,
               replaces its BSID-B1 with SID-list 1,
               and sends the packet to Q1 according to the top SID (SID-Q1)
               in the packet. 
               The packet sent to Q1 is represented by
              "4. {SID-Q1, SID-Q3, SID-C}Pkt".
            </t>
            <t>Node Q1 pops its SID-Q1 from the packet received, 
               and sends the packet to node Q3 
               according to the top SID SID-Q3 in the packet.
               The packet sent to Q3 is represented by
              "5. {SID-Q3, SID-C}Pkt". 
            </t>
            <t>Node Q3 pops its SID-Q3 from the packet received, 
              and sends the packet to node C 
              according to the top SID SID-C in the packet. 
               The packet sent to C is represented by
              "6. {SID-C}Pkt". 
            </t>
            <t>Node C pops its SID-C and gets the packet without any SIDs, 
               which is represented by
              "7. Pkt". 
            </t>
          </list>
</t>

      </section> 
<!-- "SR Path using Node SIDs" -->

      <section anchor="without-failure-path2-1d"  
               title="SR Path using Adjacency SIDs">

       <t><xref target="SR-Protect-Bind-path2-normal-1d"/> shows the 
          result of the procedure on every node on SR path 2 
          in single domain using adjacency SIDs without any failure. 

         <figure
            anchor="SR-Protect-Bind-path2-normal-1d"
            title="SR Path 2 in Single Domain in Normal Operations">
            <artwork><![CDATA[ 2.{SID-P3-B1,BSID2-B1}Pkt
                |  3.{BSID2-B1}Pkt
                |        |    4.{SID-Q3,SID-C}Pkt 
                |        |       |    5.{SID-Q3,SID-C}Pkt
                |        |   !   |       |
      !         v        v   !   v       v          !
      !    [P1]-----[P3]----[B1]----[Q1]----[Q3]    !
      !    /                                   \ 6.{SID-C}Pkt
     Pkt  /1.{SID-P1-P3,SID-P3-B1,BSID2-B1}Pkt  \   !
[CE1]---[A]                                     [C]---[CE2]
      !   \                                     /  7.Pkt
      :                                             :
      ! <------------    Domain 1    -------------> !
SR Path 2: A->P1->P3->B1->BSID2-B1(->Q1->Q3->C);BSID2-B1 w/ SID-list 3
SID-list 3: {SID-B1-Q1,SID-Q3,SID-C}; SID-list 4: {SID-Q1,SID-Q3,SID-C}]]></artwork>
          </figure>  

          The procedure on each node is below:
          <list style="numbers">
            <t>Node A as ingress of SR path 2 adds SID-P1-P3, 
            SID-P3-B1 and BSID2-B1
            into a packet (Pkt) received from CE1 and sends the packet 
            with the SIDs to node P1. 
            The packet sent to P1 is represented by
              "1. {SID-P1-P3, SID-P3-B1, BSID2-B1}Pkt".
            </t>
            <t>Node P1 pops its SID-P1-P3 from the packet received,
               sends the packet to P3.
               The packet sent to P3 is represented by
              "2. {SID-P3-B1, BSID2-B1}Pkt".
            </t>
            <t>Node P3 pops its SID-P3-B1 from the packet received,
               sends the packet to B1.
               The packet sent to B1 is represented by
              "3. {BSID2-B1}Pkt".
            </t>
            <t>Node B1 
               replaces its BSID2-B1 with SID-list 3,
               pops its SID-B1-Q1,
               and sends the packet to Q1. 
               The packet sent to Q1 is represented by
              "4. {SID-Q3, SID-C}Pkt".
            </t>
            <t>Node Q1 sends the packet to node Q3 
               according to the top SID SID-Q3 in the packet.
               The packet sent to Q3 is represented by
              "5. {SID-Q3, SID-C}Pkt". 
            </t>
            <t>Node Q3 pops its SID-Q3 from the packet received, 
              and sends the packet to node C 
              according to the top SID SID-C in the packet. 
               The packet sent to C is represented by
              "6. {SID-C}Pkt". 
            </t>
            <t>Node C pops its SID-C and gets the packet without any SIDs, 
               which is represented by
              "7. Pkt". 
            </t>
          </list>
</t>
      </section> 
<!-- "SR Path using Adjacency SIDs" -->

      </section> 
<!-- Single Domain  -->


      <section anchor="without-failure-2d"  
               title="Two Domains">

      <section anchor="without-failure-path1"  
               title="SR Path using Node SIDs">
       <t><xref target="SR-Protect-Bind-path1-normal"/> shows the 
          result of the procedure on every node on SR path 1  
          across two domains using node SIDs
          without any failure. 

         <figure
            anchor="SR-Protect-Bind-path1-normal"
            title="SR Path 1 across Two Domains in Normal Operations">
            <artwork><![CDATA[ 2.{SID-B1,SID-B3,BSID-B3}Pkt
                |  3.{SID-B1,SID-B3,BSID-B3}Pkt
                |        |    4.{SID-B3,BSID-B3}Pkt 
                |        |       |    5.{SID-Q3,SID-C}Pkt
                |        |   !   |   !   |
      !         v        v   !   v   !   v          !
      !    [P1]-----[P3]----[B1]----[B3]----[Q3]    !
      !    /                                   \ 6.{SID-C}Pkt
     Pkt  /1.{SID-P1,SID-B1,SID-B3,BSID-B3}Pkt  \   !
[CE1]---[A]                                     [C]---[CE2]
      !   \                                     /  7.Pkt
      :                                             :
      ! <--- Domain 1 -----> !       !<- Domain 2 ->!
SR Path 1: A->P1->B1->B3->BSID-B3(->Q3->C);BSID-B3 w/ SID-list 1
SID-list 1: {SID-Q3,SID-C};        SID-list 2: {SID-Q3,SID-C}]]></artwork>
          </figure>  

          The procedure on each node is below:
          <list style="numbers">
            <t>Node A as ingress of SR path 1 adds SID-P1, 
            SID-B1, SID-B3 and BSID-B3 (binding SID (BSID) of B3)
            into a packet (Pkt) received from CE1 and sends the packet 
            with the SIDs to node P1. 
            The packet sent to P1 is represented by
              "1. {SID-P1, SID-B1, SID-B3, BSID-B3}Pkt".
            </t>
            <t>Node P1 pops its SID-P1 from the packet received,
               sends the packet with top SID (SID-B1) to P3 
               along the IGP shortest path to B1 
               according to its FIB entry for SID-B1.
               The packet sent to P3 is represented by
              "2. {SID-B1, SID-B3, BSID-B3}Pkt".
            </t>
            <t>Node P3 
               sends the packet with top SID (SID-B1) to B1
               along the IGP shortest path to B1.
               The packet sent to B1 is represented by
              "3. {SID-B1, SID-B3, BSID-B3}Pkt".
            </t>
            <t>Node B1 pops its SID-B1 from the packet received and
               sends the packet with top SID (SID-B3) to B3
               along the routing path to B3.
               The packet sent to B3 is represented by
              "4. {SID-B3, BSID-B3}Pkt".
            </t>
            <t>Node B3 pops its SID-B3 from the packet received,
               replaces its BSID-B3 with SID-list 1,
               and sends the packet to Q3 according to the top SID (SID-Q3)
               in the packet. 
               The packet sent to Q3 is represented by
              "5. {SID-Q3, SID-C}Pkt".
            </t>
            <t>Node Q3 pops its SID-Q3 from the packet received, 
              and sends the packet to node C 
              according to the top SID SID-C in the packet. 
               The packet sent to C is represented by
              "6. {SID-C}Pkt". 
            </t>
            <t>Node C pops its SID-C and gets the packet without any SIDs, 
               which is represented by
              "7. Pkt". 
            </t>
          </list>
</t>

      </section> 
<!-- "SR Path using Node SIDs" -->

      <section anchor="without-failure-path2"  
               title="SR Path using Adjacency SIDs">

       <t><xref target="SR-Protect-Bind-path2-normal"/> shows the 
          result of the procedure on every node on SR path 2 
          across two domains using adjacency SIDs without any failure. 

         <figure
            anchor="SR-Protect-Bind-path2-normal"
            title="SR Path 2 across Two Domains in Normal Operations">
            <artwork><![CDATA[ 2.{SID-P3-B1,SID-B1-B3,BSID2-B3}Pkt
                |  3.{SID-B1-B3,BSID2-B3}Pkt
                |        |    4.{BSID2-B3}Pkt 
                |        |       |    5.{SID-C}Pkt
                |        |   !   |   !   |
      !         v        v   !   v   !   v          !
      !    [P1]-----[P3]----[B1]----[B3]----[Q3]    !
      !    /                                   \ 6.{SID-C}Pkt
     Pkt  /1.{SID-P1-P3,SID-P3-B1,              \   !
[CE1]---[A]   SID-B1-B3,BSID2-B3}Pkt            [C]---[CE2]
      !   \                                     /  7.Pkt
      :                                             :
      ! <--- Domain 1 -----> !       !<- Domain 2 ->!
SR Path 2: A->P1->P3->B1->B3->BSID2-B3(->Q3->C);BSID2-B3 w/ SID-list 3
SID-list 3: {SID-B3-Q3,SID-C};     SID-list 4: {SID-Q3,SID-C}]]></artwork>
          </figure>  

          The procedure on each node is below:
          <list style="numbers">
            <t>Node A as ingress of SR path 2 adds SID-P1-P3, 
            SID-P3-B1, SID-B1-B3 and BSID2-B3
            into a packet (Pkt) received from CE1 and sends the packet 
            with the SIDs to node P1. 
            The packet sent to P1 is represented by
              "1. {SID-P1-P3, SID-P3-B1, SID-B1-B3, BSID2-B3}Pkt".
            </t>
            <t>Node P1 pops its SID-P1-P3 from the packet received,
               sends the packet to P3.
               The packet sent to P3 is represented by
              "2. {SID-P3-B1, SID-B1-B3, BSID2-B3}Pkt".
            </t>
            <t>Node P3 pops its SID-P3-B1 from the packet received,
               sends the packet to B1.
               The packet sent to B1 is represented by
              "3. {SID-B1-B3, BSID2-B3}Pkt".
            </t>
            <t>Node B1 pops its SID-B1-B3 from the packet received,
               sends the packet to B3.
               The packet sent to B3 is represented by
              "4. {BSID2-B3}Pkt".
            </t>
            <t>Node B3 
               replaces its BSID2-B3 with SID-list 3,
               pops its SID-B1-Q3,
               and sends the packet to Q3. 
               The packet sent to Q3 is represented by
              "5. {SID-C}Pkt".
            </t>
            <t>Node sends the packet to node C 
              according to the top SID SID-C in the packet. 
               The packet sent to C is represented by
              "6. {SID-C}Pkt". 
            </t>
            <t>Node C pops its SID-C and gets the packet without any SIDs, 
               which is represented by
              "7. Pkt". 
            </t>
          </list>
</t>
      </section> 
<!-- "SR Path using Adjacency SIDs" -->
      </section> 
<!-- Two Domains  -->
      </section> 
<!-- Without Any Failure  -->


      <section anchor="b1-2domains-1provider-1d"  
               title="Failure of Node in Single Domain">

        <t>This section illustrates the procedure and the result of 
           the procedure on each of the related nodes on 
           SR path 1 using node SIDs and SR path 2 using adjacency SIDs 
           after node B1 with BSIDs in single domain failed.</t>

      <section anchor="b1-2domains-1provider-path1-1d"  
               title="SR Path using Node SIDs">

        <t>This section illustrates the procedure and 
           the result of the procedure on each of 
           the related nodes on SR path 1 using node SIDs 
           after node B1 with BSID-B1 failed.</t>

      <section anchor="before-igp-converges1-1d"  
               title="Before IGP Converges on Failure">
       <t><xref target="SR-Protect-Bind-path1-b1-fail-1-1-1d"/> shows the 
          result of executing procedure on each of the related nodes 
          on SR path 1 
          when node B1 failed and 
          before the IGP converges on the failure. 

         <figure
            anchor="SR-Protect-Bind-path1-b1-fail-1-1-1d"
            title="B1 on SR Path 1 failed and before IGP converges">
            <artwork><![CDATA[
 2.{SID-B1,BSID-B1}Pkt                5.{SID-Q3,SID-C}Pkt
                |            !           |
      !         v            !           v          !
      !    [P1]-----[P3]----[B1]----[Q1]----[Q3]    !
      !    / | \   / | \3.{SID-B2,SID-Q1,    | \ 6.{SID-C}Pkt
     Pkt  /1.{..}Pkt |  \  SID-Q3,SID-C}Pkt  |  \   ! 
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \2 |  / \  |  / \  |  /  7.Pkt
      !    \ | /   \ | /   \ | /4.{SID-Q1,SID-Q3,SID-C}Pkt
      !    [P2]-----[P4]----[B2]----[Q2]-----[Q4]   !
      :                                             :
      ! <------------    Domain 1    -------------> !
SR Path 1: A->P1->B1->BSID-B1(->Q1->Q3->C); BSID-B1 w/ SID-list 1
SID-list 1:{SID-Q1,SID-Q3,SID-C}
SID-list 5:{SID-B2,SID-Q1,SID-Q3,SID-C} - backup path for B1's failure]]></artwork>
          </figure>  

          The procedure and the result of the procedure on each of
          nodes A, P1, Q1, Q3 and C are the same as
          those described in <xref target="without-failure-path1-1d"/>.

          The procedure and the result of the procedure on each of 
          nodes P3 (neighbor of B1) and B2  
          are as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="3.">Neighbor P3 pops SID-B1 from the packet received,
               replaces BSID-B1 in the packet with SID-list 5 
               according to its FIB entry 
               for BSID-B1 of node B1 with ID-B1, and
               sends the packet to B2 according to the top SID (i.e., SID-B2)
               in the packet without
               going through failed B1 using TI-LFA.
               The packet sent to B2 is represented by
              "3. {SID-B2, SID-Q1, SID-Q3, SID-C}Pkt".
            </t>
            <t hangText="4.">Node B2 pops its SID (i.e., SID-B2) 
               from the packet received, and
               sends the packet to Q1 according to the top SID (SID-Q1) 
               in the packet.
               The packet sent to Q1 is represented by
              "4. {SID-Q1, SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section> 
<!-- Before IGP Converges on Failure  -->

      <section anchor="after-igp-converges1-1d"  
               title="After IGP Converges on Failure">
       <t><xref target="SR-Protect-Bind-path1-b1-fail-2-1-1d"/> shows the 
          result of executing procedure on each of the related nodes 
          on SR path 1 
          when node B1 failed and 
          after the IGP converges on the failure. 

         <figure
            anchor="SR-Protect-Bind-path1-b1-fail-2-1-1d"
            title="B1 on SR Path 1 failed and after IGP converges on failure">
            <artwork><![CDATA[
 2.{SID-B2,SID-Q1,SID-Q3,SID-C}Pkt    5.{SID-Q3,SID-C}Pkt
                |                        |
      !         |                        v          !
      !    [P1]-|---[P3]-  -[B1]-  -[Q1]----[Q3]    !
      !    / | \V  / | \           / | \   / | \ 6.{SID-C}Pkt
     Pkt  /1.{..}Pkt |  \         /  |  \ /  !  \
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \2 |  / \  |  / \  |  /  7.Pkt
      !    \ | /   \ | /   \ | /4.{SID-Q1,SID-Q3,SID-C}Pkt
      !    [P2]-----[P4]----[B2]----[Q2]-----[Q4]   !
      :                  ^                          :
      |                  |                          |
      |         3.{SID-B2,SID-Q1,SID-Q3,SID-C}Pkt   |
      ! <------------    Domain 1    -------------> ! 
SR Path 1:A->P1->B1->BSID-B1(->Q1->Q3->C);BSID-B1 w/ SID-list 1
SID-list 1: {SID-Q1,SID-Q3,SID-C}
SID-list 5: {SID-B2,SID-Q1,SID-Q3,SID-C} - backup path for B1's failure]]></artwork>
          </figure>  

          The procedure and the result of the procedure on each of
          nodes A, B2, Q1, Q3 and C are the same as
          those described in <xref target="before-igp-converges1-1d"/>.

          The procedure and the result of the procedure on each of
          nodes P1 and P4 are as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="2.">Since upstream (or previous hop) node P1 of B1 along 
               SR path 1 does not have a FIB entry for SID-B1 as top 
               SID of the packet, node P1
               pops SID-B1 from the packet, 
               replaces BSID-B1 with SID-list 5  
               in the packet
               according to its FIB entry for BSID-B1 of node B1 with ID-B1, and 
               sends the packet to P4 according to the top SID (SID-B2) in the packet
               along the IGP shortest path to B2.
               The packet sent to P4 is represented by
              "2. {SID-B2, SID-Q1, SID-Q3, SID-C}Pkt".
            </t>
            <t hangText="3.">Node P4 sends the packet to B2 according to the top SID
               (SID-B2) in the packet received along the IGP shortest path.
               The packet sent to B2 is represented by
              "3. {SID-B2, SID-Q1, SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section>
<!-- After IGP Converges on Failure -->
      </section>   
<!-- "SR Path 1 with Node SIDs" -->

      <section anchor="b1-2domains-1provider-path2-1d"  
               title="SR Path using Adjacency SIDs">

        <t>This section illustrates the procedure and the 
           result of the procedure on each of the related nodes on 
           SR path 2 using adjacency SIDs 
           after node B1 with BSID2-B1 failed.</t>

      <section anchor="before-igp-converges1-path2-1d"  
               title="Before IGP Converges on Failure">
       <t><xref target="SR-Protect-Bind-path2-b1-fail-1-1-1d"/> shows the 
          result of executing procedure on each of the related nodes 
          on SR path 2 
          when node B1 failed and 
          before the IGP converges on the failure. 

         <figure
            anchor="SR-Protect-Bind-path2-b1-fail-1-1-1d"
            title="B1 on SR path 2 failed and before IGP converges">
            <artwork><![CDATA[
 2.{SID-P3-B1,BSID2-B1}Pkt           5.{SID-Q3,SID-C}Pkt
                |            !           |
      !         v            !           v          !
      !    [P1]-----[P3]----[B1]----[Q1]----[Q3]    !
      !    / | \   / | \3.{SID-B2,SID-Q1,    | \ 6.{SID-C}Pkt
     Pkt  /1.{..}Pkt |  \  SID-Q3,SID-C}Pkt  |  \   ! 
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \2 |  / \  |  / \  |  /  7.Pkt
      !    \ | /   \ | /   \ | /4.{SID-Q1,SID-Q3,SID-C}Pkt
      !    [P2]-----[P4]----[B2]----[Q2]-----[Q4]   !
      :                                             :
      ! <------------    Domain 1    -------------> !
SR Path 2: A->P1->P3->B1->BSID2-B1(->Q1->Q3->C);BSID2-B1 w/ SID-list 3
SID-list 3:{SID-B1-Q1,SID-Q3,SID-C}
SID-list 6:{SID-B2,SID-Q1,SID-Q3,SID-C} - backup path for B1's failure]]></artwork>
          </figure>  

          The procedure and the result of the procedure on each of
          nodes A, P1, Q1, Q3 and C are the same as
          those described in <xref target="without-failure-path2-1d"/>.

          The procedure and the result of the procedure on each of
          nodes P3 (neighbor of B1) and B2 are as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="3.">Neighbor P3 pops its SID-P3-B1,
               replaces BSID2-B1 in the packet with SID-list 6 
               according to its FIB entry 
               for BSID2-B1 of node B1 with ID-B1, and
               sends the packet to B2 according to the top SID (i.e., SID-B2)
               in the packet without
               going through failed B1 using TI-LFA.
               The packet sent to B2 is represented by
              "3. {SID-B2, SID-Q1, SID-Q3, SID-C}Pkt".
            </t>
            <t hangText="4.">Node B2 pops its SID-B2 
               from the packet received, and
               sends the packet to Q1 according to the top SID (SID-Q1) 
               in the packet.
               The packet sent to Q1 is represented by
              "4. {SID-Q1, SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section> 
<!-- Before IGP Converges on Failure  -->

      <section anchor="after-igp-converges1-path2-1d"  
               title="After IGP Converges on Failure">
       <t>The 
          result of the procedure on each of the related nodes 
          on SR path 2 using adjacency SIDs 
          when node B1 failed and 
          after the IGP converges on the failure 
          is the same as the one described 
          in <xref target="before-igp-converges1-path2-1d"/>. 
       </t>

       <t>
The procedure on node P3 is different from the one on P3 in 
<xref target="before-igp-converges1-path2-1d"/>, 
which is as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="3.">Node P3 sends the packet to B2 
                along the IGP shortest path according to the top SID
               (SID-B2) in the packet received.
               The packet sent to B2 is represented by
              "3. {SID-B2, SID-Q1, SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section>
<!-- After IGP Converges on Failure -->
      </section>   
<!-- "SR Path 2 with Adjacency SIDs" -->
      </section>  
<!-- "Failure of Border of 2 domains owned by 1 provider" -->


      <section anchor="b1-2domains-1provider"  
               title="Failure of Border in One Administrative Domain">

        <t>This section illustrates the procedure and the result of 
           the procedure on each of the related nodes on 
           SR path 1 and SR path 2 across two domains 
           after border node B3 failed, 
           where the two domains are owned by one provider.</t>

      <section anchor="b1-2domains-1provider-path1"  
               title="SR Path using Node SIDs">

        <t>This section illustrates the procedure and 
           the result of the procedure on each of 
           the related nodes on SR path 1 across two domains using node SIDs 
           after border node B3 failed.</t>

      <section anchor="before-igp-converges1"  
               title="Before Convergence on Failure">
       <t><xref target="SR-Protect-Bind-path1-b1-fail-1-1"/> shows the 
          result of executing procedure on each of the related nodes 
          on SR path 1 
          when border node B3 failed and 
          before the routing convergence on the failure. 

         <figure
            anchor="SR-Protect-Bind-path1-b1-fail-1-1"
            title="B3 on SR Path 1 in OAD failed and before convergence">
            <artwork><![CDATA[
            2.{..}Pkt  3.{..}Pkt  
                |        |     4.{SID-B4,SID-Q3,SID-C}Pkt     
                |        |   !   |   !   
      !         v        V   !   |   !              !
      !    [P1]-----[P3]----[B1] |  [B3]----[Q3]    !
      !    / | \   / | \   / | \ V         / | \ 6.{SID-C}Pkt
     Pkt  /1.{..}Pkt |  \ /  |  \         /  |  \   ! 
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \  |  / \  |  /    |  /  7.Pkt
      !    \ | /   \ | /   \ | /   \ | /5.{SID-Q3,SID-C}Pkt
      !    [P2]-----[P4]----[B2]----[B4]-----[Q4]   !
      :                                             :
      ! <--- Domain 1 -----> !       !<- Domain 2 ->!
SR Path 1: A->P1->B1->B3->BSID-B3(->Q3->C);BSID-B3 w/ SID-list 1
SID-list 1:{SID-Q3,SID-C}
SID-list 5:{SID-B4,SID-Q3,SID-C} - backup path for B3's failure]]></artwork>
          </figure>  

          The procedure and the result of the procedure on each of
          nodes A, P1, P3, Q3 and C are the same as
          those described in <xref target="without-failure-path1"/>.

          The procedure and the result of the procedure on each of
          nodes B1 (neighbor of B3) and B4 (alternate border node)  
          are as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="4.">Neighbor B1 pops SID-B3 from the packet received,
               replaces BSID-B3 in the packet with SID-list 5 
               according to its FIB entry 
               for BSID-B3 of node B3 with ID-B3, and
               sends the packet to B4 according to the top SID (i.e., SID-B4)
               in the packet without
               going through failed B3 using TI-LFA.
               The packet sent to B4 is represented by
              "4. {SID-B4, SID-Q3, SID-C}Pkt".
            </t>
            <t hangText="5.">Border node B4 pops its SID (i.e., SID-B4) 
               from the packet received, and
               sends the packet to Q3 according to the top SID (SID-Q3) 
               in the packet.
               The packet sent to Q3 is represented by
              "5. {SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section> 
<!-- Before IGP Converges on Failure  -->

      <section anchor="after-igp-converges1"  
               title="After Convergence on Failure">
       <t>The procedure and the result of the procedure on each node 
          of SR path 1 are the same as
          those described in <xref target="before-igp-converges1"/>
          except for the procedure on 
          node B1 as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="4.">Neighbor B1 pops SID-B3 from the packet received,
               replaces BSID-B3 in the packet with SID-list 5 
               according to its FIB entry 
               for BSID-B3 of node B3 with ID-B3, and
               sends the packet to B4 according to the top SID (i.e., SID-B4)
               in the packet.
               The packet sent to B4 is represented by
              "4. {SID-B4, SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section>
<!-- After IGP Converges on Failure -->
      </section>   
<!-- "SR Path 1 with Node SIDs" -->

      <section anchor="b1-2domains-1provider-path2"  
               title="SR Path using Adjacency SIDs">

        <t>This section illustrates the procedure and the 
           result of the procedure on each of the related nodes on 
           SR path 2 across two domains using adjacency SIDs 
           after border node B3 failed.</t>

      <section anchor="before-igp-converges1-path2"  
               title="Before Convergence on Failure">
       <t><xref target="SR-Protect-Bind-path2-b1-fail-1-1"/> shows the 
          result of executing procedure on each of the related nodes 
          on SR path 2 
          when border node B3 failed and 
          before the convergence on the failure. 

         <figure
            anchor="SR-Protect-Bind-path2-b1-fail-1-1"
            title="B3 on SR path 2 in OAD failed and before convergence">
            <artwork><![CDATA[
            2.{..}Pkt  3.{..}Pkt  
                |        |     4.{SID-B4,SID-Q3,SID-C}Pkt     
                |        |   !   |   !   
      !         v        V   !   |   !              !
      !    [P1]-----[P3]----[B1] |  [B3]----[Q3]    !
      !    / | \   / | \   / | \ V         / | \ 6.{SID-C}Pkt
     Pkt  /1.{..}Pkt |  \ /  |  \         /  |  \   ! 
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \2 |  / \  |  /    |  /  7.Pkt
      !    \ | /   \ | /   \ | /   \ | /5.{SID-Q3,SID-C}Pkt
      !    [P2]-----[P4]----[B2]----[B4]-----[Q4]   !
      :                                             :
      ! <--- Domain 1 -----> !       !<- Domain 2 ->!
SR Path 2: A->P1->P3->B1->B3->BSID2-B3(->Q3->C);BSID2-B3 w/ SID-list 3
SID-list 3:{SID-B3-Q3,SID-C}
SID-list 6:{SID-B4,SID-Q3,SID-C} - backup path for B3's failure]]></artwork>
          </figure>  

          The procedure and the result of the procedure on each of
          nodes A, P1, P3, Q3 and C are the same as
          those described in <xref target="without-failure-path2"/>.

          The procedure and the result of the procedure on each of
          nodes B1 (neighbor of B3) and B4 (alternate border node)
          are as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="4.">Neighbor B1 pops its SID-B1-B3,
               replaces BSID2-B3 in the packet with SID-list 6 
               according to its FIB entry 
               for BSID2-B3 of node B3 with ID-B3, and
               sends the packet to B4 according to the top SID (i.e., SID-B4)
               in the packet without
               going through failed B3 using TI-LFA.
               The packet sent to B4 is represented by
              "4. {SID-B4, SID-Q3, SID-C}Pkt".
            </t>
            <t hangText="4.">Border node B4 pops its SID-B4 
               from the packet received, and
               sends the packet to Q3 according to the top SID (SID-Q3) 
               in the packet.
               The packet sent to Q3 is represented by
              "5. {SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section> 
<!-- Before IGP Converges on Failure  -->

      <section anchor="after-igp-converges1-path2"  
               title="After Convergence on Failure">
       <t>The 
          result of the procedure on each of the related nodes 
          on SR path 2 using adjacency SIDs 
          when border node B3 failed and 
          after the convergence on the failure 
          is the same as the one described 
          in <xref target="before-igp-converges1-path2"/>. 
       </t>

       <t>
The procedure on node B1 is different from the one on B1 in 
<xref target="before-igp-converges1-path2"/>, 
which is as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="4.">Node B1 sends the packet to B4 
               along the normal routing path to B4 according to the top SID 
               (SID-B4) in the packet received.
               The packet sent to B4 is represented by
              "4. {SID-B4, SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section>
<!-- After IGP Converges on Failure -->
      </section>   
<!-- "SR Path 2 with Adjacency SIDs" -->
      </section>  
<!-- "Failure of Border of 2 domains owned by 1 provider" -->

      <section anchor="b1-2domains-2providers"  
               title="Failure of Border in Two Administrative Domains">
        <t>This section illustrates the procedure and 
           result of procedure on each of the related nodes on 
           SR path 1 and SR path 2 across two domains 
           after border node B3 failed, 
           where two domains are administrated by two different providers.</t>

      <section anchor="b1-2domains-2providers-path1"  
               title="SR Path using Node SIDs">

      <section anchor="before-igp-converges"  
               title="Before Convergence on Failure">
       <t><xref target="SR-Protect-Bind-path1-b1-fail-1"/> shows the 
          result of executing procedure on each of the related nodes 
          on SR path 1 using node SIDs
          when border node B3 failed and 
          before the convergence on the failure. 

         <figure
            anchor="SR-Protect-Bind-path1-b1-fail-1"
            title="B3 on SR Path 1 in TAD failed and before convergence">
            <artwork><![CDATA[
            2.{..}Pkt  3.{..}Pkt  
                |        |     4.{SID-B4,BSID-B4}Pkt     
                |        |   !   |   !   
      !         v        V   !   |   !              !
      !    [P1]-----[P3]----[B1] |  [B3]----[Q3]    !
      !    / | \   / | \   / | \ V         / | \ 6.{SID-C}Pkt
     Pkt  /1.{..}Pkt |  \ /  |  \         /  |  \   ! 
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \2 |  / \  |  /    |  /  7.Pkt
      !    \ | /   \ | /   \ | /   \ | /5.{SID-Q3,SID-C}Pkt
      !    [P2]-----[P4]----[B2]----[B4]-----[Q4]   !
      :                                             :
      ! <--- Domain 1 -----> !       !<- Domain 2 ->!
SR Path 1: A->P1->B1->B3->BSID-B3(->Q3->C);BSID-B3 w/ SID-list 1
SID-list 1: {SID-Q3,SID-C};   BSID-B4 w/ SID-list 2: {SID-Q3,SID-C}
SID-list 7: {SID-B4,BSID-B4}  - backup bath for B3 on Path 1 in TAD]]></artwork>
          </figure>  

          The procedure and the result of the procedure on
          each of nodes A, P1, P3, Q3 and C are the same as
          those described in <xref target="without-failure-path1"/>.

          The procedure and the result of the procedure on each of
          nodes B1 (neighbor of B3) and B4 (alternate border)
          are described below.

          <list style="hanging" hangIndent="4">
            <t hangText="4.">Neighbor B1 pops SID-B3 from the packet received,
               replaces BSID-B3 in the packet with SID-list 7 
               according to its FIB entry 
               for BSID-B3 of node B3 with ID-B3, and
               sends the packet to B4 according to the top SID (i.e., SID-B4)
               in the packet without
               going through failed B3 using TI-LFA.
               The packet sent to B4 is represented by
              "4. {SID-B4, BSID-B4}Pkt".
            </t>
            <t hangText="5.">Border node B4 pops its SID-B4 
               from the packet received,
               replaces BSID-B4 with SID-list 2  
               according to its FIB entry for BSID-B4, and
               sends the packet to Q3 according to the top SID (SID-Q3) 
               in the packet.
               The packet sent to Q3 is represented by
              "5. {SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section> 
<!-- Before IGP Converges on Failure  -->

      <section anchor="after-igp-converges"  
               title="After Convergence on Failure">
       <t>The procedure and the result of the procedure on each node 
          are the same as
          those described in <xref target="before-igp-converges"/>
          except for the procedure on 
          node B1 described below.

          <list style="hanging" hangIndent="4">
            <t hangText="4.">Since upstream node B1 of B3 along 
               SR path 1 does not have a FIB entry for SID-B3 as top 
               SID of the packet, node B1
               pops SID-B3 from the packet, 
               replaces BSID-B3 with SID-list 7 in the packet
               according to its FIB entry for BSID-B3 of node B3 with ID-B3, and 
               sends the packet to B4 according to the top SID (SID-B4) 
               in the packet.
               The packet sent to P4 is represented by
              "4. {SID-B4, BSID-B4}Pkt".
            </t>
          </list>
        </t>
      </section>
<!-- After IGP Converges on Failure -->
      </section>   
<!-- "SR Path with Node SIDs" -->



      <section anchor="b1-2domains-2providers-path2"  
               title="SR Path using Adjacency SIDs">

      <section anchor="before-igp-converges-path2"  
               title="Before Convergence on Failure">
       <t><xref target="SR-Protect-Bind-path2-b1-fail-1"/> shows the 
          result of executing procedure on each of the related nodes 
          on SR path 2 using adjacency SIDs
          when border node B3 failed and 
          before the convergence on the failure. 

         <figure
            anchor="SR-Protect-Bind-path2-b1-fail-1"
            title="B3 on SR Path 2 in TAD failed and before convergence">
            <artwork><![CDATA[
            2.{..}Pkt  3.{..}Pkt  
                |        |     4.{SID-B4,BSID2-B4}Pkt     
                |        |   !   |   !   
      !         v        V   !   |   !              !
      !    [P1]-----[P3]----[B1] |  [B3]----[Q3]    !
      !    / | \   / | \   / | \ V         / | \ 6.{SID-C}Pkt
     Pkt  /1.{..}Pkt |  \ /  |  \         /  |  \   ! 
[CE1]---[A]  |   X   |   X   |   X   |   X   |  [C]---[CE2]
      !   \  |  / \  |  / \  |  / \  |  /    |  /  7.Pkt
      !    \ | /   \ | /   \ | /   \ | /5.{SID-Q3,SID-C}Pkt
      !    [P2]-----[P4]----[B2]----[B4]-----[Q4]   !
      :                                             :
      ! <--- Domain 1 -----> !       !<- Domain 2 ->!
SR Path 2: A->P1->P3->B1->B3->BSID2-B3(->Q3->C);BSID2-B3 w/ SID-list 3
SID-list 3: {SID-B3-Q3,SID-C};  BSID2-B4 w/ SID-list 4: {SID-Q3,SID-C}
SID-list 8: {SID-B4,BSID2-B4} - backup bath for B3 on Path 2 in TAD]]></artwork>
          </figure>  

          The procedure and the result of the procedure on each of
          nodes A, P1, P3, Q3 and C are the same as
          those described in <xref target="without-failure-path2"/>.

          The procedure and the result of the procedure on each of
          nodes B1 (neighbor of B3) and B4 (alternate border)
          are as follows.

          <list style="hanging" hangIndent="4">
            <t hangText="4.">Neighbor B1 
               replaces BSID2-B3 in the packet received with SID-list 8 
               according to its FIB entry 
               for BSID2-B3 of node B3 with ID-B3, and
               sends the packet to B4 according to the top SID (i.e., SID-B4)
               in the packet without
               going through failed B3 using TI-LFA.
               The packet sent to B4 is represented by
              "4. {SID-B4, BSID2-B4}Pkt".
            </t>
            <t hangText="5.">Border node B4 pops its SID-B4
               from the packet received,
               replaces BSID2-B4 with SID-list 4  
               according to its FIB entry for BSID2-B4, and
               sends the packet to Q3 according to the top SID (SID-Q3) 
               in the packet.
               The packet sent to Q3 is represented by
              "5. {SID-Q3, SID-C}Pkt".
            </t>
          </list>
        </t>
      </section> 
<!-- Before Convergence on Failure  -->

      <section anchor="after-igp-converges-path2"  
               title="After Convergence on Failure">
       <t>The procedure and
          result of executing procedure on each of the related nodes 
          on SR path 2 
          when border node B3 failed and 
          after the convergence on the failure are 
          the same as those described in 
          <xref target="before-igp-converges-path2"/>. </t>

       <t>The procedure on node B1 is different from the one on B1
          in <xref target="before-igp-converges-path2"/>, which
          is as follows.
          <list style="hanging" hangIndent="4">
            <t hangText="4.">Since upstream (neighbor) node B1 of B3 along 
               SR path 2 does not have a FIB entry for SID-B1-B3 as top 
               SID of the packet, node B1
               replaces BSID2-B3 with SID-list 8 in the packet
               according to its FIB entry for BSID2-B3 of node B3 with ID-B3, and 
               sends the packet to B4 according to the top SID (SID-B4) 
               in the packet.
               The packet sent to B4 is represented by
              "4. {SID-B4, BSID2-B4}Pkt".
            </t>
          </list>
        </t>
      </section>
<!-- After Convergence on Failure -->
      </section>   
<!-- "SR Path 2 with Adjacency SIDs" -->
      </section>  
<!-- "Failure of Border of 2 domains owned by 2 providers" -->


    </section>


    <section title="Procedures">

      <section anchor="proc-neighbor"
               title="on Neighbor of Node with Binding SID">
        <t>When there is no failure, neighbor N of node B with 
           binding SID on an SR path sends the packet to B. 
           When neighbor N
           detects the failure of B, N
           pops top SID (SID-B or SID-N-B) from the packet,
           and does the following steps:
          <list style="hanging" hangIndent="4">
            <t hangText="1.">
               If the current top SID in the packet is a Binding  
               SID of B (BSID-B), 
               replaces BSID-B in the packet with a SID list and
               sends the packet toward the top SID of the packet
               without going through B.
               The SID list represents a backup path segment for 
               the failure of B.
<!--
               If it is TAD case, the SID list contains
               node SID of alternate border node (SID-aB), 
               which is {SID-aB, BSID-aB
               (i.e., binding SID of alternate border node)};
 --> 
            </t>
            <t hangText="2.">
               Otherwise (i.e., the current top SID in the packet is an adjacency
               SID of the node or a node SID of next hop),
               executes the corresponding action for the SID from 
               <xref target="I-D.ietf-rtgwg-segment-routing-ti-lfa"/>.
            </t>
          </list>
        </t>
      </section>
<!-- on Neighbor of Border Node -->


      <section anchor="proc-upstream"
               title="on Upstream Node of Node with Binding SID">
        <t>A upstream node of node B with binding SID on an SR path
           pops the top SID from the packet received 
           if the top SID is a SID of the upstream node.
        </t>
        <t>When there is no failure or 
           B on an SR path failed and 
           before the convergence on the failure of B,
           the upstream node sends the packet
           according to its FIB entry for the top SID in the packet.
        </t>

        <t>After B failed and 
           the convergence on the failure of B,
           the upstream node pops the node SID of B (SID-B)
           from the packet and does the following steps:
          <list style="hanging" hangIndent="4">
            <t hangText="1.">
               If the current top SID in the packet is a Binding  
               SID of B (BSID-B), then
               executes the action indicated by the FIB entry for 
               BSID-B of node B. 
               The action is to replace BSID-B in the packet 
               with a SID list 
               and send the packet according to the current top 
               SID in the packet.
               The SID list represents a backup path segment for 
               the failure of B. 
<!--
               If it is TAD case, the SID list contains
               node SID of alternate border node (SID-aB), 
               which is {SID-aB, BSID-aB
               (i.e., binding SID of alternate border node)};
 --> 
            </t>
            <t hangText="2.">
               Otherwise (i.e., the current top SID in the packet is an adjacency
               SID of the node or a node SID of next hop),
               executes the corresponding action for the SID from 
               <xref target="I-D.ietf-rtgwg-segment-routing-ti-lfa"/>.
            </t>
          </list>
        </t>
      </section>
<!-- on Upstream Node of Border Node -->


<!--
      <section title="on Alternate Border Node">
         <t>When the alternate border node is not a upstream neighbor of 
           the border node on a SR path, it executes a normal procedure.
           After the border node failed, the alternate border node 
           receives the packet with its SID followed by its Binding 
           SID or a SID in the downstream domain, 
           pops its SID, and 
           sends the packet according to the current top SID 
           in the packet.</t>

        <t>When the alternate border node is a neighbor of 
           the border node on a SR path,
           it executes the procedure in 
           <xref target="proc-neighbor"/>.</t>
      </section>
-->
<!-- on Alternative Border Node -->


      <section title="Integrated Procedure">
        <t>A procedure running on a node that forwards the packet
           to be transported by an SR path in different cases 
           is called an integrated procedure. 
           The node is a border node or an internal node.
           The cases include normal case without any failure,
           a border or internal node failure. 
        </t>

        <t>Suppose that Packet = the packet received by node X. 
           an integrated procedure running on node X is 
           described in Pseudo code as shown in 
           <xref target="integrated-proc"/>. 
        </t>
<t>
<figure anchor="integrated-proc" 
        title="Integrated Procedure">
  <artwork> <![CDATA[
IF (X detects N's failure){//X:neighbor of N, before convergence
   Pops top SID from Packet; // pops SID-N or SID-X-N
   IF (top SID in Packet is Binding SID (BSID) of N) {
         Replace BSID in Packet with SID list;
   }
   Sends Packet without going N using TI-LFA for top SID in Packet;
} ELSE {//Normal or (N failed and after convergence on failure)
   IF (no FIB entry for top SID in Packet){//N failed,after converges
      Pops top SID from Packet;//pops SID-N or SID-X-N
      IF (top SID in Packet is Binding SID (BSID) of N) {
         Replace BSID in Packet with SID list;
      }
   } //Normal case: there is FIB entry for top SID, N works
   Sends Packet using FIB entry for top SID in Packet;
}]]></artwork>
</figure> 
</t>

      </section>
<!-- Integrated Procedures -->
    </section>

    <section title="Protocol Extensions">
      <t> 
         This section describes the semantic of
         protocol extensions for distributing binding protection 
         information for a node with a BSID  
         in three cases: Single Domain, OAD and TAD. </t>

     <t>For a Binding SID (BSID-B) of a node 
        (e.g., transit node B1 in <xref target="SR-Protect-Bind-A-1d"/>
         or border node B3 in <xref target="SR-Protect-Bind-A"/>)  
        on a SR path, 
        suppose that the following information is sent to 
        (or received from) the node:
          <list style="hanging" hangIndent="4">
            <t hangText="1.">
               BSID-B, and</t>
            <t hangText="2.">
              A list of SIDs (named SID-list a) associated with BSID-B, 
              where the SIDs are in the downstream domain.</t>
          </list>
     </t>

     <t>For Single Domain, 
        one piece of information is distributed.
        This one piece is BSID-B, a new SID list (named SID-list c) 
        and ID-B (Identifier of the node).
        SID-list c represents a backup path
        for the failure of the node on the SR path.
        It contains the SIDs for the path segment
        corresponding to SID-list a.</t>

     <t>This one piece (i.e., BSID-B, SID-list c and ID-B) is sent 
        to the upstream neighbor of the node
        on the SR path.  
        It is also sent to the closest upstream 
        endpoint node (e.g., P1 on SR path 1 
        in <xref target="SR-Protect-Bind-A-1d"/>) of the node if the
        node is a loose hop on the SR path, 
        which is indicated by node SID of the node (e.g., SID-B1) 
        on the SR path. 
        The node SID is used to reach the node (e.g., B1).
     </t>

     <t>For OAD, 
        one piece of information is distributed.
        This one piece is BSID-B, a new SID list (named SID-list c) and ID-B.
        SID-list c represents a backup path
        for the failure of the border node on the SR path.
        It contains the SIDs for the path segment to the alternate 
        border node and the path segment
        corresponding to SID-list a.
        This piece is distributed in the same way 
        as the one for Single Domain.
     </t>

     <t>For TAD, 
        two pieces of information are distributed.  
          <list style="hanging" hangIndent="4">
            <t hangText="Piece 1.">
               BSID-aB, which is a Binding SID of an alternate border 
               node (e.g., B4 in <xref target="SR-Protect-Bind-A"/>), and 
               a list of SIDs (named SID-list b) corresponding to SID-list a.
               SID-list b is SID-list a
               when the first SID in SID-list a is a node SID.
               when the first SID in SID-list a is an adjacency SID of 
               an adjacency, 
               the node SID of the remote node of the adjacency and 
               the other SIDs in SID-list a constitutes SID-list b.</t>
            <t hangText="Piece 2.">
               BSID-B, SID-list d {SID-aB, BSID-aB} and ID-B; 
               where SID-aB is a node SID of the alternate border node, and 
               ID-B is an Identifier (ID) of the border node.</t>
           </list>
        These two pieces of information represent a backup path
        for the failure of the border node on the SR path.</t> 

     <t>Piece 1 (i.e., BSID-aB and SID-list b) is sent to 
        the alternate border node. 
        Piece 2 (i.e., BSID-B, SID-list d and ID-B) is distributed 
        in the same way as the one for OAD.  
    </t>

    <t>In one option, 
       the TE router ID of a node is used as the ID of the node.</t>

    <t>When a protocol (such as
       PCE or BGP running on a controller) supports sending a binding 
       (i.e., a BSID and a SID list) 
       on a node, we may extend this protocol to distribute 
       the binding protection
       information (refer to <xref target="I-D.chen-pce-mbinding"/> 
       and <xref target="I-D.chen-idr-mbinding"/>).
    
       Alternatively, 
       we may extend YANG and IGP to distribute the binding protection 
       information. </t>

    <t>Note: how to distribute binding protection information  
       via which protocol is out of the scope of this document.</t>

    </section>  <!-- Protocol Extensions -->



    <section anchor="Security" title="Security Considerations">
      <t>TBD.</t>
    </section>


    <section anchor="Acknowledgements" title="Acknowledgements">
      <t>The authors would like to thank Andrew Stone
      for his comments to this work.</t>
    </section>

  </middle>

  <back>
    <references title="Normative References">
      <?rfc include="reference.RFC.2119"?>
       <!-- <?rfc include="reference.RFC.5250"?> -->
       <!-- <?rfc include="reference.RFC.5226"?> -->
      <?rfc include="reference.RFC.7356"?>
       <!-- <?rfc include="reference.RFC.7684"?> -->
       <!-- <?rfc include="reference.RFC.7770"?> -->
       <!-- <?rfc include="reference.RFC.8665"?> -->
      <?rfc include="reference.RFC.8402"?>
      <?rfc include="reference.RFC.8667"?>
      <?rfc include="reference.RFC.8174"?>

    </references>

    <references title="Informative References">
      <?rfc include="reference.I-D.ietf-rtgwg-segment-routing-ti-lfa"?>
      <?rfc include="reference.I-D.ietf-spring-segment-routing-policy"?>
      <?rfc include="reference.I-D.ietf-spring-segment-protection-sr-te-paths"?>
      <?rfc include="reference.I-D.hu-spring-segment-routing-proxy-forwarding"?>
      <?rfc include="reference.I-D.chen-pce-mbinding"?>
      <?rfc include="reference.I-D.chen-idr-mbinding"?>
<!--
      <?rfc include="reference.RFC.4090"?>
      <?rfc include="reference.RFC.3209"?>
      <?rfc include="reference.I-D.ietf-lsr-isis-ttz"?>
      <?rfc include="reference.RFC.5036"?>

      <?rfc include="reference.RFC.8279"?>
      <?rfc include="reference.RFC.9050"?>
-->


    </references>

<!-- Appendix -->


  </back>

</rfc>
