draft-ietf-pim-sm-v2-new-03.txt

xorp源码hg

Fenner/Handley/Holbrook/Kouvelas               Section 4.1.5.  [Page 18]

INTERNET-DRAFT            Expires: January 2002                July 2001


excluded.  As stored here, this state is the resulting state after any
IGMPv3 inconsistencies between LAN members have been resolved.  It need
not be kept if this router is not the DR on that interface unless this
router won a (*,G) assert on this interface for this group.  This
information is used by the pim_exclude(S,G) macro described in section
4.1.6.

PIM (S,G,rpt) Join/Prune state is the result of receiving PIM (S,G,rpt)
Join/Prune messages on this interface, and is specified in section
4.4.4. The state is used by the macros that calculate the outgoing
interface list in section 4.1.6, and in the rules for adding
Prune(S,G,rpt) messages to Join(*,G) messages specified in section
4.4.8.

The upstream (S,G,rpt) Join/Prune state is used along with the Override
Timer to send the correct override messages in response to Join/Prune
messages sent by upstream peers on a LAN.  This state and behavior are
specified in section 4.4.9.

4.1.6.  State Summarization Macros

Using this state, we define the following "macro" definitions which we
will use in the descriptions of the state machines and pseudocode in the
following sections.

The most important macros are those that define the outgoing interface
list (or "olist") for the relevant state.  An olist can be "immediate"
if it is built directly from the state of the relevant type.  For
example, the immediate_olist(S,G) is the olist that would be built if
the router only had (S,G) state and no (*,G) or (S,G,rpt) state.  In
contrast, the "inherited" olist inherits state from other types.  For
example, the inherited_olist(S,G) is the olist that is relevant for
forwarding a packet from S to G using both source-specific and group-
specific state.

There is no immediate_olist(S,G,rpt) as (S,G,rpt) state is negative
state - it removes interfaces in the (*,G) olist from the olist that is
actually used to forward traffic.  The inherited_olist(S,G,rpt) is
therefore the olist that would be used for a packet from S to G
forwarding on the RP tree.  It is a strict subset of
immediate_olist(*,G).

Generally speaking, the inherited olists are used for forwarding, and
the immediate_olists are used to make decisions about state maintenance.

immediate_olist(*,*,RP)=
    joins(*,*,RP)




Fenner/Handley/Holbrook/Kouvelas               Section 4.1.6.  [Page 19]

INTERNET-DRAFT            Expires: January 2002                July 2001


immediate_olist(*,G) =
    joins(*,G) (+) pim_include(*,G) (-) lost_assert(*,G)

immediate_olist(S,G) =
    joins(S,G) (+) pim_include(S,G) (-) lost_assert(S,G)

inherited_olist(S,G,rpt) =
        ( joins(*,*,RP(G)) (+) joins(*,G) (-) prunes(S,G,rpt) )
    (+) ( pim_include(*,G) (-) pim_exclude(S,G))
    (-) ( lost_assert(*,G) (+) lost_assert(S,G,rpt) )

inherited_olist(S,G) =
    inherited_olist(S,G,rpt) (+) immediate_olist(S,G)

The macros pim_include(*,G) and pim_include(S,G) indicate the interfaces
to which traffic might be forwarded because of hosts that are local
members on that interface.  Note that normally only the DR cares about
local membership, but when an assert happens, the assert winner takes
over responsibility for forwarding traffic to local members that have
requested traffic on a group or source/group pair.


pim_include(*,G) =
   { all interfaces I such that:
     ( ( I_am_DR( I ) AND lost_assert(*,G,I) == FALSE )
       OR AssertWinner(*,G,I) == me )
     AND  local_receiver_include(*,G,I) }

pim_include(S,G) =
    { all interfaces I such that:
      ( (I_am_DR( I ) AND lost_assert(S,G,I) == FALSE )
        OR AssertWinner(S,G,I) == me )
       AND  local_receiver_include(S,G,I) }

pim_exclude(S,G) =
    { all interfaces I such that:
      ( (I_am_DR( I ) AND lost_assert(S,G,I) == FALSE )
        OR AssertWinner(S,G,I) == me )
       AND  local_receiver_exclude(S,G,I) }


The clause "local_receiver_include(S,G,I)" is true if the IGMP module or
other local membership mechanism has determined that there are local
members on interface I that desire to receive traffic sent specifically
by S to G.  "local_receiver_include(*,G,I)" is true if the IGMP module
or other local membership mechanism has determined that there are local
members on interface I that desire to receive all traffic sent to G.
"local_receiver_exclude(S,G,I) is true if local_receiver_include(*,G,I)



Fenner/Handley/Holbrook/Kouvelas               Section 4.1.6.  [Page 20]

INTERNET-DRAFT            Expires: January 2002                July 2001


is true but none of the local members desire to receive traffic from S.

The set "joins(*,*,RP)" is the set of all interfaces on which the router
has received (*,*,RP) Joins:

joins(*,*,RP) =
    { all interfaces I such that
      DownstreamJPState(*,*,RP,I) is either Joined or
          PrunePending }

DownstreamJPState(*,*,RP,I) is the state of the finite state machine in
section 4.4.1.

The set "joins(*,G)" is the set of all interfaces on which the router
has received (*,G) Joins:

joins(*,G) =
    { all interfaces I such that
      DownstreamJPState(*,G,I) is either Joined or PrunePending }

DownstreamJPState(*,G,I) is the state of the finite state machine in
section 4.4.2.

The set "joins(S,G)" is the set of all interfaces on which the router
has received (S,G) Joins:

