AER Repair Service Use Cases
          ----------------------------
                   2000-05-02
                  Version: 1.1


Section A: Sender Protocol

  State Information:
    nextSeq     - The sequence number to use for the next original data packet
                  (a data packet with the retransmission flag set to false)
                  sent.
    nomineeAddr - The address of the nominee receiver. This address is
                  optionally specified by the congestion control algorithm and
                  is included in all data and SPM packets.
    retransBuf  - A buffer for storing all transmitted data packets by
                  sequence number for retransmission. Includes storage for a
                  NAK count for each data packet.

  A.1 Instantiation of the Protocol

  This use case begins when the sender protocol is instantiated (by upper
layers). The protocol data structures are initialized and endpoints (e.g.,
sockets) are opened for the transmission and reception of packets. The state
information is initialized as follows:

    nextSeq     = 1
    nomineeAddr = 0

The data packet buffer retransBuf is allocated and all NAK counts are
initialized to 0. A number of source path message (SPM) packets (e.g, 10) are
formed and sent to the multicast group address (obtained from the entity that
instantiates the protocol). The SPM packet format is described in Appendix A.
Each SPM packet contains a repair server IP address set to the local network
interface IP address, a nominee receiver address set to nomineeAddr, and the
current highest data packet sequence number of the transmitted data packets
set to (nextSeq - 1). A highest data packet sequence number of 0 indicates
that no data packets have been transmitted by the sender. The SPM timer is
started after sending out the SPM packets. The duration of the SPM timer is
set to some constant value (e.g., 4 seconds). This use case ends when the SPM
timer has been started.

  A.2 SPM Timer Service Routine

  This use case begins when the SPM timer expires. An SPM packet is
transmitted to the multicast group address. The SPM packet contains a repair
server IP address set to the local network interface IP address, a nominee
receiver address set to nomineeAddr, and the current highest data packet
sequence number of the transmitted data packets set to (nextSeq - 1). The SPM
timer is started with a duration of some constant value (e.g., 4 seconds).
This use case ends when the SPM timer has been started.

  A.3 Sending Data

  This use case begins when data (a variable length data block) is received
from the upper layer. This data is placed in one or more data packets. Each
data packet is assigned a sequence number of nextSeq, then nextSeq is
incremented for the next data packet. The nominee receiver address field is
set to nomineeAddr. The active network alert flag is set to false. The
retransmission flag set to false (making it an original data packet). The
first data packet always has the first segment flag set, and all data packets
except the last have the segmentation flag set. All data packets are then
buffered in the retransmission buffer retransBuf. The current sender NAK count
(maximum value of NAK count seen in NAK packets so far) for each data packet
is initialized to 0 in retransBuf. These data packets are then sent out to the
multicast group as the Testing if an Original Data Packet Can Be Sent Use Case
in the rate control algorithm allows. The timestamp of each data packet is
filled in with the current time in milliseconds just before the data packet is
sent. The data packet format is described in Appendix A. This use case ends
when the data packet transmission(s) are completed.

  A.4 Processing a Received NAK Packet

  This use case begins when a NAK packet is received from the lower layer. The
NAK packet contains the sequence number of the data packet whose
retransmission has been requested. It also contains a NAK count for that data
packet. The NAK packet format is shown in Appendix A. If the NAK packet NAK
count is greater than the current sender NAK count of that data packet in the
retransmission buffer retransBuf, then the current sender NAK count for the
data packet in retransBuf is set to the NAK packet NAK count, the requested
data packet is fetched from the retransmission buffer retransBuf, the data
packet retransmission flag is set to true (making the data packet a repair
data packet) and the data packet is sent out to the multicast group address.
Otherwise, the NAK packet is ignored and no retransmission is sent out. This
use case ends when the repair data packet is sent or the NAK packet is
ignored.

  A.5 Updating the Nominee Receiver Address

  This use case begins when the nominee receiver address nomineeAddr needs to
be updated. The new nominee receiver address is placed in nomineeAddr. This
use case ends when nomineeAddr has been updated.

  A.6 Processing a Stop

  This use case begins when a stop protocol request is received from the upper
layer. All of the resources allocated to the protocol layer are freed. This
use case ends when the resources are freed.



