RFC 2209

Resource ReSerVation Protocol (RSVP) -- Version 1 Message Processing Rules

📅 published September 1997, from ietf

RFC 2209: Resource ReSerVation Protocol (RSVP) -- Version 1 Message Processing Rules 🎀

  • Network Working Group 💜
  • Authors: R. Braden (ISI) and L. Zhang (UCLA) 👑
  • Category: Informational 🌸
  • Date: September 1997 🦋
  • Obsoletes / Updates: none listed in the title block ✨
Part 1 of 5. Stay tuned, there's more to come 💅

Status of This Memo 📜

okay so this memo is giving information for the Internet community 💖. It is NOT an Internet standard of any kind, and you can distribute it as much as you want, no limits 🫶.

Abstract 🌈

bestie, this memo is an algorithmic walkthrough of the rules an RSVP implementation uses to process messages 🧠. It's here to clarify the version 1 RSVP protocol spec, and it's lowkey iconic for that.

This memo gives a generic rundown of the rules for how Version 1 of RSVP [RFC 2205] operates. The goal is a set of algorithms that gets the needed job done, but it skips a bunch of details on purpose 🍓.

1. GENERIC DATA STRUCTURES ✨

This memo assumes the generic interface calls defined in [RFC 2005] plus the data structures below. An actual implementation might use additional or different data structures and interfaces, so don't panic if yours looks different 💅. The data structure fields that are shown are required unless they are explicitly labelled as optional.

  • PSB -- Path State Block 🛣️

Each PSB holds path state for a particular (session, sender) pair. That pair is defined by the SESSION and SENDER_TEMPLATE objects, received in a PATH message.

A PSB's contents include these values from a PATH message:

  • Session
  • Sender_Template
  • Sender_Tspec
  • The previous hop IP address and the Logical Interface Handle (LIH) from a PHOP object
  • The remaining IP TTL
  • POLICY_DATA and/or ADSPEC objects (optional)
  • Non_RSVP flag
  • E_Police flag
  • Local_Only flag

The PSB also holds info provided by routing: OutInterface_list, the list of outgoing interfaces for this (sender, destination), and IncInterface, the expected incoming interface. For a unicast destination, OutInterface_list has one entry and IncInterface is undefined.

Heads up, there can be more than one PSB for the same (session, sender) pair if they have different incoming interfaces 👀. At most one of these will have the Local_Only flag off, and that's the PSB used for forwarding PATH messages downstream. We'll call it the "forwarding PSB" from here on. The other PSBs will have the Local_Only flag on and an empty OutInterface_list. The Local_Only flag is needed to correctly match PSBs against RSBs, by the rules of [RFC 2205] 🔥.

  • RSB -- Reservation State Block 💌

Each RSB holds a reservation request that arrived in a particular RESV message. It corresponds to the triple: (session, next hop, Filter_spec_list). Here, Filter_spec_list can be a list of FILTER_SPECs (for SE style), a single FILTER_SPEC (FF style), or empty (WF style). We define the virtual object type FILTER_SPEC* for this data structure.

RSB contents include:

  • Session specification
  • Next hop IP address
  • Filter_spec_list
  • The outgoing (logical) interface OI on which the reservation is to be made or has been made
  • Style
  • Flowspec
  • A SCOPE object (optional, depending upon style)
  • RESV_CONFIRM object that was received (optional)
  • TCSB -- Traffic Control State Block 🚦

Each TCSB holds the reservation specification that has been handed to traffic control for a specific outgoing interface. Generally, TCSB info is derived from the RSBs for that same outgoing interface. Each TCSB defines a single reservation for a particular triple: (session, OI, Filter_spec_list).

TCSB contents include:

  • Session
  • OI (Outgoing Interface)
  • Filter_spec_list
  • TC_Flowspec, the effective flowspec, i.e., the LUB over the corresponding FLOWSPEC values from matching RSBs. TC_Flowspec is passed to traffic control to make the actual reservation.
  • Fwd_Flowspec, the updated object to be forwarded after merging
  • TC_Tspec, equal to Path_Te, the effective sender Tspec
  • Police Flags: the flags are E_Police_Flag, M_Police_Flag, and B_Police_Flag
  • Rhandle, F_Handle_list: handles returned by the traffic control interface, corresponding to a flowspec and perhaps a list of filter specs
  • A RESV_CONFIRM object to be forwarded
  • BSB -- Blockade State Block 🧱

