NSIS                                                               X. Fu
Internet-Draft                                          Univ. Goettingen
Expires: May 11, August 25, 2005                                   H. Tschofenig
                                                               T. Tsenov
                                                                 Siemens
                                                       November 10, 2004
                                                       February 21, 2005

                         QoS NSLP State Machine
               draft-fu-nsis-qos-nslp-statemachine-00.txt
               draft-fu-nsis-qos-nslp-statemachine-01.txt

Status of this Memo

   This document is an Internet-Draft and is subject to all provisions
   of section Section 3 of RFC 3667.  By submitting this Internet-Draft, each
   author represents that any applicable patent or other IPR claims of
   which he or she is aware have been or will be disclosed, and any of
   which he or she become aware will be disclosed, in accordance with
   RFC 3668.

   Internet-Drafts are working documents of the Internet Engineering
   Task Force (IETF), its areas, and its working groups.  Note that
   other groups may also distribute working documents as
   Internet-Drafts.

   Internet-Drafts are draft documents valid for a maximum of six months
   and may be updated, replaced, or obsoleted by other documents at any
   time.  It is inappropriate to use Internet-Drafts as reference
   material or to cite them other than as "work in progress."

   The list of current Internet-Drafts can be accessed at
   http://www.ietf.org/ietf/1id-abstracts.txt.

   The list of Internet-Draft Shadow Directories can be accessed at
   http://www.ietf.org/shadow.html.

   This Internet-Draft will expire on May 11, August 25, 2005.

Copyright Notice

   Copyright (C) The Internet Society (2004). (2005).

Abstract

   This document describes the state machines for the NSIS Signaling
   Layer Protocol for Quality-of-Service signaling (QoS NSLP).  A set of
   state machines for QoS NSLP entities at different locations of a flow
   path are presented in order to illustrate how QoS NSLP may be
   implemented.

Table of Contents

   1.   Introduction . . . . . . . . . . . . . . . . . . . . . . . . .   3
   2.   Terminology  . . . . . . . . . . . . . . . . . . . . . . . . .   4
   3.   Notational conventions used in state diagrams  . . . . . . . .   5
   4.   State Machine Symbols  . . . . . . . . . . . . . . . . . . . .   7
   5.   Common Rules . . . . . . . . . . . . . . . . . . . . . . . . .   8
     5.1  Common Procedures  . . . . . . . . . . . . . . . . . . . .   8
     5.2  Common Variables . . . . . . . . . . . . . . . . . . . . .   8
     5.3  Constants  . . . . . . . . . . . . . . . . . . . . . . . .   9
     5.4  Assumptions  . . . . . . . . . . . . . . . . . . . . . . .   9
   6.   State machine for first QNI QoS NSLP node in the flow path  . . . . . . . . . . . .  10
   7.   State machine for intermediate QNE QoS NSLP nodes . . . . . . . . . . . .  13
   8.   State machine for last QNR QoS NSLP node in the flow path  . . . . . . . . . . . .  17
   9.   Security Considerations  . . . . . . . . . . . . . . . . . . . 19  20
   10.  Open Issues  . . . . . . . . . . . . . . . . . . . . . . . . 20  21
   11.   Acknowledgments  Change History . . . . . . . . . . . . . . . . . . . . . . 21
   12.   References .  22
     11.1   Changes in Version -01 . . . . . . . . . . . . . . . . .  22
   12.  Acknowledgments  . . . . . . . . 22
   12.1  Normative . . . . . . . . . . . . . .  23
   13.  References . . . . . . . . . . . . . . . . . . . . 22
   12.2  Informative . . . . .  24
     13.1   Normative References . . . . . . . . . . . . . . . . . .  24
     13.2   Informative References . . . 22 . . . . . . . . . . . . . .  24
        Authors' Addresses . . . . . . . . . . . . . . . . . . . . . . 22  24
        Intellectual Property and Copyright Statements . . . . . . . . 24  26

1.  Introduction

   This document describes the state machines for QoS NSLP [1], trying
   to show how QoS NSLP can be implemented to support its deployment.
   The state machines described in this document are illustrative of how
   the QoS NSLP protocol defined in [1] may be implemented for the first QNI
   QoS NSLP node in the flow path, intermediate node, QNE QoS NSLP nodes, and the
   last QNR QoS NSLP node in the flow
   path.  Where there are differences [1] are authoritative.  The state
   machines are informative only.  Implementations may achieve the same
   results using different methods.

   According to [1], there are several possibilities for QoS NSLP
   signaling, at least including the following:
      end-to-end signaling vs.  scoped signaling
      sender-initiated signaling vs.  receiver-initiated signaling
   (which need to be incorporated into use scenarios when describing
   state machine.  Note they are represented by way of certain
   objects/flags in Reserve and Query messages.)

   The messages used in the QoS NSLP protocol can be summarized as
   follows:

      Requesting message       Responding message
      ------------------------+---------------------------
      RESERVE                 |None or RESERVE or RESPONSE
      QUERY                   |RESERVE or RESPONSE
      RESPONSE                |NONE
      NOTIFY                  |NONE
      ------------------------+---------------------------

   We describe a set of state machines for different roles of entities
   running QoS NSLP to illustrate how QoS NSLP may be implemented.

2.  Terminology

   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 [2].