Section B: Receiver Protocol

  State Information:
    fastNAKFlag     - If true, the repair procedure should not be delayed by a
                      NAK suppression interval. If false, NAK suppression is
                      used.
    repairServer    - The address of the repair server for the receiver.
    readNextSeq     - The sequence number of the next data packet to deliver
                      to the application.
    smoothedRTT     - The smoothed receiver to sender RTT estimate in
                      milliseconds.
    rttVariance     - The mean deviation of the receiver to sender RTT
                      estimate in milliseconds.
    retransTO       - The current NAK retransmission timer duration in
                      milliseconds.
    suppressTO      - The current NAK suppression timer duration in
                      milliseconds before being adjusted by a uniform random
                      variate.
    dataBuf         - A buffer for storing all received data packets by
                      sequence number before delivering the data to the
                      application. Includes storage for a NAK count for each
                      data packet.

  B.1 Instantiation of the Protocol

  This use case begins when the receiver protocol is instantiated (by upper
layers). The protocol data structures are initialized and endpoints (e.g.,
sockets) are opened for the transmission and reception of packets. This is
followed by a multicast join operation for joining the multicast group on
which data and NAK packets are expected. The multicast address and port
numbers are received from the entity that instantiates the protocol. The
constants used by AER are as follows:

    MAX_NAK_RETRIES         = 48
    FAST_NAK_FIRST_SUPPRESS = 10

The state information is initialized as follows:

    fastNAKFlag  = false
    repairServer = 0
    readNextSeq  = initial data packet sequence number
    smoothedRTT  = 0
    rttVariance  = 3000
    retransTO    = (smoothedRTT + (2 * rttVariance))
    suppressTO   = 100

The data packet buffer dataBuf is allocated and all NAK counts are initialized
to 0. This use case ends when the protocol is taken to a wait state where it
waits to receive data, NAK or SPM packets and also waits for expiration of
timers as described below.

  B.2 Processing a Received SPM Packet

  This use case begins when an SPM packet is received. The following
processing is performed (rs and maxSeq are the SPM packet repair server
address and highest data packet sequence number):

    repairServer = rs
    if (maxSeq != 0)
    {
      Call Use Case B.4 passing (maxSeq + 1)
    }

This use case ends when either repairServer has been updated or Use Case B.4
returns.

  B.3 Processing a Received Data Packet

  This use case begins when a data packet is received. The following
processing is performed (seq is the received data packet sequence number):

    Cancel any NAK retransmission timer for data packet seq
    Cancel any NAK suppression timer for data packet seq
    if ((data packet seq is not currently buffered in dataBuf) AND
        (seq >= readNextSeq))
    {
      Buffer received data packet in dataBuf
      NAK count for data packet seq in dataBuf = 0
      Call Use Case B.4 passing seq
      Call Use Case B.5
    }
    else
    {
      Discard received data packet
    }

This use case ends when either Use Case B.5 returns or the received data
packet is discarded.

  B.4 Detecting Gaps in Data Packet Sequence Numbers

  This use case begins when gaps in received data packet sequence numbers must
be detected and handled. The following processing is performed (seq is the
sequence number passed to this use case):

    nakSeq = (seq - 1)
    while (nakSeq >= readNextSeq)
    {
      if ((data packet nakSeq is currently buffered in dataBuf) OR
          (NAK count for data packet nakSeq in dataBuf > 0))
      {
        break while loop
      }
      nakSeq = (nakSeq - 1)
    }
    nakSeq++
    while (nakSeq < seq)
    {
      NAK count for data packet nakSeq in dataBuf = 1
      Call Use Case B.6 passing nakSeq
      nakSeq = (nakSeq + 1)
    }

This use case ends when the above processing is complete.

  B.5 Processing a Buffered Data Packet

  This use case begins when a received data packet is buffered. The following
processing is performed (seq is the data packet sequence number):

    if (application is using an asynchronous receive mode)
    {
      if (data is ready to deliver to the application)
      {
        Deliver data to the application
        Remove data packets of delivered data from dataBuf
        Update readNextSeq
      }
    }

Note that in delivering any data packets to application, a "Reassembly"
process is performed using readNextSeq along with the "First Segment" and
"Segmentation" flags in the data packet headers. This use case ends when
either readNextSeq is updated or no processing is performed.

  B.6 Start Suppression Interval

  This use case begins when a NAK suppression interval is to be started for