Each BSB contains an element of blockade state. Depending on the reservation style in use, BSBs may be per (session, Sender_Template) pair or per (session, PHOP) pair. In practice, an implementation might embed a BSB within a PSB, but for clarity we describe BSBs independently 💭.

The contents of a BSB include:

  • Session
  • Sender_Template (which is also a filter spec)
  • PHOP
  • FLOWSPEC Qb
  • Blockade timer Tb

The following Boolean flag variables are used in this section: Path_Refresh_Needed, Resv_Refresh_Needed, Tear_Needed, Need_Scope, B_Merge, and NeworMod. Refresh_PHOP_list is a variable-length list of PHOPs to be refreshed.

2. PROCESSING RULES ✨

MESSAGE ARRIVES 📬

Verify the version number and RSVP checksum. Discard the message if any mismatch is found 🙅‍♀️.

If the message type is not PATH, PTEAR, or RACK, and the IP destination address does not match any of the addresses of the local interfaces, then forward the message to the IP destination address and return.

Parse the sequence of objects in the message. If any required objects are missing, or the length field of the common header does not match an object boundary, discard the message and return.

Verify the INTEGRITY object, if there is one. If the check fails, discard the message and return.

Verify the consistent use of port fields. If the DstPort in the SESSION object is zero, but the SrcPort in a SENDER_TEMPLATE or FILTER_SPEC object is non-zero, then the message has a "conflicting source port" error. Silently discard the message and return 🤫.

Processing of POLICY_DATA objects will be specified in the future 🔮.

Further processing depends upon the message type.

PATH MESSAGE ARRIVES 🛣️

Assume the PATH message arrives on interface InIf.

Process the sender descriptor object sequence in the message as follows. The Path_Refresh_Needed and Resv_Refresh_Needed flags are initially off.

  • Search for a path state block (PSB) whose (session, sender_template) pair matches the corresponding objects in the message, and whose IncInterface matches InIf.

During this search:

  1. If a PSB is found whose session matches the DestAddress and Protocol Id fields of the received SESSION object, but the DstPorts differ and one is zero, then build and send a "Conflicting Dst Port" PERR message, drop the PATH message, and return.
  2. If a PSB is found with a matching sender host, but the Src Ports differ and one of the SrcPorts is zero, then build and send an "Ambiguous Path" PERR message, drop the PATH message, and return.
  3. If a forwarding PSB is found, i.e., a PSB that matches the (session, sender_template) pair and whose Local_Only flag is off, save a pointer to it in the variable fPSB. If none is found, set fPSB to NULL.
  • If there was no matching PSB, then:
    1. Create a new PSB.
    2. Copy the contents of the SESSION, SENDER_TEMPLATE, SENDER_TSPEC, and PHOP (IP address and LIH) objects into the PSB.
    3. If the sender is from the local API, set OutInterface_List to the single interface whose address matches the sender address, and make IncInterface undefined. Otherwise, turn on the Local_Only flag.
    4. Turn on the Path_Refresh_Needed flag.
  • Otherwise (there is a matching PSB):
    • If the PHOP IP address, the LIH, or Sender_Tspec differs between the message and the PSB, copy the new value into the PSB and turn on the Path_Refresh_Needed flag. If the PHOP IP address or the LIH differ, also turn on the Resv_Refresh_Needed flag.
  • Call the resulting PSB the "current PSB" (cPSB). Update the cPSB as follows:
    • Start or restart the cleanup timer for the PSB.
    • If the message contains an ADSPEC object, copy it into the PSB.
    • Copy the E_Police flag from the SESSION object into the PSB.
    • Store the received TTL into the PSB. If the received TTL differs from Send_TTL in the RSVP common header, set the Non_RSVP flag on in the PSB.
  • If the PSB is new, or if there is no route change notification in place, then perform the following routing manipulations, but not if the cPSB is from the local API.
    1. Invoke the appropriate Route_Query routine using DestAddress from SESSION and (for multicast routing) SrcAddress from Sender_Template. Call the results (Rt_OutL, Rt_InIf).
    2. If the destination is multicast and Rt_InIf differs from IncInterface in the cPSB, but fPSB points to the cPSB, then do the following:
      • Turn on the Local_Only flag and clear the OutInterface_list of the fPSB. Set the fPSB pointer to NULL.
      • Search for a PSB for the same (session, sender_template) pair whose IncInterface matches Rt_InIf. If one is found, set fPSB to point to it.
    3. If the destination is multicast and Rt_InIf is the same as IncInterface in the cPSB, but fPSB does not point to the cPSB, then do the following:
      • Copy into the cPSB the OutInterface_list from the PSB, if any, pointed to by fPSB. Clear the OutInterface_list and turn on the Local_Only flag in the PSB pointed to by fPSB, if any.
      • Turn off the Local_Only flag in the cPSB and set fPSB to point to the cPSB.
    4. If Rt_OutL differs from the OutInterface_list of the PSB pointed to by fPSB, then:
      • Update the OutInterface_list of the PSB from Rt_OutL, and then execute the PATH LOCAL REPAIR event sequence below.
  • If the Path_Refresh_Needed flag is now off, drop the PATH message and return.

