rfc2209.txt

著名的RFC文档,其中有一些文档是已经翻译成中文的的.

             6.   Continue with the next flow descriptor.

        o    All flow descriptors have been processed.

             Build and send any RTEAR messages to be forwarded, in the
             following manner.

             1.   Select each PSB that routes to the outgoing interface
                  OI, and, for distinct style, that has a
                  SENDER_TEMPLATE matching Filtss.

             2.   Select a flow descriptor (Qj,Fj) (where Fj may be a
                  list) in the RTEAR message whose FILTER_SPEC matches
                  the SENDER_TEMPLATE in the PSB.  If not match is
                  found, return for next PSB.

                  -    Search for an RSB (for any outgoing interface) to
                       which the PSB routes and whose Filter_spec_list
                       includes the SENDER_TEMPLATE from the PSB.

                  -    If an RSB is found, add the PHOP of the PSB to
                       the Refresh_PHOP_list.




Braden & Zhang               Informational                     [Page 13]

RFC 2209                RSVP-Message Processing           September 1997


                  -    Otherwise (no RSB is found), add the flow
                       descriptor (Qj,Fj) to the new RTEAR message being
                       built, in a manner appropriate to the style.

                  -    Continue with the next PSB.

             3.   If the next PSB is for a different PHOP or the last
                  PSB has been processed, forward any RTEAR message that
                  has been built.

        o    If any PSB's were found in the preceding step, and if the
             Resv_Refresh_Needed flag is now on, execute the RESV
             REFRESH sequence (below) for each PHOP in
             Refresh_PHOP_list.

        o    Drop the RTEAR message and return.

   RERR MESSAGE ARRIVES

        A RERR message arrives through the (real) incoming interface
        In_If.

        o    If there is no path state for SESSION, drop the RERR
             message and return.

        o    If the Error Code = 01 (Admission Control failure), do
             special processing as follows:

             1.   Find or create a Blockade State Block (BSB), in the
                  following style-dependent manner.

                  For WF (wildcard) style, there will be one BSB per
                  (session, PHOP) pair.

                  For FF style, there will be one BSB per (session,
                  filter_spec) pair.  Note that an FF style RERR message
                  carries only one flow descriptor.

                  For SE style, there will be one BSB per (session,
                  filter_spec), for each filter_spec contained in the
                  filter spec list of the flow descriptor.

             2.   For each BSB in the preceding step, set (or replace)
                  its FLOWSPEC Qb with FLOWSPEC from the message, and
                  set (or reset) its timer Tb to Kb*R seconds.  If the
                  BSB is new, set its PHOP value, and set its
                  Sender_Template equal to the appropriate filter_spec
                  from the message.



Braden & Zhang               Informational                     [Page 14]

RFC 2209                RSVP-Message Processing           September 1997


             3.   Execute the RESV REFRESH event sequence (shown below)
                  for the previous hop PHOP, but only with the B_Merge
                  flag off.  That is, if processing in the RESV REFRESH
                  sequence reaches the point of turning the B_Merge flag
                  on (because all matching reservations are blockaded),
                  do not turn it on but instead exit the REFRESH
                  sequence and return here.

        o    Execute the following for each RSB for this session whose
             OI differs from In_If and whose Filter_spec_list has at
             least one filter spec in common with the FILTER_SPEC* in
             the RERR message.   For WF style, empty FILTER_SPEC*
             structures are assumed to match.

             1.   If Error_Code = 01 and the InPlace flag in the
                  ERROR_SPEC is 1 and one or more of the BSB's
                  found/created above has a Qb that is strictly greater
                  than Flowspec in the RSB, then continue with the next
                  matching RSB, if any.

             2.   If NHOP in the RSB is the local API, then:

                  -    If the FLOWSPEC in the RERR message is strictly
                       greater than the RSB Flowspec, then turn on the
                       NotGuilty flag in the ERROR_SPEC.

                  -    Deliver an error upcall to application:

                        Call: <Upcall_Proc>( session-id, RESV_ERROR,
                                        Error_code, Error_value,
                                           Node_Addr,  Error_flags,
                                           Flowspec, Filter_Spec_List
                                            [ , Policy_data] )

                       and continue with the next RSB.

             3.   If the style has wildcard sender selection, use the
                  SCOPE object SC.In from the RERR message to construct
                  a SCOPE object SC.Out to be forwarded.  SC.Out should
                  contain those sender addresses that appeared in SC.In
                  and that route to OI, as determined by scanning the
                  PSB's.  If SC.Out is empty, continue with the next
                  RSB.

             4.   Create a new RERR message containing the error flow
                  descriptor and send to the NHOP address specified by
                  the RSB.  Include SC.Out if the style has wildcard
                  sender selection.