the missing data packet sequence number seq. The following processing is
performed:

    if (fastNAKFlag == false)
    {
      Start a NAK suppression timer for data packet seq with a duration of
        a random variate, uniformly distributed between 0 and 1.0, times
        suppressTO
    }
    else
    {
      Start a NAK suppression timer for data packet seq with a duration of
        a random variate, uniformly distributed between 0 and 1.0, times
        FAST_NAK_FIRST_SUPPRESS
    }

This use case ends when the NAK suppression timer is started.

  B.7 Processing a Received NAK Packet

  This use case begins when a NAK packet is received. The following processing
is performed (seq and nakCount are the NAK packet sequence number and NAK
count):

    if ((data packet seq is currently buffered in dataBuf) OR
        (seq < readNextSeq))
    {
      End Use Case
    }
    if (nakCount >= NAK count for data packet seq in dataBuf)
    {
      NAK count for data packet seq in dataBuf = nakCount
      Cancel any NAK retransmission timer for data packet seq
      Cancel any NAK suppression timer for data packet seq
      if (nakCount == 1)
      {
        Start a NAK retransmission timer for data packet seq with a duration
          of (retransTO + FAST_NAK_FIRST_SUPPRESS)
      }
      else
      {
        Start a NAK retransmission timer for data packet seq with a duration
          of retransTO
      }
    }

This use case ends when either the NAK packet is ignored or the NAK
retransmission timer is started.

  B.8 NAK Suppression Timer Service Routine

  This use case begins when the NAK suppression timer for a missing data
packet expires. The following processing is performed (seq is the sequence
number of the missing data packet):

    if ((data packet seq is currently buffered in dataBuf) OR
        (seq < readNextSeq))
    {
      End Use Case
    }
    if (NAK count for data packet seq in dataBuf > MAX_NAK_RETRIES)
    {
      Error, connection is broken, cannot continue
    }
    Unicast a NAK packet for data packet seq with the NAK count set to the
      receiver's NAK count (for data packet seq, from dataBuf) and the fast
      NAK flag set to fastNAKFlag to repairServer
    Start a NAK retransmission timer for data packet seq with a duration of
      retransTO

This use case ends when either the timer is ignored, an unrecoverable error
occurs or a NAK retransmission timer for the data packet is started.

  B.9 NAK Retransmission Timer Service Routine

  This use case begins when the NAK retransmission timer for a missing data
packet expires. The following processing is performed (seq is the sequence
number of the missing data packet):

    if ((data packet seq is currently buffered in dataBuf) OR
        (seq < readNextSeq))
    {
      End Use Case
    }
    NAK count for data packet seq in dataBuf is incremented by 1
    Call Use Case B.6

This use case ends when either the timer is ignored or Use Case B.6 returns.

  B.10 Enable Fast NAK

  This use case begins when the fast NAK option is to be enabled. fastNAKFlag
is set to true. This use case ends when fastNAKFlag is set to true.

  B.11 Disable Fast NAK

  This use case begins when the fast NAK option is to be disabled. fastNAKFlag
is set to false. This use case ends when fastNAKFlag is set to false.

  B.12 Updating Round Trip Time Estimates

  This use case begins when a new RTT estimate is available. The following
processing is performed (senderRTT is a new sender RTT estimate in
milliseconds and maxUpRTT is a new maximum peer group RTT estimate in
milliseconds. The maximum peer group RTT is the maximum RTT between this
receiver's repair server and all receivers and repair servers serviced by
it.):

    if (senderRTT > 0)
    {
      if (smoothedRTT == 0)
      {
        smoothedRTT = senderRTT
        rttVariance = (senderRTT / 4)
      }
      else
      {
        error       = (senderRTT - smoothedRTT)
        smoothedRTT = (smoothedRTT + (error / 8))
        rttVariance = (rttVariance + ((ABS(error) - rttVariance) / 4))
      }
      retransTO  = (smoothedRTT + (4 * rttVariance))
    }
    if (maxUpRTT > 0)
    {
      suppressTO = (1.5 * maxUpRTT)
    }