3.  Notational conventions used in state diagrams

   The following text is reused from [3] and the state diagrams are
   based on the conventions specified in [4], Section 8.2.1.  Additional
   state machine details are taken from [5].

   The complete text is reproduced here:

      State diagrams are used to represent the operation of the protocol
      by a number of cooperating state machines each comprising a group
      of connected, mutually exclusive states.  Only one state of each
      machine can be active at any given time.

      All permissible transitions between states are represented by
      arrows, the arrowhead denoting the direction of the possible
      transition.  Labels attached to arrows denote the condition(s)
      that must be met in order for the transition to take place.  All
      conditions are expressions that evaluate to TRUE or FALSE; if a
      condition evaluates to TRUE, then the condition is met.  The label
      UCT denotes an unconditional transition (i.e., UCT always
      evaluates to TRUE).  A transition that is global in nature (i.e.,
      a transition that occurs from any of the possible states if the
      condition attached to the arrow is met) is denoted by an open
      arrow; i.e., no specific state is identified as the origin of the
      transition.  When the condition associated with a global
      transition is met, it supersedes all other exit conditions
      including UCT.  The special global condition BEGIN supersedes all
      other global conditions, and once asserted remains asserted until
      all state blocks have executed to the point that variable
      assignments and other consequences of their execution remain
      unchanged.

      On entry to a state, the procedures defined for the state (if any)
      are executed exactly once, in the order that they appear on the
      page.  Each action is deemed to be atomic; i.e., execution of a
      procedure completes before the next sequential procedure starts to
      execute.  No procedures execute outside of a state block.  The
      procedures in only one state block execute at a time, even if the
      conditions for execution of state blocks in different state
      machines are satisfied, and all procedures in an executing state
      block complete execution before the transition to and execution of
      any other state block occurs, i.e., the execution of any state
      block appears to be atomic with respect to the execution of any
      other state block and the transition condition to that state from
      the previous state is TRUE when execution commences.  The order of
      execution of state blocks in different state machines is undefined
      except as constrained by their transition conditions.  A variable
      that is set to a particular value in a state block retains this
      value until a subsequent state block executes a procedure that
      modifies the value.

      On completion of all of the procedures within a state, all exit
      conditions for the state (including all conditions associated with
      global transitions) are evaluated continuously until one of the
      conditions is met.  The label ELSE denotes a transition that
      occurs if none of the other conditions for transitions from the
      state are met (i.e., ELSE evaluates to TRUE if all other possible
      exit conditions from the state evaluate to FALSE).  Where two or
      more exit conditions with the same level of precedence become TRUE
      simultaneously, the choice as to which exit condition causes the
      state transition to take place is arbitrary.

   In addition to the above notation, there are a couple of
   clarifications specific to this document.  First, all boolean
   variables are initialized to FALSE before the state machine execution
   begins.  Second, the following notational shorthand is specific to
   this document:

   <variable> = <expression1> | <expression2> | ...
      Execution of a statement of this form will result in <variable>
      having a value of exactly one of the expressions.  The logic for
      which of those expressions gets executed is outside of the state
      machine and could be environmental, configurable, or based on
      another state machine such as that of the method.

4.  State Machine Symbols

   ( ) Used to force the precedence of operators in Boolean expressions
      and to delimit the argument(s) of actions within state boxes.
   ;  Used as a terminating delimiter for actions within state boxes.
      Where a state box contains multiple actions, the order of
      execution follows the normal language conventions for reading
      text.
   =  Assignment action.  The value of the expression to the right of
      the operator is assigned to the variable to the left of the
      operator.  Where this operator is used to define multiple
      assignments, e.g., a = b = X the action causes the value of the
      expression following the right-most assignment operator to be
      assigned to all of the variables that appear to the left of the
      right-most assignment operator.
   !  Logical NOT operator.
   && Logical AND operator.
   || Logical OR operator.
   if...then...  Conditional action.  If the Boolean expression
      following the if evaluates to TRUE, then the action following the
      then is executed.
   \{ statement 1, ...  statement N \} Compound statement.  Braces are
      used to group statements that are executed together as if they
      were a single statement.
   != Inequality.  Evaluates to TRUE if the expression to the left of
      the operator is not equal in value to the expression to the right.
   == Equality.  Evaluates to TRUE if the expression to the left of the
      operator is equal in value to the expression to the right.
   >  Greater than.  Evaluates to TRUE if the value of the expression to
      the left of the operator is greater than the value of the
      expression to the right.
   <= Less than or equal to.  Evaluates to TRUE if the value of the
      expression to the left of the operator is either less than or
      equal to the value of the expression to the right.
   ++ Increment the preceding integer operator by 1.

5.  Common Rules

   Throughout the document we use terms defined in the [1], such as flow
   sender, flow receiver, QUERY, RESERVE or RESPONSE.

5.1  Common Procedures

   tx_RESERVE(Toff): Transmit RESERVE message with 'Teardown' bit off
   tx_RESERVE(Ton): Transmit RESERVE message with 'Teardown' bit on
   tx_RESPONSE(): Transmit RESPONSE message
   tx_QUERY(w/RII):
   tx_QUERY(<object>):  Transmit QUERY message with Request Identification
      Information (RII) object
   tx_QUERY(w/oRII): <object>
   tx_QUERY(w/o<object>): Transmit QUERY message without RII object <object>
   tx_NOTIFY(): Transmit NOTIFY message
   rx_RESPONSE(): Receive RESPONSE message
   rx_QUERY(): Receive QUERY message
   rx_RESERVE(): Receive RESERVE message
   TIMEOUT_State:
   rx_NOTIFY(): Transmit NOTIFY message
   TIMEOUT_StateLifetime: State lifetime timer expiration
   TIMEOUT_Refresh: Refresh interval timer expiration
   TIMEOUT_Refresh: Wait-Response interval timer expiration
   tg_QUERY: External trigger to send a QUERY message (typically
      triggered by the application).
   tg_RESERVE: External trigger to send a RESERVE message.
   tg_TEARDOWN: External trigger to clear previously established QoS
      state (typically triggered by the application).  It is translated
      to a tx_RESERVE(Ton) message.
   Set
   Install QoS state: establish Install the local QoS state.
   Refresh QoS state: refresh Refresh the local QoS state.
   Clear
   Delete QoS state: delete Delete the local QoS state.
   Send info to Application: report Report information to the application.
   RMF: Performs Resource Management Function and returns the following
      values{AVAIL, NO_AVAIL}.
   SetRII: Sets the RII object of the messages e.g.  the node requests
      explicit response to the message being sent.  Returns values
      {0,1}.
   CheckRII: Checks the RII object of received RESPONSE message if it is
      requested by current node or other upstream node.  Returns values
      {LOCAL, NO_LOCAL}.
   Result:
   ProcessQUERY: Processes the information of the RESPONSE messages a Query message and provides information.  It tells whether the reservation is
      successful or not (if it is a response to a reserve message), or
      the information carried in the response message (if it is a
      response to a query message), or an error has occurred.  Returns
      values {INFO, SUCCESSFUL, ERROR}. requested
      info