Braden & Zhang               Informational                     [Page 15]

RFC 2209                RSVP-Message Processing           September 1997


             5.   Continue with the next RSB.

        o    Drop the RERR message and return.

   RESV CONFIRM ARRIVES

        o    If the (unicast) IP address found in the RESV_CONFIRM
             object in the RACK message matches an interface of the
             node, a confirmation upcall is made to the matching
             application:

                  Call: <Upcall_Proc>( session-id, RESV_CONFIRM,
                              Error_code, Error_value, Node_Addr,
                                  LUB-Used, nlist, Flowspec,
                                  Filter_Spec_List, NULL, NULL )

        o    Otherwise, forward the RACK message to the IP address in
             its RESV_CONFIRM object.

        Drop the RACK message and return.

   UPDATE TRAFFIC CONTROL

        The sequence is invoked by many of the message arrival sequences
        to set or adjust the local traffic control state in accordance
        with the current reservation and path state.  An implicit
        parameter of this sequence is the `active' RSB.

        If the result is to modify the traffic control state, this
        sequence notifies any matching local applications with a
        RESV_EVENT upcall.  If the state change is such that it should
        trigger immediate RESV refresh messages, it also turns on the
        Resv_Refresh_Needed flag.

        o    Compute the traffic control parameters using the following
             steps.

             1.   Initially the local flag Is_Biggest is off.

             2.   Consider the set of RSB's matching SESSION and OI from
                  the active RSB.  If the style of the active RSB is
                  distinct, then the Filter_spec_list must also be
                  matched.

                  -    Compute the effective kernel flowspec,
                       TC_Flowspec, as the LUB of the FLOWSPEC values in
                       these RSB's.




Braden & Zhang               Informational                     [Page 16]

RFC 2209                RSVP-Message Processing           September 1997


                  -    Compute the effective traffic control filter spec
                       (list) TC_Filter_Spec* as the union of the
                       Filter_spec_lists from these RSB's.

                  -    If the active RSB has a FLOWSPEC larger than all
                       the others, turn on the Is_Biggest flag.

             3.   Scan all RSB's matching session and Filtss, for all
                  OI.  Set TC_B_Police_flag on if TC_Flowspec is smaller
                  than, or incomparable to, any FLOWSPEC in those RSB's.

             4.   Locate the set of PSBs (senders) whose
                  SENDER_TEMPLATEs match Filter_spec_list in the active
                  RSB and whose OutInterface_list includes OI.

             5.   Set TC_E_Police_flag on if any of these PSBs have
                  their E_Police flag on.  Set TC_M_Police_flag on if it
                  is a shared style and there is more than one PSB in
                  the set.

             6.   Compute Path_Te as the sum of the SENDER_TSPEC objects
                  in this set of PSBs.

        o    Search for a TCSB matching SESSION and OI; for distinct
             style (FF), it must also match Filter_spec_list.

             If none is found, create a new TCSB.

        o    If TCSB is new:

             1.   Store TC_Flowspec, TC_Filter_Spec*, Path_Te, and the
                  police flags into TCSB.

             2.   Turn the Resv_Refresh_Needed flag on and make the
                  traffic control call:

                 TC_AddFlowspec( OI, TC_Flowspec,
                              Path_Te, police_flags)
                               ->  Rhandle, Fwd_Flowspec

             3.   If this call fails, build and send a RERR message
                  specifying "Admission control failed" and with the
                  InPlace flag off.  Delete the TCSB, delete any
                  RESV_CONFIRM object from the active RSB, and return.







Braden & Zhang               Informational                     [Page 17]

RFC 2209                RSVP-Message Processing           September 1997


             4.   Otherwise (call succeeds), record Rhandle and
                  Fwd_Flowspec in the TCSB.  For each filter_spec F in
                  TC_Filter_Spec*, call:

                 TC_AddFilter( OI, Rhandle, Session, F)
                                     -> Fhandle

             and record the returned Fhandle in the TCSB.

        o    Otherwise, if TCSB is not new but no effective kernel
             flowspec TC_Flowspec was computed earlier, then:

             1.   Turn on the Resv_Refresh_Needed flag.

             2.   Call traffic control to delete the reservation:

                 TC_DelFlowspec( OI, Rhandle )

             3.   Delete the TCSB and return.

        o    Otherwise, if TCSB is not new but the TC_Flowspec, Path_Te,
             and/or police flags just computed differ from corresponding
             values in the TCSB, then:

             1.   If the TC_Flowspec and/or Path_Te values differ, turn
                  the Resv_Refresh_Needed flag on.

             2.   Call traffic control to modify the reservation:

                 TC_ModFlowspec( OI, Rhandle, TC_Flowspec,
                                Path_Te, police_flags )
                                     -> Fwd_Flowspec

             3.   If this call fails, build and send a RERR message
                  specifying "Admission control failed" and with the
                  InPlace bit on.  Delete any RESV_CONFIRM object from
                  the active RSB and return.

             4.   Otherwise (the call succeeds), update the TCSB with
                  the new values and save Fwd_Flowspec in the TCSB.

        o    If the TCSB is not new but the TC_Filter_Spec* just
             computed differs from the FILTER_SPEC* in the TCSB, then:

             1.   Make an appropriate set of TC_DelFilter and
                  TC_AddFilter calls to transform the Filter_spec_list
                  in the TCSB into the new TC_Filter_Spec*.




Braden & Zhang               Informational                     [Page 18]

RFC 2209                RSVP-Message Processing           September 1997


             2.   Turn on the Resv_Refresh_Needed flag.

        o    If the active RSB contains a RESV_CONFIRM object, then:

             1.   If the Is_Biggest flag is on, move the RESV_CONFIRM
                  object into the TCSB and turn on the
                  Resv_Refresh_Needed flag. (This will later cause the
                  RESV REFRESH sequence to be invoked, which will either
                  forward or return the RESV_CONFIRM object, deleting it
                  from the TCSB in either case).

             2.   Otherwise, create and send a RACK message to the
                  address in the RESV_CONFIRM object.  Include the
                  RESV_CONFIRM object in the RACK message.  The RACK
                  message should also include an ERROR_SPEC object whose
                  Error_Node parameter is IP address of OI from the TCSB
                  and that specifies "No Error".

        o    If the Resv_Refresh_Needed flag is on and the RSB is not
             from the API, make a RESV_EVENT upcall to any matching
             application:

                  Call: <Upcall_Proc>( session-id, RESV_EVENT,
                              style, Flowspec, Filter_spec_list [ ,
                              POLICY_DATA] )

             where Flowspec and Filter_spec_list come from the TCSB and
             the style comes from the active RSB.

        o    Return to the event sequence that invoked this one.

   PATH REFRESH

        This sequence sends a path refresh for a particular sender,
        i.e., a PSB.  This sequence may be entered by either the
        expiration of a refresh timer or directly as the result of the
        Path_Refresh_Needed flag being turned on during the processing
        of a received PATH message.