This use case ends when suppressTO has been updated.

  B.13 Processing a Stop

  This use case begins when a stop protocol request is received from the upper
layer. All of the resources allocated to the protocol layer are freed. This 
use case ends when the resources are freed.


Section C: Repair Server Protocol

  State Information:
    fastNAKFlag     - If true, the repair procedure should not be delayed by a
                      NAK suppression interval. If false, NAK suppression is
                      used.
    repairServer    - The address of the repair server for this repair server.
    maxSeqRcvd      - The maximum data packet sequence number received.
    smoothedRTT     - The smoothed repair server to sender RTT estimate in
                      milliseconds.
    rttVariance     - The mean deviation of the repair server to sender RTT
                      estimate in milliseconds.
    retransTO       - The current NAK retransmission timer duration in
                      milliseconds.
    suppressTO      - The current NAK suppression timer duration in
                      milliseconds before being adjusted by a uniform random
                      variate.
    retransBuf      - A limited size buffer for temporary storage of
                      transmitted data packets by sequence number for
                      retransmission.
    nakState        - A collection of NAK state data stored by data packet
                      sequence number. When created for a data packet sequence
                      number, the NAK state consists of a NAK pending flag and
                      a NAK count.

  C.1 Instantiation of the Protocol

  This use case begins when the active node receives the first SPM packet. The