Okay bestie, so if the path state is brand new or got modified, we run the refreshes, upcalls, and state updates, and it's giving main character energy 🦋

  1. If this PATH message came from a network interface and not from a local application, make a Path Event upcall for each local application for this session:
Call: <Upcall_Proc>( session-id, PATH_EVENT,
             flags, sender_tspec, sender_template
             [ , ADSPEC] [ , POLICY_DATA] )
  1. If OutInterface_list is not empty, run the PATH REFRESH event sequence (below) for the sender defined by the PSB 🌸
  2. Search for any matching reservation state, aka an RSB whose Filter_spec_list includes a FILTER_SPEC matching the SENDER_TEMPLATE and whose OI shows up in the OutInterface_list. Make this the `active RSB'. ✨

If none is found, drop the PATH message and return. Not me dropping it like it's hot 💀

  1. Run the RESV REFRESH sequence (below) for the PHOP in the PSB.
  2. Run the event sequence UPDATE TRAFFIC CONTROL to update the local traffic control state if it's needed. This sequence turns on the Resv_Refresh_Needed flag if the traffic control state got modified in a way that should trigger a reservation refresh. If so, run the RESV REFRESH sequence for the PHOP in the PSB. 🫶
  • Drop the PATH message and return. Bye bye 👋

PTEAR MESSAGE ARRIVES 🌈

  • Search for a PSB whose (Session, Sender_Template) pair matches the corresponding objects in the message. If no matching PSB is found, drop the PTEAR message and return. 🙈
  • Forward a copy of the PTEAR message to each outgoing interface listed in OutInterface_list of the PSB.
  • Find each RSB that matches this PSB, aka whose Filter_spec_list matches Sender_Template in the PSB and whose OI is included in OutInterface_list.
    1. If the RSB style is explicit, then:
      • Delete from Filter_spec_list the FILTER_SPEC that matches the PSB.
      • If Filter_spec_list is now empty, delete the RSB.
    2. Otherwise (RSB style is wildcard) then:
      • If this RSB matches no other PSB, then delete the RSB.
    3. If an RSB was found, run the event sequence UPDATE TRAFFIC CONTROL (below) to update the traffic control state so it matches the current reservation and path state. 🔥
  • Delete the PSB. Gone, reduced to nothing 💅
  • Drop the PTEAR message and return.

PERR MESSAGE ARRIVES 🍓

  • Search for a PSB whose (SESSION, SENDER_TEMPLATE) pair matches the corresponding objects in the message. If no matching PSB is found, drop the PERR message and return.
  • If the previous hop address in the PSB is the local API, make an error upcall to the application:
Call: <Upcall_Proc>( session-id, PATH_ERROR,
               Error_code, Error_value, Node_Addr,
               Sender_Template [ , Policy_Data] )

Any SENDER_TSPEC or ADSPEC object in the message is ignored. Those objects are not the vibe here 🙅‍♀️

Otherwise, send a copy of the PERR message to the PHOP IP address.

  • Drop the PERR message and return.

RESV MESSAGE ARRIVES 🎀

Initially, Refresh_PHOP_list is empty and the Resv_Refresh_Needed and NeworMod flags are off. These variables are used to control immediate reservation refreshes. Think of them as the little reminders that keep everything on track 🧚

  • Determine the Outgoing Interface OI. The logical outgoing interface OI is taken from the LIH in the NHOP object. (If the physical interface is not implied by the LIH, it can be learned from the interface matching the IP destination address.) 🦋
  • Check the path state.
    1. If there are no existing PSB's for SESSION, then build and send an RERR message (as described later) specifying "No path information", drop the RESV message, and return. Oop, nothing to reserve 😭
    2. If a PSB is found with a matching sender host but the SrcPorts differ and one of the SrcPorts is zero, then build and send an "Ambiguous Path" PERR message, drop the RESV message, and return. 🙈
  • Check for incompatible styles. If any existing RSB for the session has a style that is incompatible with the style of the message, build and send a RERR message specifying "Conflicting Style", drop the RESV message, and return. Styles gotta match, no clashing 💅

Process the flow descriptor list to make reservations, as follows, depending upon the style. The following uses a filter spec list struct Filtss of type FILTER_SPEC* (defined earlier).

For FF style: run the following steps independently for each flow descriptor in the message, aka for each (FLOWSPEC, Filtss) pair. Here the structure Filtss consists of the FILTER_SPEC from the flow descriptor.

For SE style, run the following steps once for (FLOWSPEC, Filtss), with Filtss consisting of the list of FILTER_SPEC objects from the flow descriptor.

For WF style, run the following steps once for (FLOWSPEC, Filtss), with Filtss an empty list. ✨

  • Check the path state, as follows.
    1. Locate the set of PSBs (senders) that route to OI and whose SENDER_TEMPLATEs match a FILTER_SPEC in Filtss. If this set is empty, build and send an error message specifying "No sender information", and continue with the next flow descriptor in the RESV message.
    2. If the style has explicit sender selection (e.g., FF or SE) and if any FILTER_SPEC included in Filtss matches more than one PSB, build and send a RERR message specifying "Ambiguous filter spec" and continue with the next flow descriptor in the RESV message.
    3. If the style is SE and if some FILTER_SPEC included in Filtss matches no PSB, delete that FILTER_SPEC from Filtss.
    4. Add the PHOP from the PSB to Refresh_PHOP_list, if the PHOP is not already on the list.
  • Find or create a reservation state block (RSB) for (SESSION, NHOP). If the style is distinct, Filtss is also used in the selection. Call this the "active RSB". 🌟
  • If the active RSB is new:
    1. Set the session, NHOP, OI and style of the RSB from the message.
    2. Copy Filtss into the Filter_spec_list of the RSB.
    3. Copy the FLOWSPEC and any SCOPE object from the message into the RSB.
    4. Set NeworMod flag on.
  • If the active RSB is not new, check whether Filtss from the message contains FILTER_SPECs that are not in the RSB; if so, add the new FILTER_SPECs and turn on the NeworMod flag.
  • Start or restart the cleanup timer on the active RSB, or, in the case of SE style, on each FILTER_SPEC of the RSB that also appears in Filtss. ⏰
  • If the active RSB is not new, check whether STYLE, FLOWSPEC or SCOPE objects have changed; if so, copy changed object into RSB and turn on the NeworMod flag.
  • If the message contained a RESV_CONFIRM object, copy it into the RSB and turn on NeworMod flag.
  • If the NeworMod flag is off, continue with the next flow descriptor in the RESV message, if any.
  • Otherwise (the NeworMod flag is on, aka the active RSB is new or modified), run the UPDATE TRAFFIC CONTROL event sequence (below). If the result is to modify the traffic control state, this sequence turns on the Resv_Refresh_Needed flag and makes a RESV_EVENT upcall to any local application. 💖

If the UPDATE TRAFFIC CONTROL sequence fails with an error, then delete a new RSB but restore the original reservation in an old RSB. Rough moment, but we recover 😭

  • Continue with the next flow descriptor.
  • When all flow descriptors have been processed, check the Resv_Refresh_Needed flag. If it is now on, run the RESV REFRESH sequence (below) for each PHOP in Refresh_PHOP_list.
  • Drop the RESV message and return.

If processing a RESV message finds an error, a RERR message is created containing the flow descriptor and an ERRORS object. The Error Node field of the ERRORS object is set to the IP address of OI, and the message is sent unicast to NHOP. Errors get reported, no ghosting 👻

RTEAR MESSAGE ARRIVES 🧚

Processing of a RTEAR message roughly parallels the processing of the corresponding RESV message. 🌸

A RTEAR message arrives with an IP destination address matching outgoing interface OI. Flag Resv_Refresh_Needed is initially off and Refresh_PHOP_list is empty.

  • Determine the Outgoing Interface OI. The logical outgoing interface OI is taken from the LIH in the NHOP object. (If the physical interface is not implied by the LIH, it can be learned from the interface matching the IP destination address.)
  • Process the flow descriptor list in the RTEAR message to tear down local reservation state, as follows, depending upon the style. The following uses a filter spec list struct Filtss of type FILTER_SPEC* (defined earlier).

For FF style: run the following steps independently for each flow descriptor in the message, aka for each (FLOWSPEC, Filtss) pair. Here the structure Filtss consists of the FILTER_SPEC from the flow descriptor.

For SE style, run the following steps once for (FLOWSPEC, Filtss), with Filtss consisting of the list of FILTER_SPEC objects from the flow descriptor.

For WF style, run the following steps once for (FLOWSPEC, Filtss), with Filtss an empty list.

  1. Find an RSB matching (SESSION, NHOP). If the style is distinct, Filtss is also used in the selection. Call this the "active RSB". If no active RSB is found, continue with the next flow descriptor.
  2. Check the style. If the active RSB has a style that is incompatible with the style of the message, drop the RTEAR message and return.
  3. Delete from the active RSB each FILTER_SPEC that matches a FILTER_SPEC in Filtss.
  4. If all FILTER_SPECs have now been deleted from the active RSB, delete the active RSB. 🗑️
  1. Run the UPDATE TRAFFIC CONTROL sequence (below) to bring the traffic control state in line with the reservation state. If that changes the traffic control state, the Resv_Refresh_Needed flag gets turned on and a RESV_EVENT upcall goes out to any local application 🔥.
  2. Continue with the next flow descriptor. 💅
  • All flow descriptors have been processed. ✨

Now it's time to build and send any RTEAR messages that need forwarding, like this 🦋

  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.
    • 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. 🚀
  • 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. 🔁
  • Drop the RTEAR message and return. 👋

RERR MESSAGE ARRIVES 💌

A RERR message arrives through the (real) incoming interface In_If. Okay, bestie, pay attention, this one's juicy 👀

  • If there is no path state for SESSION, drop the RERR message and return. 🥲
  • 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. 🧚

  1. 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. 💖
  2. 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. ⚠️
  • 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. 📣

  1. 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. 🔍
  2. 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. 📬
  3. Continue with the next RSB. ➡️
  • Drop the RERR message and return. 🙌

RESV CONFIRM ARRIVES 🎉

  • 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 )
  • 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. It's giving main character energy, honestly 💜

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. ✨

  • 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.
      • 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. ➕
  • 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. 🆕

  • 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
  1. 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. 💔
  2. 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. 🎯

  • 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 )
  1. Delete the TCSB and return.
  • 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
  1. 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.
  2. Otherwise (the call succeeds), update the TCSB with the new values and save Fwd_Flowspec in the TCSB. 💾
  • 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*.
    2. Turn on the Resv_Refresh_Needed flag.
  • If the active RSB contains a RESV_CONFIRM object, then:

okay so we're mid-RESV_CONFIRM bestie and it's giving "careful or your reservation gets dragged" 💅

  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" ✨
  • 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.

  • 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. it 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. 💜

  • Insert TIME_VALUES object into the PATH message being built. Compute the IP TTL for the PATH message as one less than the TTL value received in the message. However, if the result is zero, return without sending the PATH message. 🍓
  • Create a sender descriptor containing the SENDER_TEMPLATE, SENDER_TSPEC, and POLICY_DATA objects, if present in the PSB, and pack it into the PATH message being built. ✨
  • Send a copy of the PATH message to each interface OI in OutInterface_list. Before sending each copy:
    1. If the PSB has the E_Police flag on and if interface OI is not capable of policing, turn the E_Police flag on in the PATH message being built. 🔥
    2. Pass the ADSPEC object and Non_RSVP flag present in the PSB to the traffic control call TC_Advertise. Insert the modified ADSPEC object that is returned into the PATH message being built. 💅
    3. Insert into its PHOP object the interface address and the LIH for the interface. 🫶

RESV REFRESH 🌈

this sequence sends a reservation refresh towards a particular previous hop with IP address PH. it MAY be entered by the expiration of a refresh timer, or invoked from the PATH MESSAGE ARRIVES, RESV MESSAGE ARRIVES, RTEAR MESSAGE ARRIVES, or RERR MESSAGE ARRIVES sequence. 👑

in general, this sequence considers each of the PSB's with PHOP address PH. for a given PSB, it scans the TCSBs for matching reservations and merges the styles, FLOWSPECs and Filter_spec_list's appropriately. it then builds a RESV message and sends it to PH. the details depend upon the attributes of the style(s) included in the reservations. 🦋

initially the Need_Scope flag is off and the new_SCOPE object is empty. 🙈

  • Create an output message containing INTEGRITY (if configured), SESSION, RSVP_HOP, and TIME_VALUES objects. 🌸
  • Determine the style for these reservations from the first RSB for the session, and move the STYLE object into the proto-message. (Note that the present set of styles are never themselves merged; if future styles can be merged, these rules will become more complex). 🧚
  • If style is wildcard and if there are PSB's from more than one PHOP and if the multicast routing protocol does not use shared trees, set the Need_Scope flag on. 💖
  • Select each sender PSB whose PHOP has address PH. Set the local flag B_Merge off and execute the following steps. 🍓
    1. Select all TCSB's whose Filter_spec_list's match the SENDER_TEMPLATE object in the PSB and whose OI appears in the OutInterface_list of the PSB. ✨
    2. If the PSB is from the API, then:
      • If TCSB contains a CONFIRM object, then create and send a RACK message containing the object and delete the CONFIRM object from the TCSB. 💅
      • Continue with next PSB. 🫶
    3. If B_Merge flag is off then ignore a blockaded TCSB, as follows.
      • Select BSB's that match this TCSB. If a selected BSB is expired, delete it. If any of the unexpired BSB's has a Qb that is not strictly larger than TC_Flowspec, then continue processing with the next TCSB. 🔥

However, if steps 1 and 2 result in finding that all TCSB's matching this PSB are blockaded, then:

  • If this RESV REFRESH sequence was invoked from RESV ERROR RECEIVED, then return to the latter. 💀
  • Otherwise, turn on the B_Merge flag and restart at step 1, immediately above. 🌈
  1. Merge the flowspecs from this set of TCSB's, as follows:
    • If B_Merge flag is off, compute the LUB over the flowspec objects. From each TCSB, use the Fwd_Flowspec object if present, else use the normal Flowspec object.

While computing the LUB, check for a RESV_CONFIRM object in each TCSB. If a RESV_CONFIRM object is found:

  • If the flowspec (Fwd_Flowspec or Flowspec) in that TCSB is larger than all other (non-blockaded) flowspecs being compared, then save this RESV_CONFIRM object for forwarding and delete from the TCSB. 👑
  • Otherwise (the corresponding flowspec is not the largest), 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 specifying "No Error". 🎀
  • Delete the RESV_CONFIRM object from the TCSB. ✨
  • Otherwise (B_Merge flag is on), compute the GLB over the Flowspec objects of this set of TCSB's.

While computing the GLB, delete any RESV_CONFIRM object object in any of these TCSB's. 🧚

  1. (All matching TCSB's have been processed). The next step depends upon the style attributes.
    • Distinct reservation (FF) style: Use the Sender_Template as the merged FILTER_SPEC. Pack the merged (FLOWSPEC, FILTER_SPEC, F_POLICY_DATA) triplet into the message as a flow descriptor. 💖
    • Shared wildcard reservation (WF) style: There is no merged FILTER_SPEC. Merge (compute the LUB of) the merged FLOWSPECS from the TCSB's, across all PSB's for PH. 🌸
    • Shared distinct reservation (SE) style: Using the Sender_Template as the merged FILTER_SPEC, form the union of the FILTER_SPECS obtained from the TCSB's. Merge (compute the LUB of) the merged FLOWSPECS from the TCSB's, across all PSB's for PH. 🍓
  2. If the Need_Scope flag is on and the sender specified by the PSB is not the local API:
    • Find each RSB that matches this PSB, i.e., whose Filter_spec_list matches Sender_Template in the PSB and whose OI is included in OutInterface_list. 🦋
    • If the RSB either has no SCOPE list or its SCOPE list includes the sender IP address from the PSB, insert the sender IP address into new_SCOPE. 🫶
  • (All PSB's for PH have been processed). Finish the RESV message. 👑
    1. If Need_Scope flag is on but new_SCOPE is empty, no RESV message SHOULD be sent; return. Otherwise, if Need_Scope is on, move new_SCOPE into the message. 💀
    2. If a shared reservation style is being built, move the final merged FLOWSPEC object and filter spec list into the message. ✨
    3. If a RESV_CONFIRM object was saved earlier, move it into the new RESV message. 🌈
    4. Set the RSVP_HOP object in the message to contain the IncInterface address through which it will be sent and the LIH from (one of) the PSB's. 🧚
  • Send the message to the address PH. 💅

ROUTE CHANGE NOTIFICATION 🎀

this sequence is triggered when routing sends a route change notification to RSVP. 🦋

  • Each PSB is located whose SESSION matches the destination address and whose SENDER_TEMPLATE matches the source address (for multicast).
    1. If the OutInterface_list from the notification differs from that in the PSB, execute the PATH LOCAL REPAIR sequence. 🔥
    2. If the IncInterface from the notification differs from that in the PSB, update the PSB. 🌸

PATH LOCAL REPAIR 💖

the sequence is entered to effect local repair after a route change for a given PSB. 🍓

  • Wait for a delay time of W seconds. ⭐
  • Execute the PATH REFRESH event sequence (above) for the PSB. 👑

References 📚

[Baker96] Baker, F., "RSVP Cryptographic Authentication", Work in Progress.

[RFC 2205] Braden, R., Ed., Zhang, L., Berson, S., Herzog, S., and S. Jamin, "Resource ReSerVation Protocol (RSVP) -- Version 1 FunctionalSpecification", RFC 2205, September 1997.

[RFC 2207] Berger, L. and T. O'Malley, "RSVP Extensions for IPSEC IPv4 Data Flows", RFC 2207, September 1997.

[RSVP93] Zhang, L., Deering, S., Estrin, D., Shenker, S., and D. Zappala, "RSVP: A New Resource ReSerVation Protocol", IEEE Network, September 1993.

Security Considerations 🚨

Processing the RSVP INTEGRITY object [Baker96] is only mentioned in this memo, because the processing rules are described here only in general terms. The RSVP support for IPSEC [RFC 2207] will imply modifications that have not yet been incorporated into these processing rules. 😭🔐

Okay bestie, we're wrapping up RFC 2209 and this last bit is just the contact info for the two authors 💖

Authors' Addresses 🎀

Bob Braden, who is totally iconic, hangs out at USC Information Sciences Institute 🦋 at 4676 Admiralty Way, Marina del Rey, CA 90292. You can call him at (310) 822-1511 📞 or email Braden@ISI.EDU 💌.

Lixia Zhang 🧚 is at the UCLA Computer Science Department, 4531G Boelter Hall, Los Angeles, CA 90095-1596 USA 🌸. Her phone is 310-825-2695 and her email is lixia@cs.ucla.edu 💜.

And that's the whole RFC, babe. Two legends who literally built the foundations, no cap 👑✨

📦 where this page comes from