<?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="exp" docName="draft-geng-msr6-rlb-segment-02" ipr="trust200902">
  <front>
    <title abbrev="draft-geng-msr6-rlb-segment-00">RLB (Replication through
    Local Bitstring) Segment for Multicast Source Routing over IPv6</title>

    <author fullname="Xuesong Geng" initials="X." surname="Geng">
      <organization>Huawei Technologies</organization>

      <address>
        <postal>
          <street/>
        </postal>

        <email>gengxuesong@huawei.com</email>
      </address>
    </author>

    <author fullname="Zhenbin Li" initials="Z." surname="Li">
      <organization>Huawei Technologies</organization>

      <address>
        <email>lizhenbin@huawei.com</email>

        <uri/>
      </address>
    </author>

    <author fullname="Jingrong Xie" initials="J." surname="Xie">
      <organization>Huawei Technologies</organization>

      <address>
        <postal>
          <street/>

          <city/>

          <code/>

          <country/>
        </postal>

        <email>xiejingrong@huawei.com</email>
      </address>
    </author>

    <date day="23" month="October" year="2023"/>

    <abstract>
      <t>This document defines 2 new types of segment: End.RLB.X and End.RLB,
      and the corresponding packet processing procedures over the IPv6 data
      plane for the MSR6(Multicast Source Routing over IPv6) TE solutions.</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">RFC 2119</xref>.</t>
    </note>
  </front>

  <middle>
    <section title="Introduction">
      <t>MSR6(Multicast Source Routing over IPv6) is an IPv6 based multicast
      source routing (MSR6) solution, defined in <xref
      target="I-D.cheng-spring-ipv6-msr-design-consideration"/>, which
      leverages the benefits of source routing over IPv6 data plane to provide
      simplified multicast TE and BE service in an IPv6 network without
      unnecessary multicast tree status and complex control plane protocols.
      MSR6 needs to reuse the advantages of SRv6 and BIER to implement source
      routing.</t>

      <t>MSR6 has two basic modes of forwarding: one is based on Shortest Path
      First(SPF), which is called MSR6 BE mode; the other is based on traffic
      engineered, which is called MSR6 TE mode. <xref
      target="I-D.geng-msr6-traffic-engineering"/> and <xref
      target="I-D.chen-pim-srv6-p2mp-path"/> have introduced structured
      segment list by defining arguments in each segment. Based on these
      existing work, this document defines 3 new types of segment with local
      bitstring, which could reduce encapsulation overhead and enhance
      scalability.</t>
    </section>

    <section title="Terminologies">
      <t/>

      <t>MSR6: Multicast Source Routing over IPv6, defined in <xref
      target="I-D.cheng-spring-ipv6-msr-design-consideration"/>.</t>

      <t>MRH: Multicast Routing Header, a new type of Routing Header which is
      used for MSR6.</t>

      <t>Multicast domain: A set of network device which could provide P2MP
      multicast transport. In this document, the multicast domain is an MSR
      domain, where every nodes support the capability of MSR6.</t>

      <t>Root Node: Root node is the beginning point of a multicast tree and
      also the initiation node of a multicast tunnel. It encapsulates the
      packet with a multicast header. The type of the encapsulation depends on
      the routing protocol used in the multicast domain. For MSR6 TE, the
      encapsulation is MSR6 TE header, which is an IPv6 header with MRH.</t>

      <t>Replication Endpoint: the intermediate node of a multicast tree,
      which replicates packet and forwards the packet to the downstream nodes.
      For MSR6, the Replication Node is called Replication Endpoint which can
      be indicated by the MSR6 Segment and replicate packets according to the
      multicast source routing information encapsulation in the MSR6 header of
      the packet.</t>

      <t>Leaf Node: Leaf node is the end point of a multicast tree and also
      the decapsulation node of a multicast tunnel. It decapsulates the
      multicast header in the packet and forwards the packet based on overlay
      encapsulation.</t>

      <t>Parent Node: The parent node is the node that does the packet
      replication, corresponding to the concept of a child node.</t>

      <t>Child Node: The child node is the downstream node that will receive
      the packet which has been replicated ,corresponding to the concept of a
      parent node.</t>

      <t>End.RLB(Replication through Local Bitstring): Endpoint with the
      function of Replication through Local Bitstring</t>

      <t>End.RLB(Replication through Local Bitstring).X: Endpoint with the
      function of Replication through Local Bitstring and defining output
      port.</t>

      <t>LB(Local Bitstring)Segment: Segment with Local Bitstring.</t>
    </section>

    <section title="Local Bitstring">
      <t>For a specific node, the downstream port can be represented by a
      specific bit in the local bitstring of the node. If the packet needs to
      be replicated through the downstream port, the bit MUST be set. Or else,
      the bit MUST be set as 0.</t>
    </section>

    <section title="RLB.X Segment Definition">
      <t>The segment defined in <xref target="RFC8402"/> can represent
      instruction, topological or service based on the requirement. This
      document specifies RLB.X segment for multicast path encoding.</t>

      <t>End.RLB.X is a new type of segment which is used to identify the
      Replication Endpoint, which is able to replicate the packet based on the
      local bitstring in the segment. RLB.X segment is used as an IPv6
      address, which is 128 bits and follows the SID format defined in <xref
      target="RFC8986"/>, consisting of LOC:FUNCT:ARG. RLB.X segment is
      advertised by the RLB.X replication endpoint.</t>

      <t><figure>
          <artwork><![CDATA[+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                                                               |
|                           Locator                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                           Function                            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|          Local Bitstring      |            Pointer            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+]]></artwork>
        </figure></t>

      <t>Local Bitstring indicates a set of adjacency links that the packet
      are supposed to be replicated to and Pointer is used to locate the
      segment the packet will parse in the next replication endpoint.</t>

      <t>Each replication node maintains the mapping relationship of the bit
      position and adjacency link in the Local Bitstring Forwarding
      Table(LBFT).</t>
    </section>

    <section title="End.RLB.X Behavior">
      <t>The replication node does the following when the DA of the packet is
      a local End.RLB.X SID.</t>

      <t><figure>
          <artwork><![CDATA[   S01. When an MRH is processed {
   S02.   If (Segments Left == 0 or Local Bitstring==Pointer==0) {
   S03.      Stop processing the MRH, and proceed to process the next
                header in the packet, whose type is identified by
                the Next Header field in the routing header.
   S04.   }
   S05.   If (IPv6 Hop Limit <= 1) {
   S06.      Send an ICMP Time Exceeded message to the Source Address
                with Code 0 (Hop limit exceeded in transit),
                interrupt packet processing, and discard the packet.
   S07.   }
   S08.   max_LE = (Hdr Ext Len / 2) - 1
   S09.   If ((Last Entry > max_LE) or (Segments Left > Last Entry+1)) {
   S10.      Send an ICMP Parameter Problem to the Source Address
                with Code 0 (Erroneous header field encountered)
                and Pointer set to the Segments Left field,
                interrupt packet processing, and discard the packet.
   S11.   }
   S12.   Decrement IPv6 Hop Limit by 1
   S13.   Replicate the packet based on the local bitstring in the 
            End.RLB.X and look up LBFT
   S14.   Set the Segment Left of the 1st replicated packet to "Pointer" 
            in the argument of the SID
   S15.   Update IPv6 DA with Segment List[Segment Left]
   S16.   Forward the packet through the adjacency link indicated by 
            local bitstring
   S17.   Repeat S14-S17 with "Pointer+n"(n=the number of packets 
            which have been updated) untill all the packets are transmitted 
            through the indicated link
   R18.   }]]></artwork>
        </figure></t>
    </section>

    <section title="RLB Segment and LB Segment Definition">
      <t/>

      <t>End.RLB is a new type of segment which is used to identify the
      Replication Endpoint, which is able to replicate the packet based on the
      local bitstring in the correponding LB segment. RLB segment is used as
      an IPv6 address, which is 128 bits and follows the SID format defined in
      [RFC8986], consisting of LOC:FUNCT:ARG. RLB segment is advertised by the
      RLB replication endpoint.</t>

      <t><figure>
          <artwork><![CDATA[+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                                                               |
|                           Locator                             |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                           Function                            |
|                                                               |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+]]></artwork>
        </figure></t>

      <t>When RLB Segment is used, there MUST be a corresponding LB Segment in
      the segment list. LB Segment is a special segment which is 128-bits
      containing the local bitstring. That is, LB segment does not take the
      format of LOC:FUNCT:ARG and need not to define the behavior. There is an
      argument in End.LB to indicate the next LB segments for the downstream
      nodes, for example "pointer " defined in <xref
      target="I-D.geng-msr6-traffic-engineering"/>.</t>

      <t><figure>
          <artwork><![CDATA[+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                                                               |
|                         Local  Bitstring                      |
|                                                               |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|                            Pointer                            |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+]]></artwork>
        </figure></t>

      <t>End.RLB segment and LB segment are used together. Each replication
      node maintains the mapping relationship of the bit position with the
      adjacency link and the next hop End.RLB SID in the Local Bitstring
      Forwarding Table(LBFT).</t>
    </section>

    <section title="End.RLB Behavior">
      <t>The replication node does the following when the DA of the packet is
      a local End.RLB SID.</t>

      <t><figure>
          <artwork><![CDATA[   S01. When an MRH is processed {
   S02.   If (Segments Left == 0 or Local Bitstring==Pointer==0) {
   S03.      Stop processing the MRH, and proceed to process the next
                header in the packet, whose type is identified by
                the Next Header field in the routing header.
   S04.   }
   S05.   If (IPv6 Hop Limit <= 1) {
   S06.      Send an ICMP Time Exceeded message to the Source Address
                with Code 0 (Hop limit exceeded in transit),
                interrupt packet processing, and discard the packet.
   S07.   }
   S08.   max_LE = (Hdr Ext Len / 2) - 1
   S09.   If ((Last Entry > max_LE) or (Segments Left > Last Entry+1)) {
   S10.      Send an ICMP Parameter Problem to the Source Address
                with Code 0 (Erroneous header field encountered)
                and Pointer set to the Segments Left field,
                interrupt packet processing, and discard the packet.
   S11.   }
   S12.   Decrement IPv6 Hop Limit by 1
   S13.   Replicate the packet based on the local bitstring in the 
            SID[Segment Left] and look up LBFT
   S14.   Set the Segment Left of the 1st replicated packet to "Pointer" 
            in the argument of the SID
   S15.   Update IPv6 DA with End.RLB indicated by the first bit set in 
            the LBFT
   S16.   Forward the packet through the adjacency link indicated by 
            the first bit set in the LBFT
   S17.   Repeat S14-S17 with "Pointer+n"(n=the number of packets 
            which have been updated) untill all the packets are transmitted 
            through the indicated link
   R18.   }]]></artwork>
        </figure></t>
    </section>

    <section title="Illustration">
      <t/>

      <t><figure>
          <artwork><![CDATA[                                 +---+
                              +--| D |
                     +---+   B2  +---+
                  +--| B |----|
                  |  +---+   B4  +---+
         +---+   A1           +--| E |
         | A |----|              +---+
         +---+    |           +--| F |
                 A2  +---+   C4  +---+
                  +--| C |----|
                     +---+   C7  +---+
                              +--| G |
                                 +---+
      |-->MSR-R<--|->MSR End<-|-->MSR-L<--|

   MSR-R: MSR6 Root Node, including Node A;

   MSR End: MSR6 Replication Endpoint, including Node B and C;

   MSR-L: MSR6 Leaf Nodes, including Node D, E, F, G;]]></artwork>
        </figure></t>

      <t>Take End.RLB and End.LB as an example.</t>

      <t>Acording to the requirement of the service, a multicast tree is
      calculated as showed in the above figure.</t>

      <section title="End.RLB.X">
        <t/>

        <section title="MRH Encapsulation">
          <t>In node A, the packet is encapsulated with an IPv6 header with
          MRH as an extension header. The segment list in the MRH is as
          follows, which is composed of LB SID.</t>

          <t><figure>
              <artwork><![CDATA[  +----------------------------------------+
  | Loc:A|Fun:End.RLB.X| LB:11000000| P:2  |
  +----------------------------------------+
  | Loc:B|Fun:End.RLB.X| LB:01010000| P:0  |
  +----------------------------------------+
  | Loc:C|Fun:End.RLB.X| LB:00010010| P:0  |
  +----------------------------------------+
]]></artwork>
            </figure></t>
        </section>

        <section title="Forwarding Process">
          <t>Node A will receive the packet with the destination address of
          the IPv6 header is a local SID for node A and the function is
          End.RLB.X. Local Bitstring in the segment will be used as an entry
          to look up LBFT in node A. So the packet will be replicated into 2
          packets and sent out through A1 and A2. The destination address of
          the replicated packet will be set to SID[2] and SID[3] based on the
          value of the pointer.</t>

          <t><figure>
              <preamble>(preamble)</preamble>

              <artwork><![CDATA[     +----------------------------+
     |BitPosition | Adjacency Link|  
     +----------------------------+
     |      1     |      A1       |
     +----------------------------+
     |      2     |      A2       |  
     +----------------------------+
     |      3     |      A3       | 
     +----------------------------+
     |      4     |      A4       |
     +----------------------------+
     |      5     |      A5       | 
     +----------------------------+
     |      6     |      A6       | 
     +----------------------------+
     |      7     |      A7       |  
     +----------------------------+
     |      8     |      A8       |  
     +----------------------------+]]></artwork>
            </figure></t>

          <t>Node B will receive the packet with the destination address of
          the IPv6 header is a local SID for node B and the function is
          End.RLB.X. Local Bitstring in the segment will be used as an entry
          to look up LBFT in node B. So the packet will be replicated into 2
          packets and sent out through B2 and B4. The destination address of
          the replicated packet will be set to address-D and address-E based
          on the LBFT.</t>

          <t><figure>
              <preamble>(preamble)</preamble>

              <artwork><![CDATA[     +--------------------------------------+
     |BitPosition | Adjacency Link| Address | 
     +--------------------------------------+
     |      1     |      B1       |  Add-B1 | 
     +--------------------------------------+
     |      2     |      B2       |  Add-D  | 
     +--------------------------------------+
     |      3     |      B3       |  Add-B3 | 
     +--------------------------------------+
     |      4     |      B4       |  Add-E  | 
     +--------------------------------------+
     |      5     |      B5       |  Add-B5 | 
     +--------------------------------------+
     |      6     |      B6       |  Add-B6 | 
     +--------------------------------------+
     |      7     |      B7       |  Add-B7 | 
     +--------------------------------------+
     |      8     |      B8       |  Add-B8 | 
     +--------------------------------------+
   Local Bitstring Forwarding Table(LBFT) in Node B]]></artwork>
            </figure></t>

          <t>Node C will receive the packet with the destination address of
          the IPv6 header is a local SID for node C and the function is
          End.RLB.X. Local Bitstring in the segment will be used as an entry
          to look up LBFT in node C. So the packet will be replicated into 2
          packets and sent out through C4 and C7. The destination address of
          the replicated packet will be set to address-F and address-G based
          on the LBFT.</t>

          <t><figure>
              <artwork><![CDATA[     +--------------------------------------+
     |BitPosition | Adjacency Link|  Address| 
     +--------------------------------------+
     |      1     |      C1       |  Add-C1 | 
     +--------------------------------------+
     |      2     |      C2       |  Add-C2 | 
     +--------------------------------------+
     |      3     |      C3       |  Add-C3 | 
     +--------------------------------------+
     |      4     |      C4       |  Add-F  | 
     +--------------------------------------+
     |      5     |      C5       |  Add-C5 | 
     +--------------------------------------+
     |      6     |      C6       |  Add-C6 | 
     +--------------------------------------+
     |      7     |      C7       |  Add-G  | 
     +--------------------------------------+
     |      8     |      C8       |  Add-C8 | 
     +--------------------------------------+
   Local Bitstring Forwarding Table(LBFT) in Node C
]]></artwork>
            </figure></t>
        </section>
      </section>

      <section title="End.RLB">
        <t/>

        <section title="MRH Encapsulation">
          <t>In node A, the packet is encapsulated with an IPv6 header with
          MRH as an extension header. The segment list in the MRH is as
          follows, which is composed of LB SID.</t>

          <t><figure>
              <artwork><![CDATA[  +----------------------------------------+
  |           LB:11000000           | P:2  |
  +----------------------------------------+
  |           LB:01010000           | P:0  |
  +----------------------------------------+
  |           LB:00010010           | P:0  |
  +----------------------------------------+]]></artwork>
            </figure></t>
        </section>

        <section title="Forwarding Process">
          <t>Node A will receive the packet with the destination address of
          the IPv6 header is a local End.RLB for node A, which is SID A. Based
          on the End.RLB behavior defined in section 4, node A will parse
          SID[Segment Left] in MRH, which is SID[1].</t>

          <t/>

          <t>SID[1] will be used as an entry to look up LBFT in node A. So the
          packet will be replicated into 2 packets. For the 1st packet, the
          destination address of the IPv6 header will be set to SID B, the
          Segment Left will be set to 2 based on the pointer and the packet
          will be sent out through A1. For the 2nd packet, the destination
          address of the IPv6 header will be set to SID C, the Segment Left
          will be set to 2+1 based on the pointer and the packet will be sent
          out through A2.</t>

          <t><figure>
              <artwork><![CDATA[     +--------------------------------------+
     |BitPosition | Adjacency Link| RLB SID |  
     +--------------------------------------+
     |      1     |      A1       |  SID-B  |
     +--------------------------------------+
     |      2     |      A2       |  SID-C  | 
     +--------------------------------------+
     |      3     |      A3       |  SID-A3 | 
     +--------------------------------------+
     |      4     |      A4       |  SID-A4 | 
     +--------------------------------------+
     |      5     |      A5       |  SID-A5 | 
     +--------------------------------------+
     |      6     |      A6       |  SID-A6 | 
     +--------------------------------------+
     |      7     |      A7       |  SID-A7 | 
     +--------------------------------------+
     |      8     |      A8       |  SID-A8 | 
     +--------------------------------------+
   Local Bitstring Forwarding Table(LBFT) in Node A
]]></artwork>
            </figure></t>

          <t>Node B will receive the packet with the destination address of
          the IPv6 header is a local End.RLB for node B, which is SID B. Based
          on the End.RLB behavior defined in section 4, the node will parse
          SID[Segment Left] in MRH, which is SID[2].</t>

          <t>SID[2] will be used as an entry to look up LBFT in node B. So the
          packet will be replicated into 2 packets. For the 1st packet, the
          destination address of the IPv6 header will be set to SID D, the
          Segment Left will be set to 0 based on the pointer and the packet
          will be sent out through B2. For the 2nd packet, the destination
          address of the IPv6 header will be set to SID E, the Segment Left
          will be set to 0 based on the pointer and the packet will be sent
          out through B4.</t>

          <t><figure>
              <artwork><![CDATA[     +--------------------------------------+
     |BitPosition | Adjacency Link| RLB SID | 
     +--------------------------------------+
     |      1     |      B1       |  SID-B1 | 
     +--------------------------------------+
     |      2     |      B2       |  SID-D  | 
     +--------------------------------------+
     |      3     |      B3       |  SID-B3 | 
     +--------------------------------------+
     |      4     |      B4       |  SID-E  | 
     +--------------------------------------+
     |      5     |      B5       |  SID-B5 | 
     +--------------------------------------+
     |      6     |      B6       |  SID-B6 | 
     +--------------------------------------+
     |      7     |      B7       |  SID-B7 | 
     +--------------------------------------+
     |      8     |      B8       |  SID-B8 | 
     +--------------------------------------+
   Local Bitstring Forwarding Table(LBFT) in Node B
]]></artwork>
            </figure></t>

          <t/>

          <t>Node C will receive the packet with the destination address of
          the IPv6 header is a local End.RLB for node C, which is SID C. Based
          on the End.RLB behavior defined in section 4, the node will parse
          SID[Segment Left] in MRH, which is SID[3].</t>

          <t>SID[3] will be used as an entry to look up LBFT in node C. So the
          packet will be replicated into 2 packets. For the 1st packet, the
          destination address of the IPv6 header will be set to SID F, the
          Segment Left will be set to 0 based on the pointer and the packet
          will be sent out through C4. For the 2nd packet, the destination
          address of the IPv6 header will be set to SID G, the Segment Left
          will be set to 0 based on the pointer and the packet will be sent
          out through C7.</t>

          <t><figure>
              <artwork><![CDATA[     +--------------------------------------+
     |BitPosition | Adjacency Link| RLB SID | 
     +--------------------------------------+
     |      1     |      C1       |  SID-C1 | 
     +--------------------------------------+
     |      2     |      C2       |  SID-C2 | 
     +--------------------------------------+
     |      3     |      C3       |  SID-C3 | 
     +--------------------------------------+
     |      4     |      C4       |  SID-F  | 
     +--------------------------------------+
     |      5     |      C5       |  SID-C5 | 
     +--------------------------------------+
     |      6     |      C6       |  SID-C6 | 
     +--------------------------------------+
     |      7     |      C7       |  SID-G  | 
     +--------------------------------------+
     |      8     |      C8       |  SID-C8 | 
     +--------------------------------------+
   Local Bitstring Forwarding Table(LBFT) in Node C
]]></artwork>
            </figure></t>

          <t>Node D will receive the packet with the destination address of
          the IPv6 header is a local End.RLB for node D, which is SID D.
          Because the Segment Left is 0, the packet will decapsulate the IPv6
          header with the MRH. Node E,F,G will do the same.</t>
        </section>
      </section>
    </section>

    <section anchor="IANA" title="IANA Considerations">
      <t>This document makes no request of IANA.</t>

      <t>Note to RFC Editor: this section may be removed on publication as an
      RFC.</t>
    </section>

    <section anchor="Security" title="Security Considerations">
      <t/>
    </section>

    <section anchor="Acknowledgements" title="Acknowledgements">
      <t/>
    </section>
  </middle>

  <back>
    <references title="Normative References">
      <?rfc include="reference.RFC.2119"?>

      <?rfc include="reference.RFC.8402"?>

      <?rfc include="reference.RFC.8986"?>

      <?rfc include='reference.I-D.cheng-spring-ipv6-msr-design-consideration'
?>

      <?rfc include='reference.I-D.geng-msr6-traffic-engineering'?>

      <?rfc include='reference.I-D.chen-pim-srv6-p2mp-path'?>
    </references>

    <references title="Informative References">
      <reference anchor="InfRef">
        <front>
          <title/>

          <author>
            <organization/>
          </author>

          <date year="2004"/>
        </front>
      </reference>
    </references>
  </back>
</rfc>