5.2  Common Variables

   RII: Request Identification Information (RII) object.  Logical
      variable representing if the RII is set or not.  Takes values
      {0,1}.

   SCOPING: Scoping flag of common message header.  Takes values
      {"Next_hop","Whole_path"}.
   RSN: Reservation Sequence Number object.  Takes values:
      - recRSN - RSN object of the received message
      - currRSN - Current stored RSN value for installed QoS state.
      (Assumed to be the one for the direction where the message comes
      from e.g.Upstream/Downstream)
   ACK: Acknowledgement flag of common message header.  Takes values
      {"On","Off"}.
   SummaryRefresh: Keeps information if Summary refresh method may be
      used for refreshing a installed QoS state.  Takes value
      {"On","Off"}.
   E_SPEC: Error_Spec object.  Takes values:
      - 0x02? - Success values
      - 0x04? - Transient Failure values
      - ERROR - Not specified in the QoS NSLP draft, but used
      here.(Section 10)
   QSPEC: QoS specification object.
   FlowID: Flow ID kept by the installed QoS state.
   Replace: Replace flag of common message header.  Takes values
      {"On","Off"}.
   SII: Source Identification Information entry.  Takes values:
      - CurrSII - SII entry stored for current installed QoS state.
      (Assumed to be the one for the direction where the message comes
      from e.g.Upstream/Downstream)
      - newSII - SII of the received message is different from the SII
      stored for the current installed QoS state.

5.3  Constants

5.4  Assumptions

   o  For simplification not all included objects in a message are
      showed.  Only those that are significant for the case are showed.
      State machines do not present handling of messages that are not
      significant for management of the states such as certain NOTIFY
      and QUERY messages.
   o  State machines represent handling of messages of the same Session
      ID and with no protocol errors.  Separate parallel instances of
      the state machines should handle messages for different Session
      IDs.
   o  Default message handling should be defined for messages with
      different Session IDs that have impact on current session state
      and error messages.  This is not included in the current version.
   o  ACK flag in the common header is set "On" by default.
   o  Direction of receiving and sending messages is not specified.  We
      assume it is implicit from the context.

6.  State machine for first QNI QoS NSLP node in the flow path

      -----------
      State: INIT
      -----------

      Condition                Action                    State
      ------------------------+-------------------------+------------
      UCT                     | initialize variables    |IDLE
      ------------------------+-------------------------+------------

   -----------
   State: IDLE
   -----------

   Condition                Action                    State      Note
   ------------------------+-------------------------+-----------+---
      (rx_QUERY) && (!RII) && |tx_NOTIFY(ERROR)
   rx_QUERY(RII)           |ProcessQUERY             |IDLE       |1)
         (RMF="NO_AVAIL")       |
                           |tx_RESPONSE(RII)         |           |2)
                              |                         |           |
      (rx_QUERY) && (RII)     |tx_RESPONSE(w/RII)       |IDLE           |
                           |                         |           |
   (tg_RESERVE) &&         |Send info to Application |IDLE       |
      (RMF="NO_AVAIL")     |                         |           |
                           |                         |           |
      (tg_QUERY)
   (tg_RESERVE) && (setRII)  |tx_QUERY(w/RII)          |WAITRESP1 (!RII)  |tx_RESERVE(w/oRII),      |QoS state  |
      && (!setRII) &&      | Install QoS state,      |Installed  |
      (RMF="AVAIL")        |
      (tg_RESERVE) && (RII) &&|tx_RESERVE(w/RII)        |WAITRESP2 Send info to Application|           |
         (RMF="AVAIL")
                           |                         |           |
   (tg_RESERVE) && (setRII)|Install QoS state,       |QoS state  |
      &&(RMF="AVAIL")      | tx_RESERVE(RII)         |Installed +|
                           |
      (rx_QUERY) && (!RII) && |tx_RESERVE(w/RII)                         |WAITRESP2  |2)
         (setRII) &&  |
                           |                         |
         (RMF="AVAIL")           |
   (rx_QUERY)&&(!RII)&&    |Tx_RESPONSE(RSN,         |IDLE       |1)
     (RMF="NO_AVAIL")      |  E_SPEC="ERROR")        |           |2)
                           |                         |           |
   (rx_QUERY) && (!RII) && |tx_RESERVE(w/oRII),      |ESTABLISHED|2)      |QoS state  |2)
      (!setRII) &&         | Set Install QoS state,          |      |Installed  |
      (RMF="AVAIL")        | Send info to Application|           |
                           |                         |           |
      (tg_RESERVE)
   (rx_QUERY) &&         |tx_RESERVE(w/oRII),      |ESTABLISHED|
         (!setRII) (!RII) &&         | Set |Install QoS state,       |QoS state  |2)
      (setRII) &&          |tx_RESERVE( RII)         |Installed +|
      (RMF="AVAIL")        |                         |WAITRESP2  |
                           |                         |           |
   (tg_QUERY) && (setRII)  |tx_QUERY(RII)            |WAITRESP1  |
                           |
         (RMF="AVAIL")                         | Send info to Application|           |
   ------------------------+-------------------------+-----------+---
   Note:
     1) tx_NOTIFY(ERROR) is transmitted when an ERROR event must
         be announced How to other downstream nodes which do not expect
         a RESPONSE message signal unsuccessful reservation for this action. E.g., there is no provided Receiver initiated
       reservation (No RII which will included; sent Response(RSN) should not be included in a RESPONSE message;
       forwarded further than the next peer). No Error_SPEC value
       specified for this case.
     2) Relevant for Receiver-initiated reservation.

   ----------------
   State: WAITRESP1
   ----------------

   Condition                Action                    State
   ------------------------+-------------------------+------------
      (TIMEOUT_Refresh)
   (TIMEOUT_WaitResp) &&    |tx_RESERVE(w/RII)   |tx_QUERY(RII)            |WAITRESP1
      (!MaxRetry)          |                         |
                           |                         |
      (TIMEOUT_Refresh)
   (TIMEOUT_WaitResp) &&   |Send info to Application |IDLE
      (MaxRetry)           |                         |
                           |                         |
   rx_RESPONSE             |Send info to Application |IDLE
   ------------------------+-------------------------+------------

      ------------------

   --------------------------------------
   State: ESTABLISHED
      ------------------ QoS state installed + WAITRESP2
   --------------------------------------

   Condition                Action                    State
   ------------------------+-------------------------+------------
      TIMEOUT_Refresh         |tx_RESERVE               |ESTABLISHED
   (TIMEOUT_WaitResp) &&   |tx_RESERVE(RII)          |QoS state
      (!MaxRetry)          |                         |installed +
                           |
      tg_TEARDOWN             |tx_RESERVE(Ton),                         |WAITRESP2
                           |                         |
                           |                         |
   (TIMEOUT_WaitResp) &&   |Delete QoS state         |IDLE
      (MaxRetry)           |Send info to Application |
                           |                         | Clear
   rx_RESPONSE(RII,        |Delete QoS state         |IDLE
       E_SPEC="0x04?")     |Send info to Application |
                           |                         |
                           |                         |
   rx_RESPONSE(RII,        |Send info to Application |QoS state
       E_SPEC="0x02?")     |SummaryRefresh="On"      |installed
   ------------------------+-------------------------+------------
      ----------------
   --------------------------
   State: WAITRESP2
      ---------------- QoS state installed
   --------------------------

   Condition                Action                    State
      ------------------------+-------------------------+------------
      (TIMEOUT_Refresh)      Note
   ------------------------+-------------------------+-----------+---
   TIMEOUT_Refresh         |If (SummaryRefresh="On") |QoS state  |
                           |  (Tx_RESERVE(RSN)) &&    |tx_RESERVE(w/RII)        |WAITRESP2
         (!MaxRetry)   |installed  |
                           |  (SummaryRefresh="Off") |           |
      (TIMEOUT_Refresh) &&    |Send info to Application |IDLE
         (MaxRetry)
                           |Else                     |           |
                           |  Tx_RESERVE(RSN,QSPEC); |
      (rx_RESPONSE) &&           |
                           |                         |           |
   rx_RESPONSE(RSN,        |SummaryRefresh="On"      |QoS state  |
       E_SPEC="0x02?")     |                         |installed  |
                           |                         |           |
   TIMEOUT_StateLifetime   |Delete QoS state         |IDLE       |1)
                           |Send info to Application |IDLE
         (Result="ERROR") |           |
                           |                         |
      (rx_RESPONSE) &&        |Set           |
   tg_TEARDOWN             |Delete QoS state,           |ESTABLISHED
         (Result="SUCCESS")&&        |IDLE       | Send
                           | tx_RESERVE(Ton)         |           |
                           |                         |           |
   rx_NOTIFY(RSN,          |Delete QoS state         |IDLE       |
       E_SPEC="0x04?")     |Send info to Application|
         (RMF="AVAIL") Application |           |
      ------------------------+-------------------------+------------
   ------------------------+-------------------------+-----------+---

   Note:
     1) If QoS state lifetime expires in QNI, should RESERVE(Ton)
        be sent downstream the path?