joins(S,G) =
    { all interfaces I such that
      DownstreamJPState(S,G,I) is either Joined or PrunePending }

DownstreamJPState(S,G,I) is the state of the finite state machine in
section 4.4.3.

The set "prunes(S,G,rpt)" is the set of all interfaces on which the
router has received (*,G) joins and (S,G,rpt) prunes.

prunes(S,G,rpt) =
    { all interfaces I such that                                         |
      DownstreamJPState(S,G,rpt,I) is Pruned or PruneTmp }               |

DownstreamJPState(S,G,rpt,I) is the state of the finite state machine in
section 4.4.4.

The set "lost_assert(*,G)" is the set of all interfaces on which the
router has received (*,G) joins but has lost a (*,G) assert.  The macro
lost_assert(*,G,I) is defined in Section 4.5.5.





Fenner/Handley/Holbrook/Kouvelas               Section 4.1.6.  [Page 21]

INTERNET-DRAFT            Expires: January 2002                July 2001


lost_assert(*,G) =
    { all interfaces I such that
      lost_assert(*,G,I) == TRUE }

The set "lost_assert(S,G,rpt)" is the set of all interfaces on which the
router has received (*,G) joins but has lost an (S,G) assert.  The macro
lost_assert(S,G,rpt,I) is defined in Section 4.5.5.

lost_assert(S,G,rpt) =
    { all interfaces I such that
      lost_assert(S,G,rpt,I) == TRUE }

The set "lost_assert(S,G)" is the set of all interfaces on which the
router has received (S,G) joins but has lost an (S,G) assert.  The macro
lost_assert(S,G,I) is defined in Section 4.5.5.

lost_assert(S,G) =
    { all interfaces I such that
      lost_assert(S,G,I) == TRUE }



The following pseudocode macro definitions are also used in many places
in the specification.  Basically RPF' is the RPF neighbor towards an RP
or source unless a PIM-Assert has overridden the normal choice of
neighbor.

  neighbor RPF'(*,G) {
      if ( I_Am_Assert_Loser(*,G,RPF_interface(RP(G))) ) {
           return AssertWinner(*, G, RPF_interface(RP(G)) )
      } else {
           return MRIB.next_hop( RP(G) )
      }
  }


  neighbor RPF'(S,G,rpt) {
      if( I_Am_Assert_Loser(S, G, RPF_interface(RP(G)) ) ) {
           return AssertWinner(S, G, RPF_interface(RP(G)) )
      } else {
           return RPF'(*,G)
      }
  }








Fenner/Handley/Holbrook/Kouvelas               Section 4.1.6.  [Page 22]

INTERNET-DRAFT            Expires: January 2002                July 2001


  neighbor RPF'(S,G) {
      if ( I_Am_Assert_loser(S, G, RPF_interface(S) )) {
           return AssertWinner(S, G, RPF_interface(S) )
      } else {
           return MRIB.next_hop( S )
      }
  }


RPF'(*,G) and RPF'(S,G) indicate the neighbor from which data packets
should be coming and to which joins should be sent on the RP tree and
SPT respectively.

RPF'(S,G,rpt) is basically RPF'(*,G) modified by the result of an
Assert(S,G) on RPF_interface(RP(G)).  In such a case, packets from S
will be originating from a different router than RPF'(*,G).  If we only
have active (*,G) Join state, we need to accept packets from
RPF'(S,G,rpt), and add a Prune(S,G,rpt) to the periodic Join(*,G)
messages that we send to RPF'(*,G) (See Section 4.4.8).

The function MRIB.next_hop( S ) returns the next-hop PIM neighbor toward
the host S, as indicated by the current MRIB.  If S is directly
adjacent, then MRIB.next_hop( S ) returns NULL.  At the RP for G,
MRIB.next_hop( RP(G )) returns NULL.

I_Am_Assert_loser(S, G, I) is true if the Assert start machine (in
section 4.5.1) for (S,G) on Interface I is in "I am Assert Loser" state.

I_Am_Assert_loser(*, G, I) is true if the Assert start machine (in
section 4.5.2) for (*,G) on Interface I is in "I am Assert Loser" state.

4.2.  Data Packet Forwarding Rules

The PIM-SM packet forwarding rules are defined below in pseudocode.

     iif is the incoming interface of the packet.
     S is the source address of the packet.
     G is the destination address of the packet (group address).
     RP is the address of the Rendezvous Point for this group.
     RPF_interface(S) is the interface the MRIB indicates would be used
     to route packets to S.
     RPF_interface(RP) is the interface the MRIB indicates would be used
     to route packets to RP, except at the RP when it is the
     decapsulation interface (the "virtual" interface on which register
     packets are received).

First, we restart (or start) the Keepalive timer if the source is on a
directly connected subnet.



Fenner/Handley/Holbrook/Kouvelas                 Section 4.2.  [Page 23]

INTERNET-DRAFT            Expires: January 2002                July 2001


Second, we check to see if the SPT bit should be set because we've now
switched from the RP tree to the SPT.

Next we check to see whether the packet should be accepted based on TIB
state and the interface that the packet arrived on.

If the packet should be forwarded using (S,G) state, we then build an
outgoing interface list for the packet.  If this list is not empty, then
we refresh the (S,G) state keepalive timer.

If the packet should be forwarded using (*,*,RP) or (*,G) state, then we
just build an outgoing interface list for the packet. We also check if   |
we should initiate a switch to start receiving this source on a shortest |
path tree.                                                               |

Finally we remove the incoming interface from the outgoing interface
list we've created, and if the resulting outgoing interface list is not
empty, we forward the packet out of those interfaces.