active node searches for the repair server object for the SPM packet IP source
address and multicast group and, not finding any, creates a new repair server
object for the stream. The IP source address and multicast group are extracted
from the SPM packet and stored by the repair server. The repair server object
is added to the active node cache using the SPM packet IP source address
(which is the sender's IP address) and multicast group. The constants used by
AER are as follows:

    FAST_NAK_FIRST_SUPPRESS = 10

The state information is initialized as follows:

    fastNAKFlag  = false
    repairServer = 0
    maxSeqRcvd   = 0
    smoothedRTT  = 0
    rttVariance  = 3000
    retransTO    = (smoothedRTT + (2 * rttVariance))
    suppressTO   = 100

The data packet buffer retransBuf is allocated and initialized as empty. Use
Case C.2 is then called for further SPM packet processing. This use case ends
when Use Case C.2 returns.

  C.2 Processing a Received SPM Packet in the Wait State

  This use case begins when an SPM packet is received in the wait state. The
SPM packet is processed in this use case and is not forwarded down the
multicast tree until this use case subcasts it. The following processing is
performed (rs and maxSeq are the SPM packet repair server address and highest
data packet sequence number):

    Cancel the SPM wait timer
    Start the SPM wait timer with a fixed duration (e.g., 20 seconds)
    repairServer = rs
    if (maxSeq != 0)
    {
      Call Use Case C.4 passing (maxSeq + 1)
    }
    Subcast SPM packet(s) downstream with the SPM packet(s) repair server
      address field set to the local outgoing interface IP address(s)

Note that when subcasting the SPM packet downstream, it is sent once out
each outgoing interface for the multicast tree, and each of these SPM packets
has the outgoing interface IP address in the repair server field. This use
case ends when the the SPM packet is subcast downstream.

  C.3 Processing a Received Data Packet

  This use case begins when a data packet with sequence number seq is received
by the repair server. Note that original data packets (data packets with the
retransmission flag set to false) are first forwarded out all outgoing
interfaces for the multicast tree before this processing takes place. Repair
data packets (data packets with the retransmission flag set to true) are
processed first and forwarded out all outgoing interfaces for the multicast
tree only when these use cases call for subcasting the repair data packet
downstream. The following processing is performed:

    if (data packet seq is not currently buffered in retransBuf)
    {
      if (nakState exists for data packet seq)
      {
        Cancel any current NAK suppression timer for data packet seq
        Cancel any current NAK retransmission timer for data packet seq
        if ((retransmission flag in data packet seq == true) AND
            (NAK pending flag in nakState for data packet seq == true))
        {
          Subcast data packet seq downstream
        }
        NAK pending flag in nakState for data packet seq = false
      }
      if (old data packet oldSeq must be removed from retransBuf to make room
          for data packet seq)
      {
        Remove old data packet oldSeq from retransBuf
        if (nakState exists for data packet oldSeq)
        {
          Delete nakState for data packet oldSeq
        }
        Free old data packet oldSeq
      }
      Buffer data packet seq in retransBuf
      Call Use Case C.4 passing seq
      if (seq > maxSeqRcvd)
      {
        maxSeqRcvd = seq
      }
    }
    else
    {
      Discard received data packet
    }

Note that the repair server data packet buffer retransBuf uses a certain
buffer management policy (e.g., limited size FIFO) and an old data packet may
need to be removed from retransBuf to make room for the newly received data
packet. If an old data packet must be removed, then any nakState for that data
packet must be destroyed. This use case ends when either Use Case C.4 returns,
maxSeqRcvd is updated or the data packet is discarded.

  C.4 Detecting Gaps in Data Packet Sequence Numbers

  This use case begins when lost data packets must be detected and handled.
The following processing is performed (seq is the sequence number passed to
this use case):

    if (maxSeqRcvd == 0)
    {
      End Use Case
    }
    if (seq > (maxSeqRcvd + 1))
    {
      nakSeq = (seq - 1)
      while (nakSeq > maxSeqRcvd)
      {
        if (nakState exists for data packet nakSeq)
        {
          break
        }
        nakSeq--
      }
      nakSeq++
      while (nakSeq < seq)
      {
        Call Use Case C.5 passing nakSeq
        nakSeq++
      }
    }

This use case ends when either Use Case C.5 returns for the last missing data
packet or no action is taken.

  C.5 Starting Data Packet Recovery

  This use case begins when data packet seq is detected as missing and the
data packet recovery process must be started. The following processing is
performed (seq is the sequence number passed to this use case):

    Create nakState for data packet seq
    NAK count in nakState for data packet seq        = 1
    NAK pending flag in nakState for data packet seq = true
    Subcast a NAK packet for data packet seq with the NAK count set to the
      nakState NAK count and the fast NAK flag set to false to the multicast
      group
    if (fastNAKFlag == false)
    {
      Start a NAK suppression timer for data packet seq with a duration of
        a random variate, uniformly distributed between 0 and 1.0, times
        suppressTO, plus FAST_NAK_FIRST_SUPPRESS
    }
    else
    {
      Start a NAK suppression timer for data packet seq with a duration of
        FAST_NAK_FIRST_SUPPRESS
    }

This use case ends when either a NAK suppression or NAK retransmission timer
for data packet seq is started.

  C.6 Processing a Received Multicast NAK Packet from Upstream

  This use case begins when a multicast NAK packet is received from upstream.
The following processing is performed (seq and nakCount are the NAK packet
sequence number and NAK count):

    if (data packet seq is not currently buffered in retransBuf)
    {
      if (nakState exists for data packet seq)
      {
        if (nakCount > NAK count in nakState for data packet seq)
        {
          NAK count in nakState for data packet seq = nakCount
          Subcast a NAK packet for data packet seq with the NAK count set to
            the nakState NAK count and the fast NAK flag set to false to the
            multicast group
        }
        Cancel any current NAK suppression timer for data packet seq
        Cancel any current NAK retransmission timer for data packet seq
      }
      else
      {
        Create nakState for data packet seq
        NAK count in nakState for data packet seq        = nakCount
        NAK pending flag in nakState for data packet seq = true
        Subcast a NAK packet for data packet seq with the NAK count set to the
          nakState NAK count and the fast NAK flag set to false to the
          multicast group
      }
      Start a NAK retransmission timer for data packet seq with a duration
        of retransTO
    }

This use case ends when either the NAK retransmission timer is started or the
NAK packet is ignored.

  C.7 Processing a Received Unicast NAK Packet from Downstream

  This use case begins when a unicast NAK packet is received from downstream.
The following processing is performed (seq is the NAK packet sequence number):

    if (data packet seq is not currently buffered in retransBuf)
    {
      if (nakState exists for data packet seq)
      {
        Call Use Case C.8
      }
      else
      {
        Call Use Case C.9
      }
    }
    else
    {
      Call Use Case C.10
    }

This use case ends when either Use Case C.8, C.9 or C.10 returns.

  C.8 Processing a NAK Packet with NAK State

  This use case begins when a unicast NAK packet is received from downstream
for a data packet that is not currently in retransBuf and nakState exists for
the data packet. The following processing is performed (seq, nakCount and
fastNAK are the NAK packet sequence number, NAK count and fast NAK flag):

    if (nakCount > NAK count in nakState for data packet seq)
    {
      NAK count in nakState for data packet seq        = nakCount
      NAK pending flag in nakState for data packet seq = true
      Subcast a NAK packet for data packet seq with the NAK count set to the
        nakState NAK count and the fast NAK flag set to false to the multicast
        group
      if (fastNAK == true)
      {
        Cancel any current NAK suppression timer for data packet seq
        Cancel any current NAK retransmission timer for data packet seq
        Unicast a NAK packet for data packet seq with the NAK count set to the
          nakState NAK count and the fast NAK flag set to fastNAKFlag to
          repairServer
        Start a NAK retransmission timer for data packet seq with a duration
          of retransTO
      }
    }
    else
    {
      if ((nakCount == NAK count in nakState for data packet seq) AND
          (fastNAK == true) AND (fastNAKFlag == false))
      {
        NAK pending flag in nakState for data packet seq = true
        Cancel any current NAK suppression timer for data packet seq
        Cancel any current NAK retransmission timer for data packet seq
        Unicast a NAK packet for data packet seq with the NAK count set to the
          nakState NAK count and the fast NAK flag set to fastNAKFlag to
          repairServer
        Start a NAK retransmission timer for data packet seq with a duration
          of retransTO
      }
    }

This use case ends when either the NAK packet is subcast downstream, the NAK
retransmission timer is started or no processing is performed.

  C.9 Processing a NAK Packet without NAK State

  This use case begins when a unicast NAK packet is received from downstream
for a data packet that is not currently in retransBuf and nakState does not
exist for the data packet. The following processing is performed (seq,
nakCount and fastNAK are the NAK packet sequence number, NAK count and fast
NAK flag):

    Create nakState for data packet seq
    NAK count in nakState for data packet seq        = nakCount
    NAK pending flag in nakState for data packet seq = true
    Subcast a NAK packet for data packet seq with the NAK count set to the
      nakState NAK count and the fast NAK flag set to false to the
      multicast group
    if (fastNAK == true)
    {
      Unicast a NAK packet for data packet seq with the NAK count set to the
        nakState NAK count and the fast NAK flag set to fastNAKFlag to
        repairServer
      Start a NAK retransmission timer for data packet seq with a duration of
        retransTO
    }
    else
    {
      Start a NAK suppression timer for data packet seq with a duration of
        a random variate, uniformly distributed between 0 and 1.0, times
        suppressTO
    }

This use case ends when either a NAK suppression or NAK retransmission timer
for data packet seq is started.

  C.10 Generating a Repair Data Packet

  This use case begins when a unicast NAK packet is received from downstream
for a data packet that is currently in retransBuf. The following processing is
performed (seq and nakCount are the NAK packet sequence number and NAK count):

    if (nakState exists for data packet seq)
    {
      if (nakCount <= NAK count in nakState for data packet seq)
      {
        End Use Case
      }
    }
    else
    {
      Create nakState for data packet seq
    }
    NAK count in nakState for data packet seq        = nakCount
    NAK pending flag in nakState for data packet seq = false
    Get data packet seq from retransBuf
    Retransmission flag in data packet seq = true
    Subcast data packet seq to the multicast group

This use case ends when either data packet seq is subcast to the multicast
group or no processing is performed.

  C.11 NAK Suppression Timer Service Routine

  This use case begins when the NAK suppression timer for data packet seq
expires. The following processing is performed:

    if ((data packet seq is currently buffered in retransBuf) OR
        (No nakState exists for data packet seq) OR
        (NAK pending flag in nakState for data packet seq == false))
    {
      End Use Case
    }
    Unicast a NAK packet for data packet seq with the NAK count set to the
      nakState NAK count and the fast NAK flag set to fastNAKFlag to
      repairServer
    Start a NAK retransmission timer for data packet seq with a duration of
      retransTO

This use case ends when the NAK retransmission timer is started.

  C.12 NAK Retransmission Timer Service Routine

  This use case begins when the NAK retransmission timer for data packet seq
expires. The following processing is performed:

    if ((data packet seq is currently buffered in retransBuf) OR
        (No nakState exists for data packet seq) OR
        (NAK pending flag in nakState for data packet seq == false))
    {
      End Use Case
    }
    NAK count in nakState for data packet seq is incremented by 1
    Subcast a NAK packet for data packet seq with the NAK count set to the
      nakState NAK count and the fast NAK flag set to false to the multicast
      group
    Start a NAK suppression timer for data packet seq with a duration of
      a random variate, uniformly distributed between 0 and 1.0, times
      suppressTO

This use case ends when the NAK suppression timer is started.

  C.13 Enable Fast NAK

  This use case begins when called by the rate control nomination algorithm.
The following processing is performed:

    fastNAKFlag = true

This use case ends when fastNAKFlag has been updated.

  C.14 Disable Fast NAK

  This use case begins when called by the rate control nomination algorithm.
The following processing is performed:

    fastNAKFlag = false

This use case ends when fastNAKFlag has been updated.

  C.15 Updating Round Trip Time Estimates

  This use case begins when a new RTT estimate is available. The following
processing is performed (senderRTT is a new sender RTT estimate in
milliseconds and maxUpRTT is a new maximum peer group RTT estimate in
milliseconds. The maximum peer group RTT is the maximum RTT between this
receiver's repair server and all receivers and repair servers serviced by the
it.):

    if (senderRTT > 0)
    {
      if (smoothedRTT == 0)
      {
        smoothedRTT = senderRTT
        rttVariance = (senderRTT / 4)
      }
      else
      {
        error       = (senderRTT - smoothedRTT)
        smoothedRTT = (smoothedRTT + (error / 8))
        rttVariance = (rttVariance + ((ABS(error) - rttVariance) / 4))
      }
      retransTO  = (smoothedRTT + (4 * rttVariance))
    }
    if (maxUpRTT > 0)
    {
      suppressTO = (1.5 * maxUpRTT)
    }

This use case ends when suppressTO has been updated.

  C.16 SPM Wait Timer Service Routine

  This use case begins when the SPM wait timer expires. This event indicates
that either no packets are being sent by the sender anymore on this multicast
group or the routes have changed. All timers for the repair server are
canceled, all buffer resources for the repair server are freed and the repair
server object is removed from the active node cache. This use case ends when
the protocol state is destroyed.



Appendix A: Packet Formats

 Data Packet:
   Data packets are multicast packets that are forwarded downstream upon
   arrival at an Active Node. Only after the data packet is forwarded is a
   copy of the data packet passed to the Repair Server for processing. Data
   packets contain:

       Sequence Number
       Timestamp
       Nominee Receiver Address
       Active Network Alert Flag = false
       Retransmission Flag       = false
       First Segment Flag
       Segmentation Flag
       Payload

 Repair Data Packet:
   Repair data packets are multicast packets that are passed to the Repair
   Server upon arrival at an Active Node. The Repair Server processes the
   repair data packet and may decide to forward the repair data packet
   downstream or not. Repair data packets contain:

       Sequence Number
       Timestamp
       Nominee Receiver Address
       Active Network Alert Flag = true
       Retransmission Flag       = true
       First Segment Flag
       Segmentation Flag
       Payload

 Source Path Message (SPM) Packet:
   SPM packets are multicast packets that are passed to the Repair Server upon
   arrival at an Active Node. The Repair Server processes the SPM packet and
   may decide to forward the SPM downstream or not. SPM packets contain:

       Repair Server Address
       Nominee Receiver Address
       Maximum Transmitted Data Packet Sequence Number

 Unicast Negative Acknowledgement (NAK) Packet:
   Unicast NAK packets are unicast packets that are passed to the Repair
   Server upon arrival at an Active Node. Unicast NAK packets contain:

       Data Packet Sequence Number
       NAK Count
       Fast NAK Flag
       Multicast Flag = false

 Multicast Negative Acknowledgement (NAK) Packet:
   Multicast NAK packets are multicast packets that are passed to the Repair
   Server upon arrival at an Active Node. The Repair Server processes the
   multicast NAK packet and may decide to forward the multicast NAK packet
   downstream or not. Multicast NAK packets contain:

       Data Packet Sequence Number
       NAK Count
       Fast NAK Flag
       Multicast Flag = true