7.  State machine for intermediate QNE QoS NSLP nodes

      -----------
      State: INIT
      -----------

      Condition                Action                    State
      ------------------------+-------------------------+------------
      UCT                     | initialize variables    |IDLE
      ------------------------+-------------------------+------------

   -----------
   State: IDLE
   -----------

   Condition                Action                    State      Note
   ------------------------+-------------------------+-----------+---
      (rx_RESERVE)&& !((RII)&&|Set QoS state,           |ESTABLISHED|1a)
         (setRII))
   (rx_QUERY) &&         | tx_RESERVE(w/oRII) (!RII)    |tx_QUERY(w/oRII)         |IDLE       |2)
                           |                         |
         (RMF="AVAIL")           |
   (rx_QUERY(RII,          |ProcessQUERY,            |IDLE       |7)
       SCOPING="Next_hop") |Tx_RESPONSE(RII)         |           |
                           |                         |           |
      (rx_RESERVE)
   (rx_QUERY) && (RII) &&|Set QoS state,           |ESTABLISHED|1b)
         (RMF="AVAIL") &&     |tx_QUERY(w/RII)          |IDLE       |7)
                           | tx_RESPONSE(w/RII)                         |           |
         (SCOPING="Next_hop")
   (rx_RESERVE(RII)) &&    |Tx_RESPONSE(RII,         |IDLE       |3)
      (RMF="NO_AVAIL")     |    E_SPEC="0x04?")      |           |
                           |                         |           |
   (rx_RESERVE) && (!RII)&&|Set QoS state            |ESTABLISHED|1b)
         (RMF="AVAIL") && (!RII)&&|Tx_RESPONSE(RSN,         |IDLE       |3)
      (RMF="NO_AVAIL")     |    E_SPEC="0x04?")      |           |
         (SCOPING="Next_hop")
                           |                         |           |
   (rx_RESPONSE(RII)) &&   |Tx_RESPONSE(RII)         |IDLE       |
     (CheckRII="Not_LOCAL")|                         |           |
      (rx_QUERY) && (!RII)    |tx_QUERY(w/oRII)         |IDLE       |2)
                           |                         |           |
      (rx_QUERY)
   (rx_RESERVE)&& !(setRII)|Install QoS state,       |QoS State  |1a)
     &&           |tx_QUERY(w/RII)          |IDLE  (RMF="AVAIL")     |If(ACK="On")             |Installed  |
         (SCOPING="Next_hop")
                           |    Tx_RESPONSE(RSN,     |           |
                           |         E_SPEC="0x02?");|           |
                           |If(RII) Tx_RESPONSE(RII) |
      (rx_RESERVE)           |
                           |Else  Tx_RESPONSE(w/oRII)|           |
                           |                         |           |
   (rx_RESERVE(SCOPING=    |Install QoS state,       |QoS State  |1b)
      "Next_hop")) && (RII)&& |tx_RESPONSE(RII, ERROR)  |IDLE       |3)
         (RMF="NO_AVAIL")      |If(RII) Tx_RESPONSE(RII, |Installed  |
      (RMF="AVAIL")        |    E_SPEC="0x02?")      |           |
                           |Else    Tx_RESPONSE(RSN, |           |
      (rx_RESERVE) && (!RII)&&|tx_NOTIFY(ERROR)         |IDLE       |3)
         (RMF="NO_AVAIL")
                           |    E_SPEC="0x02?")      |           |
                           |                         |           |

   (rx_RESERVE) && ((RII)|||tx_RESERVE(w/RII)        |WAITRESP1 (setRII)|Install QoS state,       |QoS State  |4)
         (setRII))
       &&         |                         |           | (RMF="AVAIL")    |Tx_RESPONSE(RII),        |Installed +|
                           |If(ACK="On")             |WAITRESP1  |
                           |    Tx_RESPONSE(RSN,     |           |
                           |         E_SPEC="0x02?");|           |
      (rx_QUERY) && (RII)     |tx_QUERY(w/RII)          |WAITRESP2  |5)
                           |                         |           |
   (tg_QUERY) && (setRII)  |tx_QUERY(w/RII)  |tx_QUERY(RII)            |WAITRESP2  |5)
   ------------------------+-------------------------+-----------+---

      ------------------

   ----------------
   State: ESTABLISHED
      ------------------ QoS State Installed + WAITRESP1
   ----------------

   Condition                Action                    State
      ------------------------+-------------------------+------------
      rx_RESERVE(Ton)         |tx_RESERVE(Ton),         |IDLE      Note
   ------------------------+-------------------------+-----------+---
   (TIMEOUT_WaitResp) &&   |tx_RESERVE(RII)          |WAITRESP1  |  clear QoS state
      (!MaxRetry)          |                         |           |
      TIMEOUT_Refresh         |Refresh
                           |                         |           |
   (TIMEOUT_WaitResp) &&   |Delete QoS state;       |ESTABLISHED State,        |  if state changes,           |
      (MaxRetry) &&        |tx_NOTIFY(RSN,           |IDLE       |  tx_RESERVE(w/RII)
                           |    E_SPEC="0x04?")      |           |
      TIMEOUT_State           |Clear
                           |Send info to Application |           |
                           |                         |           |
   (rx_RESPONSE(RII,       |Delete QoS state State,        |IDLE
      ------------------------+-------------------------+------------       |4)
         E_SPEC="0x04?"))  |tx_NOTIFY(RSN,           |           |
    &&(CheckRII="LOCAL")   |    E_SPEC="0x04?")      |           |
                           |Send info to Application |           |
                           |                         |           |
   (rx_RESPONSE(RII,       |Send info to Application |QoS State  |
         E_SPEC="0x02?"))  |SummaryRefresh="On"      |Installed  |
    &&(CheckRII="LOCAL")   |                         |           |
   ------------------------+-------------------------+-----------+---

   ----------------
   State: WAITRESP1 WAITRESP2
   ----------------

   Condition                Action                    State
      ------------------------+-------------------------+------------
      (TIMEOUT_Refresh)      Note
   ------------------------+-------------------------+-----------+---
   (TIMEOUT_WaitResp) &&    |tx_RESERVE(w/RII)        |WAITRESP1   |tx_QUERY(RII)            |WAITRESP2  |
      (!MaxRetry)          | Send info to Application|                         |           |
      (TIMEOUT_Refresh)
                           |                         |           |
   (TIMEOUT_WaitResp) &&    |tx_NOTIFY(ERROR),   |Send info to Application |IDLE       |
      (MaxRetry) &&           | Send                         |           |
                           |                         |           |
   (rx_RESPONSE) &&        |Send info to Application|IDLE Application |IDLE       |
      (CheckRII="LOCAL")   |                         |           |
   ------------------------+-------------------------+-----------+---

   ------------------
   State: QoS State Installed
   ------------------

   Condition                Action                    State      Note
   ------------------------+-------------------------+-----------+---
   rx_RESERVE(Ton)         |tx_RESERVE(Ton),         |IDLE       |
      (TIMEOUT_Refresh) &&    |tx_RESPONSE(w/RII,Result=|
         (MaxRetry) &&
                           |Delete QoS state         |  "ERROR")               |IDLE
         (CheckRII="NO_LOCAL")|           |
                           |                         |
      (rx_RESPONSE) &&        |Set           |
   rx_RESERVE              |Refresh QoS state            |ESTABLISHED
         (CheckRII="LOCAL")&&        |QoS State  |6)
                           |If(ACK="On")             |Installed  |
                           |Tx_RESPONSE(RSN,         |
         (Result="SUCCESS")           |
                           |      E_SPEC="0x02?")    |           |
      (rx_RESPONSE) &&        |Set QoS state,           |ESTABLISHED
         (CheckRII="NO_LOCAL")|  tx_RESPONSE(RII)
                           |
         &&(Result="SUCCESS")                         |           |
   rx_RESPONSE(RSN,        |SummaryRefresh="On"      |QoS State  |6)
          E_SPEC="0x02?")  |                         |Installed  |
      (rx_RESPONSE) &&        |tx_NOTIFY(ERROR),        |IDLE
         (CheckRII="LOCAL")&&
                           | send info to Application|
         (Result="ERROR")                         |           |
   TIMEOUT_Refresh         |If (SummaryRefresh="On") |QoS State  |6)
                           |  (Tx_RESERVE(RSN))      |Installed  |
      (rx_RESPONSE) &&        |tx_RESPONSE(w/RII)       |IDLE
         (CheckRII="NO_LOCAL")|
                           |
         &&(Result="ERROR") &&(SummaryRefresh="Off")|           |
                           |Else                     |
      ------------------------+-------------------------+-------------
      ----------------
      State: WAITRESP2
      ----------------

      Condition                Action           |
                           |  Tx_RESERVE(RSN,QSPEC)  |           |
                           |                         |           |
   (rx_RESPONSE(RII,       |SummaryRefresh="On"      |QoS State
      ------------------------+-------------------------+------------
      (TIMEOUT_Refresh) &&    |tx_QUERY(w/RII)          |WAITRESP2
         (!MaxRetry)  |
          E_SPEC="0x02?")) |Tx_RESPONSE(RII,         |Installed  |
   &&(ChechRII="NOT_LOCAL")|      E_SPEC="0x02?")    |           |
      (TIMEOUT_Refresh) &&    |Send info to Application
                           |                         |           |
                           |                         |           |
   (TIMEOUT_StateLifetime) |Delete QoS state         |IDLE
         (MaxRetry) &&       |8)
                           |                         |
         (CheckRII="LOCAL")           |
   (rx_RESPONSE(RII,       |                         |           |
      (TIMEOUT_Refresh) &&    |tx_RESPONSE(Result=
          E_SPEC="0x04?")) |Delete QoS state         |IDLE
         (MaxRetry) &&       |  "ERROR")
   &&(ChechRII="NOT_LOCAL")|rx_RESPONSE(RII,         |
         (CheckRII="NO_LOCAL")|           |
                           |      E_SPEC="0x04?")    |
      (rx_RESPONSE) &&        |Send info to Application           |
                           |                         |           |
   rx_RESPONSE(RSN,        |Delete QoS state         |IDLE
         (CheckRII="LOCAL")       |
         E_SPEC="0x04?")   |rx_NOTIFY(RSN,           |           |
                           |
      (rx_RESPONSE) &&        |tx_RESPONSE(w/RII)      E_SPEC="0x04?")    |           |
                           |                         |           |
   rx_NOTIFY(RSN,          |Delete QoS state         |IDLE
         (CheckRII="NO_LOCAL")|       |
      ------------------------+-------------------------+-------------

      Note:
          E_SPEC="0x04?")  |rx_NOTIFY(RSN,           |           |
                           |      E_SPEC="0x04?")    |           |
                           |                         |           |
                           |                         |           |

   (Rx_RESERVE)&&(currSII) |Update QoS state         |QoS State  |9)
    &&(Replace="On")       |If (RII)                 |Installed  |
    &&(RMF="AVAIL")        |    Tx_RESERVE(RII,QSPEC)|           |
    &&((recRSN>=currRSN)   |else                     |           |
       ||(newFlowID))      |   Tx_RESERVE(RSN,QSPEC);|           |
                           |If (ACK="On")&&(!RII)    |           |
                           |    tx_RESPONSE(RSN,     |           |
                           |         E_SPEC="0x02?");|           |
                           |                         |           |
                           |                         |           |
   (Rx_RESERVE)&&(newSII)  |Update QoS state         |QoS State  |9)
    &&(RMF="AVAIL")        |If (RII)                 |Installed  |
    &&((recRSN>=currRSN)   |    Tx_RESERVE(RII,QSPEC)|           |
       ||(newFlowID))      |else                     |           |
                           |   Tx_RESERVE(RSN,QSPEC);|           |
                           |If (ACK="On")&&(!RII)    |           |
                           |    tx_RESPONSE(RSN,     |           |
                           |         E_SPEC="0x02?");|           |
                           |If (Replace="On")        |           |
                           |    tx_Reserve(Ton)      |           |
                           |    to currSII           |           |
   ------------------------+-------------------------+-----------+---

   NOTE:
      1) Successful reservation with response without Response request (1a) and with
        Scoping (1b); (1b).
      2) Processing of Query msg for Receiver initiated
        reservation; reservation
      3) Unsuccessful reservation for Receiver initiated
        reservation, with/without request for response
        from the flow
        sender side.  Tx_NOTIFY(ERROR) is sent to the upstream nodes to
        indicate failure of the reservation previous node in the case when no RESPONSE
        is required by them; path.
      4) Reservation requests with Unsuccessful reservation. RII set in requested at the local node.
        NOTIFY(RSN) is sent further to the upstream nodes
        or in this node; nodes.
      5) Processing of Query message received from a neighboring
        node or msg triggered by the application layer.
      6) QoS State refresh procedures
      7) Processing of Query msg received from an upstream node.
      8) We assume that handling of QoS state lifetime expiration
        event is based on the local policy of the node.
        NOTIFY/Reserve(Ton) messages might be sent to other peers.
        These issues are not described in the QoS NSLP draft.
      9) Update QoS state and Re-route functionality

8.  State machine for last QNR QoS NSLP node in the flow path

      -----------
      State: INIT
      -----------

      Condition                Action                    State
      ------------------------+-------------------------+------------
      UCT                     | initialize variables    |IDLE
      ------------------------+-------------------------+------------

   -----------
   State: IDLE
   -----------

   Condition                Action                    State      Note
   ------------------------+-------------------------+-----------+---
   rx_QUERY(RII)           |tx_RESPONSE(RII)         |IDLE       |
                           |                         |           |
   (rx_RESERVE)&&(!RII)    |Tx_RESPONSE(RSN,         |IDLE       |
    && (RMF="NO_A")        |      E_SPEC="0x04?")    |           |
                           |                         |           |
                           |                         |           |
   (rx_RESERVE(RII))       |Tx_RESPONSE(RII,         |IDLE       |
    && (RMF="NO_A")        |      E_SPEC="0x04?")    |           |
                           |                         |           |
   (tg_QUERY) &&           |tx_QUERY(w/RII)           |tx_QUERY(w/oRII)         |WAITRESV   |1)
      (!setRII)            |                         |           |
                           |                         |           |
      (rx_RESERVE) && (RII) &&|Set
                           |                         |           |
   (rx_RESERVE(RII))       |Install QoS state,           |ESTABLISHED|2a) state        |QoS state  |2)
    && (RMF="AVAIL")       |Tx_RESPONSE(RII,         |installed  |  tx_RESPONSE(w/RII)
                           |      E_SPEC="0x02?")    |           |
                           |                         |
      (rx_RESERVE) && (!RII)&&|Set           |
   (rx_RESERVE)&&(!RII)    |Install QoS state            |ESTABLISHED|2b)        |QoS state  |2)
    && (RMF="AVAIL")       |Tx_RESPONSE(RSN,         |installed  |
                                  E_SPEC="0x02?")    |           |
   ------------------------+-------------------------+-----------+---
   ---------------
   State: WAITRESV
   ---------------

   Condition                Action                    State      Note
   ------------------------+-------------------------+-----------+---
   TIMEOUT_WaitResp        |Tx_QUERY(w/oRII)         |WAITRESV   |
                           |                         |
      (tg_RESERVE) &&           |
   (TIMEOUT_WaitResp)      |Send info to Application Appl.       |IDLE       |3)
         (RMF="NO_AVAIL")       |
    && (MaxRetry)          |                         |           |
                           |                         |
      (rx_RESPONSE) && (RII)&&|tx_RESPONSE(RII, ERROR)           |
   (rx_RESERVE)&&(!RII)    |tx_RESPONSE(RSN,         |IDLE       |3)
     && (RMF="Not_AVAIL")  |
         (RMF="NO_AVAIL")      E_SPEC="0x04?")    |           |
                           |Send info to Appl.       |           |
                           |                         |
      (rx_QUERY) && (RII) &&  |tx_QUERY(w/RII)           |
   (rx_RESERVE(RII))       |tx_RESPONSE(RII,         |IDLE       |3)
     && (RMF="Not_AVAIL")  |
      ------------------------+-------------------------+-----------+---

      ------------------
      State: ESTABLISHED
      ------------------

      Condition                Action                    State
      ------------------------+-------------------------+------------
      rx_RESERVE              |Refresh QoS state        |ESTABLISHED      E_SPEC="0x04?")    |           |
      TIMEOUT_State           |Clear QoS state          |IDLE
      ------------------------+-------------------------+------------
      ---------------
      State: WAITRESV
      ---------------

      Condition                Action                    State      Note
      ------------------------+-------------------------+-----------+---
      (rx_RESPONSE) &&
                           |Send info to Application Appl.       |           |
                           |                         |           |
   rx_RESPONSE(E_SPEC=     |Send info to Appl.       |IDLE       |4)
                   "ERROR")|                         |
         (Result="ERROR")           |
                           |                         |           |
                           |                         |
      (rx_RESERVE) && (!RII)&&|Set           |
   (rx_RESERVE)&&(!RII)    |Install QoS state            |ESTABLISHED|2)        |QoS state  |
    && (RMF="AVAIL")       |Tx_RESPONSE(RSN,         |installed  |
                           |       E_SPEC="0x02?")   |           |
                           |                         |
      (rx_RESERVE) && (RII)&& |Set           |
   (rx_RESERVE(RII))       |Install QoS state,           |ESTABLISHED|2) State        |QoS state  |
    && (RMF="AVAIL")       |Tx_RESPONSE(RII)         |installed  | tx_RESPONSE(w/RII)
                           |                         |
      (rx_RESERVE) && (RII) &&|tx_NOTIFY(ERROR),        |IDLE       |4)
         (RMF="NO_AVAIL")           | Send info to Application|
   ------------------------+-------------------------+-----------+---
   ------------------
   State: QoS state installed
   ------------------

   Condition                Action                    State      Note
   ------------------------+-------------------------+-----------+---
   rx_RESERVE              |Refresh QoS state        |QoS state  |
                           |If(ACK="On")             |installed  |
                           |   Tx_RESPONSE(RSN,      |
      (rx_RESERVE) && (!RII)&&|tx_RESPONSE(RII,ERROR),           |
                           |          E_SPEC="0x02?")|           |
                           |                         |           |
   TIMEOUT_StateLifetime   |Delete QoS state         |IDLE       |4)
         (RMF="NO_AVAIL")       |5)
                           | Send info to Application|                         |
      ------------------------+-------------------------+-----------+---           |
   rx_RESERVE(Ton)         |Delete QoS state         |IDLE       |
                           |                         |           |
   ------------------------+-------------------------+------------

   Note:
    1) Initiation of receiver-side reservation; Receiver-side reservation
    2) Successful reservation with&without Reservation with& without response request from
        sender side; the
      QNI side
    3) In case of no Unsuccessful Reservation with & without response requested (RII request from
      the QNI side.
    4) How to signal unsuccessful reservation for Receiver initiated
      reservation(No RII is included, received Response(RSN) should
      not present in
        RESERVE message), NOTIFY(ERROR) message be forwarded.
    5) We assume that handling of QoS state lifetime expiration event
      is based on the local policy of the node. NOTIFY/Reserve(Ton)
      messages might be sent back to the
        upstream nodes other peers. These issues are not
      described in order to clear already established the QoS state;
            4) Unsuccessful reservation with&without response request
        from sender side; NSLP draft.

9.  Security Considerations

   This document does not raise new security considerations.  Any
   security concerns with the QoS NSLP are likely reflected in security
   related NSIS work already (such as [1] or [6]).

   For the time being, the state machines described in this document do
   not consider the security aspect of QoS NSLP protocol itself.  A
   future versions of this document will add security relevant states
   and state transitions.

10.  Open Issues

   This document tries to describe possible states and transitions for
   QoS NSLP according to its current specification [1], Section 5.  We
   found some issues during the development of the state machines.

   o  For
   example, for receiver-initiated reservation, it is unclear who triggers a teardown; bi-directional
      teardown.
   o  Bi-directional reservation is difficult to support as the state
      machine becomes quite complex (note at one particular point in
      time the protocol state engine can be only in one state).  Another example is, it is often ignored
   o  How to signal unsuccessful reservation for the
   functionality of abort operation after a defined MaxRetry number of
   retries.  Results of this type of transitions are dependent on the
   parameter Receiver initiated
      reservation (No RII (e.g., if it is locally set or not).

   There are further unclear issues with processing rules and message
   definition, e.g., soft state handling and how to process notification
   messages, which will be described in more detail in included; a future version
   of resulting Response(RSN) cannot be
      forwarded further than the next peer).  No Error_SPEC value
      specified for this document.

   To avoid confusions in case.
   o  If QoS state machines, instead of lifetime expires in QNI, should RESERVE(Ton) be sent
      downstream the path?
   o  The case of unsuccessful reservation at a QNE node and QNR,
   in this document no RII
      specified by upstream nodes.  According to the spec RESPONSE(RSN)
      should not be forwarded further than the next peer.  Currently we
      use NOTIFY(RSN) that is sent further to the notations upstream nodes.
   o  We assume that handling of "first QoS NSLP node in state lifetime expiration event is
      based on the
   flow path" (the closest one to local policy of the flow sender or node.  NOTIFY/Reserve(Ton)
      messages might be sent to other peers.  These issues are not
      described in the flow sender
   itself), "intermediate QoS NSLP nodes" draft.
   o  The draft states that RESERVE message MUST be sent only towards
      the QNR.  This is not the case when re-routing procedure is done
      and "last QoS NSLP RESERVE(Ton) message should be sent from merging QNE node for
      deleting the old branch.  We believe this is towards the QNI.
   o  Re-routing functionality described in this document is not
      complete and need further consideration.

11.  Change History

11.1  Changes in Version -01

   Version -01 covers more functionalities of the
   flow path" (the closest one to QoS NSLP.  This
   requires addition and changes of the flow receiver or notations.  The main details are
   as follows:

   1.  Notation of the flow receiver
   itself).

   Default rules nodes changed to QNI, QNE and common QNR.
   2.  Description of soft state transitions in case refresh functionality.
   3.  Support of reception ACK flag in the common header.
   4.  Include of
   certain messages as Notify, QoS NSLP objects, flags from the common header and Query(w/RII), will be described
       entries stored with the installed QoS state in a
   future version node: ACK,
       Replace, RSN, Error_SPEC, QSPEQ, FlowID, SII.
   5.  Initial description of this document.

11. Re-routing functionality (Section 10).
   6.  For support of all listed changes, some notations are changed.

12.  Acknowledgments

   The authors would like to thank Sven Van den Bosch for his feedback.

12.

13.  References

12.1

13.1  Normative References

   [1]  Bosch, S., Karagiannis, G. and A. McDonald, "NSLP for
        Quality-of-Service signaling", draft-ietf-nsis-qos-nslp-04 (work
        in progress), July
        Internet-Draft draft-ietf-nsis-qos-nslp-05, October 2004.

   [2]  Bradner, S., "Key words for use in RFCs to Indicate Requirement
        Levels", March 1997.

12.2

13.2  Informative References

   [3]  Vollbrecht, J., Eronen, P., Petroni, N. and Y. Ohba, "State
        Machines for Extensible Authentication Protocol (EAP) Peer and
        Authenticator", draft-ietf-eap-statemachine-05 (work in
        progress), September Internet-Draft draft-ietf-eap-statemachine-06,
        December 2004.

   [4]  Institute of Electrical and Electronics Engineers, "DRAFT
        Standard for Local and Metropolitan Area Networks: Port-Based
        Network Access Control (Revision)", IEEE 802-1X-REV/D9, January
        2004.

   [5]  Ohba, Y., "State Machines for Protocol for Carrying
        Authentication for Network Access  (PANA)",
        draft-ohba-pana-statemachine-00 (work in progress), July 2004.
        Internet-Draft draft-ohba-pana-statemachine-01, February 2005.

   [6]  Tschofenig, H. and D. Kroeselberg, "Security Threats for NSIS",
        draft-ietf-nsis-threats-06 (work in progress),
        Internet-Draft draft-ietf-nsis-threats-06, October 2004.

Authors' Addresses

   Xiaoming Fu
   University of Goettingen
   Telematics Group
   Lotzestr. 16-18
   Goettingen  37083
   Germany

   EMail:

   Email: fu@cs.uni-goettingen.de
   Hannes Tschofenig
   Siemens
   Otto-Hahn-Ring 6
   Munich, Bayern  81739
   Germany

   EMail:

   Email: Hannes.Tschofenig@siemens.com

   Tseno Tsenov
   Siemens
   Otto-Hahn-Ring 6
   Munich, Bayern  81739
   Germany

   EMail:

   Email: tseno.tsenov@mytum.de

Intellectual Property Statement

   The IETF takes no position regarding the validity or scope of any
   Intellectual Property Rights or other rights that might be claimed to
   pertain to the implementation or use of the technology described in
   this document or the extent to which any license under such rights
   might or might not be available; nor does it represent that it has
   made any independent effort to identify any such rights.  Information
   on the procedures with respect to rights in RFC documents can be
   found in BCP 78 and BCP 79.

   Copies of IPR disclosures made to the IETF Secretariat and any
   assurances of licenses to be made available, or the result of an
   attempt made to obtain a general license or permission for the use of
   such proprietary rights by implementers or users of this
   specification can be obtained from the IETF on-line IPR repository at
   http://www.ietf.org/ipr.

   The IETF invites any interested party to bring to its attention any
   copyrights, patents or patent applications, or other proprietary
   rights that may cover technology that may be required to implement
   this standard.  Please address the information to the IETF at
   ietf-ipr@ietf.org.

Disclaimer of Validity

   This document and the information contained herein are provided on an
   "AS IS" basis and THE CONTRIBUTOR, THE ORGANIZATION HE/SHE REPRESENTS
   OR IS SPONSORED BY (IF ANY), THE INTERNET SOCIETY AND THE INTERNET
   ENGINEERING TASK FORCE DISCLAIM ALL WARRANTIES, EXPRESS OR IMPLIED,
   INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE
   INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED
   WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

Copyright Statement

   Copyright (C) The Internet Society (2004). (2005).  This document is subject
   to the rights, licenses and restrictions contained in BCP 78, and
   except as set forth therein, the authors retain all their rights.

Acknowledgment

   Funding for the RFC Editor function is currently provided by the
   Internet Society.