Tech-invite3GPPspaceIETF RFCsSIP
93929190898887868584838281807978777675747372717069686766656463626160595857565554535251504948474645444342414039383736353433323130292827262524232221201918171615141312111009080706050403020100
in Index   Prev   Next

RFC 5245

Interactive Connectivity Establishment (ICE): A Protocol for Network Address Translator (NAT) Traversal for Offer/Answer Protocols

Pages: 117
Obsoletes:  40914092
Obsoleted by:  8445
Updated by:  6336
Part 2 of 5 – Pages 19 to 51
First   Prev   Next

ToP   noToC   RFC5245 - Page 19   prevText

4. Sending the Initial Offer

In order to send the initial offer in an offer/answer exchange, an agent must (1) gather candidates, (2) prioritize them, (3) eliminate redundant candidates, (4) choose default candidates, and then (5) formulate and send the SDP offer. All but the last of these five steps differ for full and lite implementations.

4.1. Full Implementation Requirements

4.1.1. Gathering Candidates

An agent gathers candidates when it believes that communication is imminent. An offerer can do this based on a user interface cue, or based on an explicit request to initiate a session. Every candidate
ToP   noToC   RFC5245 - Page 20
   is a transport address.  It also has a type and a base.  Four types
   are defined and gathered by this specification -- host candidates,
   server reflexive candidates, peer reflexive candidates, and relayed
   candidates.  The server reflexive candidates are gathered using STUN
   or TURN, and relayed candidates are obtained through TURN.  Peer
   reflexive candidates are obtained in later phases of ICE, as a
   consequence of connectivity checks.  The base of a candidate is the
   candidate that an agent must send from when using that candidate.

4.1.1.1. Host Candidates
The first step is to gather host candidates. Host candidates are obtained by binding to ports (typically ephemeral) on a IP address attached to an interface (physical or virtual, including VPN interfaces) on the host. For each UDP media stream the agent wishes to use, the agent SHOULD obtain a candidate for each component of the media stream on each IP address that the host has. It obtains each candidate by binding to a UDP port on the specific IP address. A host candidate (and indeed every candidate) is always associated with a specific component for which it is a candidate. Each component has an ID assigned to it, called the component ID. For RTP-based media streams, the RTP itself has a component ID of 1, and RTCP a component ID of 2. If an agent is using RTCP, it MUST obtain a candidate for it. If an agent is using both RTP and RTCP, it would end up with 2*K host candidates if an agent has K IP addresses. The base for each host candidate is set to the candidate itself.
4.1.1.2. Server Reflexive and Relayed Candidates
Agents SHOULD obtain relayed candidates and SHOULD obtain server reflexive candidates. These requirements are at SHOULD strength to allow for provider variation. Use of STUN and TURN servers may be unnecessary in closed networks where agents are never connected to the public Internet or to endpoints outside of the closed network. In such cases, a full implementation would be used for agents that are dual stack or multihomed, to select a host candidate. Use of TURN servers is expensive, and when ICE is being used, they will only be utilized when both endpoints are behind NATs that perform address and port dependent mapping. Consequently, some deployments might consider this use case to be marginal, and elect not to use TURN servers. If an agent does not gather server reflexive or relayed candidates, it is RECOMMENDED that the functionality be implemented and just disabled through configuration, so that it can be re-enabled through configuration if conditions change in the future.
ToP   noToC   RFC5245 - Page 21
   If an agent is gathering both relayed and server reflexive
   candidates, it uses a TURN server.  If it is gathering just server
   reflexive candidates, it uses a STUN server.

   The agent next pairs each host candidate with the STUN or TURN server
   with which it is configured or has discovered by some means.  If a
   STUN or TURN server is configured, it is RECOMMENDED that a domain
   name be configured, and the DNS procedures in [RFC5389] (using SRV
   records with the "stun" service) be used to discover the STUN server,
   and the DNS procedures in [RFC5766] (using SRV records with the
   "turn" service) be used to discover the TURN server.

   This specification only considers usage of a single STUN or TURN
   server.  When there are multiple choices for that single STUN or TURN
   server (when, for example, they are learned through DNS records and
   multiple results are returned), an agent SHOULD use a single STUN or
   TURN server (based on its IP address) for all candidates for a
   particular session.  This improves the performance of ICE.  The
   result is a set of pairs of host candidates with STUN or TURN
   servers.  The agent then chooses one pair, and sends a Binding or
   Allocate request to the server from that host candidate.  Binding
   requests to a STUN server are not authenticated, and any ALTERNATE-
   SERVER attribute in a response is ignored.  Agents MUST support the
   backwards compatibility mode for the Binding request defined in
   [RFC5389].  Allocate requests SHOULD be authenticated using a long-
   term credential obtained by the client through some other means.

   Every Ta milliseconds thereafter, the agent can generate another new
   STUN or TURN transaction.  This transaction can either be a retry of
   a previous transaction that failed with a recoverable error (such as
   authentication failure), or a transaction for a new host candidate
   and STUN or TURN server pair.  The agent SHOULD NOT generate
   transactions more frequently than one every Ta milliseconds.  See
   Section 16 for guidance on how to set Ta and the STUN retransmit
   timer, RTO.

   The agent will receive a Binding or Allocate response.  A successful
   Allocate response will provide the agent with a server reflexive
   candidate (obtained from the mapped address) and a relayed candidate
   in the XOR-RELAYED-ADDRESS attribute.  If the Allocate request is
   rejected because the server lacks resources to fulfill it, the agent
   SHOULD instead send a Binding request to obtain a server reflexive
   candidate.  A Binding response will provide the agent with only a
   server reflexive candidate (also obtained from the mapped address).
   The base of the server reflexive candidate is the host candidate from
   which the Allocate or Binding request was sent.  The base of a
   relayed candidate is that candidate itself.  If a relayed candidate
ToP   noToC   RFC5245 - Page 22
   is identical to a host candidate (which can happen in rare cases),
   the relayed candidate MUST be discarded.

4.1.1.3. Computing Foundations
Finally, the agent assigns each candidate a foundation. The foundation is an identifier, scoped within a session. Two candidates MUST have the same foundation ID when all of the following are true: o they are of the same type (host, relayed, server reflexive, or peer reflexive). o their bases have the same IP address (the ports can be different). o for reflexive and relayed candidates, the STUN or TURN servers used to obtain them have the same IP address. o they were obtained using the same transport protocol (TCP, UDP, etc.). Similarly, two candidates MUST have different foundations if their types are different, their bases have different IP addresses, the STUN or TURN servers used to obtain them have different IP addresses, or their transport protocols are different.
4.1.1.4. Keeping Candidates Alive
Once server reflexive and relayed candidates are allocated, they MUST be kept alive until ICE processing has completed, as described in Section 8.3. For server reflexive candidates learned through a Binding request, the bindings MUST be kept alive by additional Binding requests to the server. Refreshes for allocations are done using the Refresh transaction, as described in [RFC5766]. The Refresh requests will also refresh the server reflexive candidate.

4.1.2. Prioritizing Candidates

The prioritization process results in the assignment of a priority to each candidate. Each candidate for a media stream MUST have a unique priority that MUST be a positive integer between 1 and (2**31 - 1). This priority will be used by ICE to determine the order of the connectivity checks and the relative preference for candidates. An agent SHOULD compute this priority using the formula in Section 4.1.2.1 and choose its parameters using the guidelines in Section 4.1.2.2. If an agent elects to use a different formula, ICE will take longer to converge since both agents will not be coordinated in their checks.
ToP   noToC   RFC5245 - Page 23
4.1.2.1. Recommended Formula
When using the formula, an agent computes the priority by determining a preference for each type of candidate (server reflexive, peer reflexive, relayed, and host), and, when the agent is multihomed, choosing a preference for its IP addresses. These two preferences are then combined to compute the priority for a candidate. That priority is computed using the following formula: priority = (2^24)*(type preference) + (2^8)*(local preference) + (2^0)*(256 - component ID) The type preference MUST be an integer from 0 to 126 inclusive, and represents the preference for the type of the candidate (where the types are local, server reflexive, peer reflexive, and relayed). A 126 is the highest preference, and a 0 is the lowest. Setting the value to a 0 means that candidates of this type will only be used as a last resort. The type preference MUST be identical for all candidates of the same type and MUST be different for candidates of different types. The type preference for peer reflexive candidates MUST be higher than that of server reflexive candidates. Note that candidates gathered based on the procedures of Section 4.1.1 will never be peer reflexive candidates; candidates of these type are learned from the connectivity checks performed by ICE. The local preference MUST be an integer from 0 to 65535 inclusive. It represents a preference for the particular IP address from which the candidate was obtained, in cases where an agent is multihomed. 65535 represents the highest preference, and a zero, the lowest. When there is only a single IP address, this value SHOULD be set to 65535. More generally, if there are multiple candidates for a particular component for a particular media stream that have the same type, the local preference MUST be unique for each one. In this specification, this only happens for multihomed hosts. If a host is multihomed because it is dual stack, the local preference SHOULD be set equal to the precedence value for IP addresses described in RFC 3484 [RFC3484]. The component ID is the component ID for the candidate, and MUST be between 1 and 256 inclusive.
4.1.2.2. Guidelines for Choosing Type and Local Preferences
One criterion for selection of the type and local preference values is the use of a media intermediary, such as a TURN server, VPN server, or NAT. With a media intermediary, if media is sent to that
ToP   noToC   RFC5245 - Page 24
   candidate, it will first transit the media intermediary before being
   received.  Relayed candidates are one type of candidate that involves
   a media intermediary.  Another are host candidates obtained from a
   VPN interface.  When media is transited through a media intermediary,
   it can increase the latency between transmission and reception.  It
   can increase the packet losses, because of the additional router hops
   that may be taken.  It may increase the cost of providing service,
   since media will be routed in and right back out of a media
   intermediary run by a provider.  If these concerns are important, the
   type preference for relayed candidates SHOULD be lower than host
   candidates.  The RECOMMENDED values are 126 for host candidates, 100
   for server reflexive candidates, 110 for peer reflexive candidates,
   and 0 for relayed candidates.  Furthermore, if an agent is multihomed
   and has multiple IP addresses, the local preference for host
   candidates from a VPN interface SHOULD have a priority of 0.

   Another criterion for selection of preferences is IP address family.
   ICE works with both IPv4 and IPv6.  It therefore provides a
   transition mechanism that allows dual-stack hosts to prefer
   connectivity over IPv6, but to fall back to IPv4 in case the v6
   networks are disconnected (due, for example, to a failure in a 6to4
   relay) [RFC3056].  It can also help with hosts that have both a
   native IPv6 address and a 6to4 address.  In such a case, higher local
   preferences could be assigned to the v6 addresses, followed by the
   6to4 addresses, followed by the v4 addresses.  This allows a site to
   obtain and begin using native v6 addresses immediately, yet still
   fall back to 6to4 addresses when communicating with agents in other
   sites that do not yet have native v6 connectivity.

   Another criterion for selecting preferences is security.  If a user
   is a telecommuter, and therefore connected to a corporate network and
   a local home network, the user may prefer their voice traffic to be
   routed over the VPN in order to keep it on the corporate network when
   communicating within the enterprise, but use the local network when
   communicating with users outside of the enterprise.  In such a case,
   a VPN address would have a higher local preference than any other
   address.

   Another criterion for selecting preferences is topological awareness.
   This is most useful for candidates that make use of intermediaries.
   In those cases, if an agent has preconfigured or dynamically
   discovered knowledge of the topological proximity of the
   intermediaries to itself, it can use that to assign higher local
   preferences to candidates obtained from closer intermediaries.
ToP   noToC   RFC5245 - Page 25

4.1.3. Eliminating Redundant Candidates

Next, the agent eliminates redundant candidates. A candidate is redundant if its transport address equals another candidate, and its base equals the base of that other candidate. Note that two candidates can have the same transport address yet have different bases, and these would not be considered redundant. Frequently, a server reflexive candidate and a host candidate will be redundant when the agent is not behind a NAT. The agent SHOULD eliminate the redundant candidate with the lower priority.

4.1.4. Choosing Default Candidates

A candidate is said to be default if it would be the target of media from a non-ICE peer; that target is called the DEFAULT DESTINATION. If the default candidates are not selected by the ICE algorithm when communicating with an ICE-aware peer, an updated offer/answer will be required after ICE processing completes in order to "fix up" the SDP so that the default destination for media matches the candidates selected by ICE. If ICE happens to select the default candidates, no updated offer/answer is required. An agent MUST choose a set of candidates, one for each component of each in-use media stream, to be default. A media stream is in-use if it does not have a port of zero (which is used in RFC 3264 to reject a media stream). Consequently, a media stream is in-use even if it is marked as a=inactive [RFC4566] or has a bandwidth value of zero. It is RECOMMENDED that default candidates be chosen based on the likelihood of those candidates to work with the peer that is being contacted. It is RECOMMENDED that the default candidates are the relayed candidates (if relayed candidates are available), server reflexive candidates (if server reflexive candidates are available), and finally host candidates.

4.2. Lite Implementation Requirements

Lite implementations only utilize host candidates. A lite implementation MUST, for each component of each media stream, allocate zero or one IPv4 candidates. It MAY allocate zero or more IPv6 candidates, but no more than one per each IPv6 address utilized by the host. Since there can be no more than one IPv4 candidate per component of each media stream, if an agent has multiple IPv4 addresses, it MUST choose one for allocating the candidate. If a host is dual stack, it is RECOMMENDED that it allocate one IPv4 candidate and one global IPv6 address. With the lite implementation, ICE cannot be used to dynamically choose amongst candidates. Therefore, including more than one candidate from a particular scope
ToP   noToC   RFC5245 - Page 26
   is NOT RECOMMENDED, since only a connectivity check can truly
   determine whether to use one address or the other.

   Each component has an ID assigned to it, called the component ID.
   For RTP-based media streams, the RTP itself has a component ID of 1,
   and RTCP a component ID of 2.  If an agent is using RTCP, it MUST
   obtain candidates for it.

   Each candidate is assigned a foundation.  The foundation MUST be
   different for two candidates allocated from different IP addresses,
   and MUST be the same otherwise.  A simple integer that increments for
   each IP address will suffice.  In addition, each candidate MUST be
   assigned a unique priority amongst all candidates for the same media
   stream.  This priority SHOULD be equal to:

   priority = (2^24)*(126) +
              (2^8)*(IP precedence) +
              (2^0)*(256 - component ID)

   If a host is v4-only, it SHOULD set the IP precedence to 65535.  If a
   host is v6 or dual stack, the IP precedence SHOULD be the precedence
   value for IP addresses described in RFC 3484 [RFC3484].

   Next, an agent chooses a default candidate for each component of each
   media stream.  If a host is IPv4 only, there would only be one
   candidate for each component of each media stream, and therefore that
   candidate is the default.  If a host is IPv6 or dual stack, the
   selection of default is a matter of local policy.  This default
   SHOULD be chosen such that it is the candidate most likely to be used
   with a peer.  For IPv6-only hosts, this would typically be a globally
   scoped IPv6 address.  For dual-stack hosts, the IPv4 address is
   RECOMMENDED.

4.3. Encoding the SDP

The process of encoding the SDP is identical between full and lite implementations. The agent will include an m line for each media stream it wishes to use. The ordering of media streams in the SDP is relevant for ICE. ICE will perform its connectivity checks for the first m line first, and consequently media will be able to flow for that stream first. Agents SHOULD place their most important media stream, if there is one, first in the SDP. There will be a candidate attribute for each candidate for a particular media stream. Section 15 provides detailed rules for constructing this attribute. The attribute carries the IP address,
ToP   noToC   RFC5245 - Page 27
   port, and transport protocol for the candidate, in addition to its
   properties that need to be signaled to the peer for ICE to work: the
   priority, foundation, and component ID.  The candidate attribute also
   carries information about the candidate that is useful for
   diagnostics and other functions: its type and related transport
   addresses.

   STUN connectivity checks between agents are authenticated using the
   short-term credential mechanism defined for STUN [RFC5389].  This
   mechanism relies on a username and password that are exchanged
   through protocol machinery between the client and server.  With ICE,
   the offer/answer exchange is used to exchange them.  The username
   part of this credential is formed by concatenating a username
   fragment from each agent, separated by a colon.  Each agent also
   provides a password, used to compute the message integrity for
   requests it receives.  The username fragment and password are
   exchanged in the ice-ufrag and ice-pwd attributes, respectively.  In
   addition to providing security, the username provides disambiguation
   and correlation of checks to media streams.  See Appendix B.4 for
   motivation.

   If an agent is a lite implementation, it MUST include an "a=ice-lite"
   session-level attribute in its SDP.  If an agent is a full
   implementation, it MUST NOT include this attribute.

   The default candidates are added to the SDP as the default
   destination for media.  For streams based on RTP, this is done by
   placing the IP address and port of the RTP candidate into the c and m
   lines, respectively.  If the agent is utilizing RTCP, it MUST encode
   the RTCP candidate using the a=rtcp attribute as defined in RFC 3605
   [RFC3605].  If RTCP is not in use, the agent MUST signal that using
   b=RS:0 and b=RR:0 as defined in RFC 3556 [RFC3556].

   The transport addresses that will be the default destination for
   media when communicating with non-ICE peers MUST also be present as
   candidates in one or more a=candidate lines.

   ICE provides for extensibility by allowing an offer or answer to
   contain a series of tokens that identify the ICE extensions used by
   that agent.  If an agent supports an ICE extension, it MUST include
   the token defined for that extension in the ice-options attribute.

   The following is an example SDP message that includes ICE attributes
   (lines folded for readability):
ToP   noToC   RFC5245 - Page 28
       v=0
       o=jdoe 2890844526 2890842807 IN IP4 10.0.1.1
       s=
       c=IN IP4 192.0.2.3
       t=0 0
       a=ice-pwd:asd88fgpdd777uzjYhagZg
       a=ice-ufrag:8hhY
       m=audio 45664 RTP/AVP 0
       b=RS:0
       b=RR:0
       a=rtpmap:0 PCMU/8000
       a=candidate:1 1 UDP 2130706431 10.0.1.1 8998 typ host
       a=candidate:2 1 UDP 1694498815 192.0.2.3 45664 typ srflx raddr
   10.0.1.1 rport 8998

   Once an agent has sent its offer or its answer, that agent MUST be
   prepared to receive both STUN and media packets on each candidate.
   As discussed in Section 11.1, media packets can be sent to a
   candidate prior to its appearance as the default destination for
   media in an offer or answer.

5. Receiving the Initial Offer

When an agent receives an initial offer, it will check if the offerer supports ICE, determine its own role, gather candidates, prioritize them, choose default candidates, encode and send an answer, and for full implementations, form the check lists and begin connectivity checks.

5.1. Verifying ICE Support

The agent will proceed with the ICE procedures defined in this specification if, for each media stream in the SDP it received, the default destination for each component of that media stream appears in a candidate attribute. For example, in the case of RTP, the IP address and port in the c and m lines, respectively, appear in a candidate attribute and the value in the rtcp attribute appears in a candidate attribute. If this condition is not met, the agent MUST process the SDP based on normal RFC 3264 procedures, without using any of the ICE mechanisms described in the remainder of this specification with the following exceptions: 1. The agent MUST follow the rules of Section 10, which describe keepalive procedures for all agents.
ToP   noToC   RFC5245 - Page 29
   2.  If the agent is not proceeding with ICE because there were
       a=candidate attributes, but none that matched the default
       destination of the media stream, the agent MUST include an a=ice-
       mismatch attribute in its answer.

   3.  If the default candidates were relayed candidates learned through
       a TURN server, the agent MUST create permissions in the TURN
       server for the IP addresses learned from its peer in the SDP it
       just received.  If this is not done, initial packets in the media
       stream from the peer may be lost.

5.2. Determining Role

For each session, each agent takes on a role. There are two roles -- controlling and controlled. The controlling agent is responsible for the choice of the final candidate pairs used for communications. For a full agent, this means nominating the candidate pairs that can be used by ICE for each media stream, and for generating the updated offer based on ICE's selection, when needed. For a lite implementation, being the controlling agent means selecting a candidate pair based on the ones in the offer and answer (for IPv4, there is only ever one pair), and then generating an updated offer reflecting that selection, when needed (it is never needed for an IPv4-only host). The controlled agent is told which candidate pairs to use for each media stream, and does not generate an updated offer to signal this information. The sections below describe in detail the actual procedures followed by controlling and controlled nodes. The rules for determining the role and the impact on behavior are as follows: Both agents are full: The agent that generated the offer which started the ICE processing MUST take the controlling role, and the other MUST take the controlled role. Both agents will form check lists, run the ICE state machines, and generate connectivity checks. The controlling agent will execute the logic in Section 8.1 to nominate pairs that will be selected by ICE, and then both agents end ICE as described in Section 8.1.2. In unusual cases, described in Appendix B.11, it is possible for both agents to mistakenly believe they are controlled or controlling. To resolve this, each agent MUST select a random number, called the tie-breaker, uniformly distributed between 0 and (2**64) - 1 (that is, a 64-bit positive integer). This number is used in connectivity checks to detect and repair this case, as described in Section 7.1.2.2.
ToP   noToC   RFC5245 - Page 30
   One agent full, one lite:  The full agent MUST take the controlling
      role, and the lite agent MUST take the controlled role.  The full
      agent will form check lists, run the ICE state machines, and
      generate connectivity checks.  That agent will execute the logic
      in Section 8.1 to nominate pairs that will be selected by ICE, and
      use the logic in Section 8.1.2 to end ICE.  The lite
      implementation will just listen for connectivity checks, receive
      them and respond to them, and then conclude ICE as described in
      Section 8.2.  For the lite implementation, the state of ICE
      processing for each media stream is considered to be Running, and
      the state of ICE overall is Running.

   Both lite:  The agent that generated the offer which started the ICE
      processing MUST take the controlling role, and the other MUST take
      the controlled role.  In this case, no connectivity checks are
      ever sent.  Rather, once the offer/answer exchange completes, each
      agent performs the processing described in Section 8 without
      connectivity checks.  It is possible that both agents will believe
      they are controlled or controlling.  In the latter case, the
      conflict is resolved through glare detection capabilities in the
      signaling protocol carrying the offer/answer exchange.  The state
      of ICE processing for each media stream is considered to be
      Running, and the state of ICE overall is Running.

   Once roles are determined for a session, they persist unless ICE is
   restarted.  An ICE restart (Section 9.1) causes a new selection of
   roles and tie-breakers.

5.3. Gathering Candidates

The process for gathering candidates at the answerer is identical to the process for the offerer as described in Section 4.1.1 for full implementations and Section 4.2 for lite implementations. It is RECOMMENDED that this process begin immediately on receipt of the offer, prior to alerting the user. Such gathering MAY begin when an agent starts.

5.4. Prioritizing Candidates

The process for prioritizing candidates at the answerer is identical to the process followed by the offerer, as described in Section 4.1.2 for full implementations and Section 4.2 for lite implementations.
ToP   noToC   RFC5245 - Page 31

5.5. Choosing Default Candidates

The process for selecting default candidates at the answerer is identical to the process followed by the offerer, as described in Section 4.1.4 for full implementations and Section 4.2 for lite implementations.

5.6. Encoding the SDP

The process for encoding the SDP at the answerer is identical to the process followed by the offerer for both full and lite implementations, as described in Section 4.3.

5.7. Forming the Check Lists

Forming check lists is done only by full implementations. Lite implementations MUST skip the steps defined in this section. There is one check list per in-use media stream resulting from the offer/answer exchange. To form the check list for a media stream, the agent forms candidate pairs, computes a candidate pair priority, orders the pairs by priority, prunes them, and sets their states. These steps are described in this section.

5.7.1. Forming Candidate Pairs

First, the agent takes each of its candidates for a media stream (called LOCAL CANDIDATES) and pairs them with the candidates it received from its peer (called REMOTE CANDIDATES) for that media stream. In order to prevent the attacks described in Section 18.5.2, agents MAY limit the number of candidates they'll accept in an offer or answer. A local candidate is paired with a remote candidate if and only if the two candidates have the same component ID and have the same IP address version. It is possible that some of the local candidates won't get paired with remote candidates, and some of the remote candidates won't get paired with local candidates. This can happen if one agent doesn't include candidates for the all of the components for a media stream. If this happens, the number of components for that media stream is effectively reduced, and considered to be equal to the minimum across both agents of the maximum component ID provided by each agent across all components for the media stream. In the case of RTP, this would happen when one agent provides candidates for RTCP, and the other does not. As another example, the offerer can multiplex RTP and RTCP on the same port and signals that it can do that in the SDP through an SDP attribute [RFC5761]. However, since the offerer doesn't know if the answerer can perform
ToP   noToC   RFC5245 - Page 32
   such multiplexing, the offerer includes candidates for RTP and RTCP
   on separate ports, so that the offer has two components per media
   stream.  If the answerer can perform such multiplexing, it would
   include just a single component for each candidate - for the combined
   RTP/RTCP mux.  ICE would end up acting as if there was just a single
   component for this candidate.

   The candidate pairs whose local and remote candidates are both the
   default candidates for a particular component is called,
   unsurprisingly, the default candidate pair for that component.  This
   is the pair that would be used to transmit media if both agents had
   not been ICE aware.

   In order to aid understanding, Figure 6 shows the relationships
   between several key concepts -- transport addresses, candidates,
   candidate pairs, and check lists, in addition to indicating the main
   properties of candidates and candidate pairs.
ToP   noToC   RFC5245 - Page 33
       +------------------------------------------+
       |                                          |
       | +---------------------+                  |
       | |+----+ +----+ +----+ |   +Type          |
       | || IP | |Port| |Tran| |   +Priority      |
       | ||Addr| |    | |    | |   +Foundation    |
       | |+----+ +----+ +----+ |   +ComponentiD   |
       | |      Transport      |   +RelatedAddr   |
       | |        Addr         |                  |
       | +---------------------+   +Base          |
       |             Candidate                    |
       +------------------------------------------+
       *                                         *
       *    *************************************
       *    *
     +-------------------------------+
    .|                               |
     | Local     Remote              |
     | +----+    +----+   +default?  |
     | |Cand|    |Cand|   +valid?    |
     | +----+    +----+   +nominated?|
     |                    +State     |
     |                               |
     |                               |
     |          Candidate Pair       |
     +-------------------------------+
     *                              *
     *                  ************
     *                  *
     +------------------+
     |  Candidate Pair  |
     +------------------+
     +------------------+
     |  Candidate Pair  |
     +------------------+
     +------------------+
     |  Candidate Pair  |
     +------------------+

            Check
            List

               Figure 6: Conceptual Diagram of a Check List
ToP   noToC   RFC5245 - Page 34

5.7.2. Computing Pair Priority and Ordering Pairs

Once the pairs are formed, a candidate pair priority is computed. Let G be the priority for the candidate provided by the controlling agent. Let D be the priority for the candidate provided by the controlled agent. The priority for a pair is computed as: pair priority = 2^32*MIN(G,D) + 2*MAX(G,D) + (G>D?1:0) Where G>D?1:0 is an expression whose value is 1 if G is greater than D, and 0 otherwise. Once the priority is assigned, the agent sorts the candidate pairs in decreasing order of priority. If two pairs have identical priority, the ordering amongst them is arbitrary.

5.7.3. Pruning the Pairs

This sorted list of candidate pairs is used to determine a sequence of connectivity checks that will be performed. Each check involves sending a request from a local candidate to a remote candidate. Since an agent cannot send requests directly from a reflexive candidate, but only from its base, the agent next goes through the sorted list of candidate pairs. For each pair where the local candidate is server reflexive, the server reflexive candidate MUST be replaced by its base. Once this has been done, the agent MUST prune the list. This is done by removing a pair if its local and remote candidates are identical to the local and remote candidates of a pair higher up on the priority list. The result is a sequence of ordered candidate pairs, called the check list for that media stream. In addition, in order to limit the attacks described in Section 18.5.2, an agent MUST limit the total number of connectivity checks the agent performs across all check lists to a specific value, and this value MUST be configurable. A default of 100 is RECOMMENDED. This limit is enforced by discarding the lower-priority candidate pairs until there are less than 100. It is RECOMMENDED that a lower value be utilized when possible, set to the maximum number of plausible checks that might be seen in an actual deployment configuration. The requirement for configuration is meant to provide a tool for fixing this value in the field if, once deployed, it is found to be problematic.

5.7.4. Computing States

Each candidate pair in the check list has a foundation and a state. The foundation is the combination of the foundations of the local and remote candidates in the pair. The state is assigned once the check list for each media stream has been computed. There are five potential values that the state can have:
ToP   noToC   RFC5245 - Page 35
   Waiting:  A check has not been performed for this pair, and can be
      performed as soon as it is the highest-priority Waiting pair on
      the check list.

   In-Progress:  A check has been sent for this pair, but the
      transaction is in progress.

   Succeeded:  A check for this pair was already done and produced a
      successful result.

   Failed:  A check for this pair was already done and failed, either
      never producing any response or producing an unrecoverable failure
      response.

   Frozen:  A check for this pair hasn't been performed, and it can't
      yet be performed until some other check succeeds, allowing this
      pair to unfreeze and move into the Waiting state.

   As ICE runs, the pairs will move between states as shown in Figure 7.
ToP   noToC   RFC5245 - Page 36
      +-----------+
      |           |
      |           |
      |  Frozen   |
      |           |
      |           |
      +-----------+
            |
            |unfreeze
            |
            V
      +-----------+         +-----------+
      |           |         |           |
      |           | perform |           |
      |  Waiting  |-------->|In-Progress|
      |           |         |           |
      |           |         |           |
      +-----------+         +-----------+
                                  / |
                                //  |
                              //    |
                            //      |
                           /        |
                         //         |
               failure //           |success
                     //             |
                    /               |
                  //                |
                //                  |
              //                    |
             V                      V
      +-----------+         +-----------+
      |           |         |           |
      |           |         |           |
      |   Failed  |         | Succeeded |
      |           |         |           |
      |           |         |           |
      +-----------+         +-----------+

                         Figure 7: Pair State FSM

   The initial states for each pair in a check list are computed by
   performing the following sequence of steps:

   1.  The agent sets all of the pairs in each check list to the Frozen
       state.
ToP   noToC   RFC5245 - Page 37
   2.  The agent examines the check list for the first media stream (a
       media stream is the first media stream when it is described by
       the first m line in the SDP offer and answer).  For that media
       stream:

       *  For all pairs with the same foundation, it sets the state of
          the pair with the lowest component ID to Waiting.  If there is
          more than one such pair, the one with the highest priority is
          used.

   One of the check lists will have some number of pairs in the Waiting
   state, and the other check lists will have all of their pairs in the
   Frozen state.  A check list with at least one pair that is Waiting is
   called an active check list, and a check list with all pairs Frozen
   is called a frozen check list.

   The check list itself is associated with a state, which captures the
   state of ICE checks for that media stream.  There are three states:

   Running:  In this state, ICE checks are still in progress for this
      media stream.

   Completed:  In this state, ICE checks have produced nominated pairs
      for each component of the media stream.  Consequently, ICE has
      succeeded and media can be sent.

   Failed:  In this state, the ICE checks have not completed
      successfully for this media stream.

   When a check list is first constructed as the consequence of an
   offer/answer exchange, it is placed in the Running state.

   ICE processing across all media streams also has a state associated
   with it.  This state is equal to Running while ICE processing is
   under way.  The state is Completed when ICE processing is complete
   and Failed if it failed without success.  Rules for transitioning
   between states are described below.

5.8. Scheduling Checks

Checks are generated only by full implementations. Lite implementations MUST skip the steps described in this section. An agent performs ordinary checks and triggered checks. The generation of both checks is governed by a timer that fires periodically for each media stream. The agent maintains a FIFO queue, called the triggered check queue, which contains candidate pairs for which checks are to be sent at the next available
ToP   noToC   RFC5245 - Page 38
   opportunity.  When the timer fires, the agent removes the top pair
   from the triggered check queue, performs a connectivity check on that
   pair, and sets the state of the candidate pair to In-Progress.  If
   there are no pairs in the triggered check queue, an ordinary check is
   sent.

   Once the agent has computed the check lists as described in
   Section 5.7, it sets a timer for each active check list.  The timer
   fires every Ta*N seconds, where N is the number of active check lists
   (initially, there is only one active check list).  Implementations
   MAY set the timer to fire less frequently than this.  Implementations
   SHOULD take care to spread out these timers so that they do not fire
   at the same time for each media stream.  Ta and the retransmit timer
   RTO are computed as described in Section 16.  Multiplying by N allows
   this aggregate check throughput to be split between all active check
   lists.  The first timer fires immediately, so that the agent performs
   a connectivity check the moment the offer/answer exchange has been
   done, followed by the next check Ta seconds later (since there is
   only one active check list).

   When the timer fires and there is no triggered check to be sent, the
   agent MUST choose an ordinary check as follows:

   o  Find the highest-priority pair in that check list that is in the
      Waiting state.

   o  If there is such a pair:

      *  Send a STUN check from the local candidate of that pair to the
         remote candidate of that pair.  The procedures for forming the
         STUN request for this purpose are described in Section 7.1.2.

      *  Set the state of the candidate pair to In-Progress.

   o  If there is no such pair:

      *  Find the highest-priority pair in that check list that is in
         the Frozen state.

      *  If there is such a pair:

         +  Unfreeze the pair.

         +  Perform a check for that pair, causing its state to
            transition to In-Progress.
ToP   noToC   RFC5245 - Page 39
      *  If there is no such pair:

         +  Terminate the timer for that check list.

   To compute the message integrity for the check, the agent uses the
   remote username fragment and password learned from the SDP from its
   peer.  The local username fragment is known directly by the agent for
   its own candidate.

6. Receipt of the Initial Answer

This section describes the procedures that an agent follows when it receives the answer from the peer. It verifies that its peer supports ICE, determines its role, and for full implementations, forms the check list and begins performing ordinary checks. When ICE is used with SIP, forking may result in a single offer generating a multiplicity of answers. In that case, ICE proceeds completely in parallel and independently for each answer, treating the combination of its offer and each answer as an independent offer/ answer exchange, with its own set of pairs, check lists, states, and so on. The only case in which processing of one pair impacts another is freeing of candidates, discussed below in Section 8.3.

6.1. Verifying ICE Support

The logic at the offerer is identical to that of the answerer as described in Section 5.1, with the exception that an offerer would not ever generate a=ice-mismatch attributes in an SDP. In some cases, the answer may omit a=candidate attributes for the media streams, and instead include an a=ice-mismatch attribute for one or more of the media streams in the SDP. This signals to the offerer that the answerer supports ICE, but that ICE processing was not used for the session because a signaling intermediary modified the default destination for media components without modifying the corresponding candidate attributes. See Section 18 for a discussion of cases where this can happen. This specification provides no guidance on how an agent should proceed in such a failure case.

6.2. Determining Role

The offerer follows the same procedures described for the answerer in Section 5.2.
ToP   noToC   RFC5245 - Page 40

6.3. Forming the Check List

Formation of check lists is performed only by full implementations. The offerer follows the same procedures described for the answerer in Section 5.7.

6.4. Performing Ordinary Checks

Ordinary checks are performed only by full implementations. The offerer follows the same procedures described for the answerer in Section 5.8.

7. Performing Connectivity Checks

This section describes how connectivity checks are performed. All ICE implementations are required to be compliant to [RFC5389], as opposed to the older [RFC3489]. However, whereas a full implementation will both generate checks (acting as a STUN client) and receive them (acting as a STUN server), a lite implementation will only receive checks, and thus will only act as a STUN server.

7.1. STUN Client Procedures

These procedures define how an agent sends a connectivity check, whether it is an ordinary or a triggered check. These procedures are only applicable to full implementations.

7.1.1. Creating Permissions for Relayed Candidates

If the connectivity check is being sent using a relayed local candidate, the client MUST create a permission first if it has not already created one previously. It would have created one previously if it had told the TURN server to create a permission for the given relayed candidate towards the IP address of the remote candidate. To create the permission, the agent follows the procedures defined in [RFC5766]. The permission MUST be created towards the IP address of the remote candidate. It is RECOMMENDED that the agent defer creation of a TURN channel until ICE completes, in which case permissions for connectivity checks are normally created using a CreatePermission request. Once established, the agent MUST keep the permission active until ICE concludes.

7.1.2. Sending the Request

The check is generated by sending a Binding request from a local candidate to a remote candidate. [RFC5389] describes how Binding requests are constructed and generated. A connectivity check MUST
ToP   noToC   RFC5245 - Page 41
   utilize the STUN short-term credential mechanism.  Support for
   backwards compatibility with RFC 3489 MUST NOT be used or assumed
   with connectivity checks.  The FINGERPRINT mechanism MUST be used for
   connectivity checks.

   ICE extends STUN by defining several new attributes, including
   PRIORITY, USE-CANDIDATE, ICE-CONTROLLED, and ICE-CONTROLLING.  These
   new attributes are formally defined in Section 19.1, and their usage
   is described in the subsections below.  These STUN extensions are
   applicable only to connectivity checks used for ICE.

7.1.2.1. PRIORITY and USE-CANDIDATE
An agent MUST include the PRIORITY attribute in its Binding request. The attribute MUST be set equal to the priority that would be assigned, based on the algorithm in Section 4.1.2, to a peer reflexive candidate, should one be learned as a consequence of this check (see Section 7.1.3.2.1 for how peer reflexive candidates are learned). This priority value will be computed identically to how the priority for the local candidate of the pair was computed, except that the type preference is set to the value for peer reflexive candidate types. The controlling agent MAY include the USE-CANDIDATE attribute in the Binding request. The controlled agent MUST NOT include it in its Binding request. This attribute signals that the controlling agent wishes to cease checks for this component, and use the candidate pair resulting from the check for this component. Section 8.1.1 provides guidance on determining when to include it.
7.1.2.2. ICE-CONTROLLED and ICE-CONTROLLING
The agent MUST include the ICE-CONTROLLED attribute in the request if it is in the controlled role, and MUST include the ICE-CONTROLLING attribute in the request if it is in the controlling role. The content of either attribute MUST be the tie-breaker that was determined in Section 5.2. These attributes are defined fully in Section 19.1.
7.1.2.3. Forming Credentials
A Binding request serving as a connectivity check MUST utilize the STUN short-term credential mechanism. The username for the credential is formed by concatenating the username fragment provided by the peer with the username fragment of the agent sending the request, separated by a colon (":"). The password is equal to the password provided by the peer. For example, consider the case where agent L is the offerer, and agent R is the answerer. Agent L
ToP   noToC   RFC5245 - Page 42
   included a username fragment of LFRAG for its candidates and a
   password of LPASS.  Agent R provided a username fragment of RFRAG and
   a password of RPASS.  A connectivity check from L to R utilizes the
   username RFRAG:LFRAG and a password of RPASS.  A connectivity check
   from R to L utilizes the username LFRAG:RFRAG and a password of
   LPASS.  The responses utilize the same usernames and passwords as the
   requests (note that the USERNAME attribute is not present in the
   response).

7.1.2.4. DiffServ Treatment
If the agent is using Diffserv Codepoint markings [RFC2475] in its media packets, it SHOULD apply those same markings to its connectivity checks.

7.1.3. Processing the Response

When a Binding response is received, it is correlated to its Binding request using the transaction ID, as defined in [RFC5389], which then ties it to the candidate pair for which the Binding request was sent. This section defines additional procedures for processing Binding responses specific to this usage of STUN.
7.1.3.1. Failure Cases
If the STUN transaction generates a 487 (Role Conflict) error response, the agent checks whether it included the ICE-CONTROLLED or ICE-CONTROLLING attribute in the Binding request. If the request contained the ICE-CONTROLLED attribute, the agent MUST switch to the controlling role if it has not already done so. If the request contained the ICE-CONTROLLING attribute, the agent MUST switch to the controlled role if it has not already done so. Once it has switched, the agent MUST enqueue the candidate pair whose check generated the 487 into the triggered check queue. The state of that pair is set to Waiting. When the triggered check is sent, it will contain an ICE- CONTROLLING or ICE-CONTROLLED attribute reflecting its new role. Note, however, that the tie-breaker value MUST NOT be reselected. A change in roles will require an agent to recompute pair priorities (Section 5.7.2), since those priorities are a function of controlling and controlled roles. The change in role will also impact whether the agent is responsible for selecting nominated pairs and generating updated offers upon conclusion of ICE. Agents MAY support receipt of ICMP errors for connectivity checks. If the STUN transaction generates an ICMP error, the agent sets the state of the pair to Failed. If the STUN transaction generates a
ToP   noToC   RFC5245 - Page 43
   STUN error response that is unrecoverable (as defined in [RFC5389])
   or times out, the agent sets the state of the pair to Failed.

   The agent MUST check that the source IP address and port of the
   response equal the destination IP address and port to which the
   Binding request was sent, and that the destination IP address and
   port of the response match the source IP address and port from which
   the Binding request was sent.  In other words, the source and
   destination transport addresses in the request and responses are
   symmetric.  If they are not symmetric, the agent sets the state of
   the pair to Failed.

7.1.3.2. Success Cases
A check is considered to be a success if all of the following are true: o The STUN transaction generated a success response. o The source IP address and port of the response equals the destination IP address and port to which the Binding request was sent. o The destination IP address and port of the response match the source IP address and port from which the Binding request was sent.
7.1.3.2.1. Discovering Peer Reflexive Candidates
The agent checks the mapped address from the STUN response. If the transport address does not match any of the local candidates that the agent knows about, the mapped address represents a new candidate -- a peer reflexive candidate. Like other candidates, it has a type, base, priority, and foundation. They are computed as follows: o Its type is equal to peer reflexive. o Its base is set equal to the local candidate of the candidate pair from which the STUN check was sent. o Its priority is set equal to the value of the PRIORITY attribute in the Binding request. o Its foundation is selected as described in Section 4.1.1.3. This peer reflexive candidate is then added to the list of local candidates for the media stream. Its username fragment and password are the same as all other local candidates for that media stream.
ToP   noToC   RFC5245 - Page 44
   However, the peer reflexive candidate is not paired with other remote
   candidates.  This is not necessary; a valid pair will be generated
   from it momentarily based on the procedures in Section 7.1.3.2.2.  If
   an agent wishes to pair the peer reflexive candidate with other
   remote candidates besides the one in the valid pair that will be
   generated, the agent MAY generate an updated offer which includes the
   peer reflexive candidate.  This will cause it to be paired with all
   other remote candidates.

7.1.3.2.2. Constructing a Valid Pair
The agent constructs a candidate pair whose local candidate equals the mapped address of the response, and whose remote candidate equals the destination address to which the request was sent. This is called a valid pair, since it has been validated by a STUN connectivity check. The valid pair may equal the pair that generated the check, may equal a different pair in the check list, or may be a pair not currently on any check list. If the pair equals the pair that generated the check or is on a check list currently, it is also added to the VALID LIST, which is maintained by the agent for each media stream. This list is empty at the start of ICE processing, and fills as checks are performed, resulting in valid candidate pairs. It will be very common that the pair will not be on any check list. Recall that the check list has pairs whose local candidates are never server reflexive; those pairs had their local candidates converted to the base of the server reflexive candidates, and then pruned if they were redundant. When the response to the STUN check arrives, the mapped address will be reflexive if there is a NAT between the two. In that case, the valid pair will have a local candidate that doesn't match any of the pairs in the check list. If the pair is not on any check list, the agent computes the priority for the pair based on the priority of each candidate, using the algorithm in Section 5.7. The priority of the local candidate depends on its type. If it is not peer reflexive, it is equal to the priority signaled for that candidate in the SDP. If it is peer reflexive, it is equal to the PRIORITY attribute the agent placed in the Binding request that just completed. The priority of the remote candidate is taken from the SDP of the peer. If the candidate does not appear there, then the check must have been a triggered check to a new remote candidate. In that case, the priority is taken as the value of the PRIORITY attribute in the Binding request that triggered the check that just completed. The pair is then added to the VALID LIST.
ToP   noToC   RFC5245 - Page 45
7.1.3.2.3. Updating Pair States
The agent sets the state of the pair that *generated* the check to Succeeded. Note that, the pair which *generated* the check may be different than the valid pair constructed in Section 7.1.3.2.2 as a consequence of the response. The success of this check might also cause the state of other checks to change as well. The agent MUST perform the following two steps: 1. The agent changes the states for all other Frozen pairs for the same media stream and same foundation to Waiting. Typically, but not always, these other pairs will have different component IDs. 2. If there is a pair in the valid list for every component of this media stream (where this is the actual number of components being used, in cases where the number of components signaled in the SDP differs from offerer to answerer), the success of this check may unfreeze checks for other media streams. Note that this step is followed not just the first time the valid list under consideration has a pair for every component, but every subsequent time a check succeeds and adds yet another pair to that valid list. The agent examines the check list for each other media stream in turn: * If the check list is active, the agent changes the state of all Frozen pairs in that check list whose foundation matches a pair in the valid list under consideration to Waiting. * If the check list is frozen, and there is at least one pair in the check list whose foundation matches a pair in the valid list under consideration, the state of all pairs in the check list whose foundation matches a pair in the valid list under consideration is set to Waiting. This will cause the check list to become active, and ordinary checks will begin for it, as described in Section 5.8. * If the check list is frozen, and there are no pairs in the check list whose foundation matches a pair in the valid list under consideration, the agent + groups together all of the pairs with the same foundation, and + for each group, sets the state of the pair with the lowest component ID to Waiting. If there is more than one such pair, the one with the highest priority is used.
ToP   noToC   RFC5245 - Page 46
7.1.3.2.4. Updating the Nominated Flag
If the agent was a controlling agent, and it had included a USE- CANDIDATE attribute in the Binding request, the valid pair generated from that check has its nominated flag set to true. This flag indicates that this valid pair should be used for media if it is the highest-priority one amongst those whose nominated flag is set. This may conclude ICE processing for this media stream or all media streams; see Section 8. If the agent is the controlled agent, the response may be the result of a triggered check that was sent in response to a request that itself had the USE-CANDIDATE attribute. This case is described in Section 7.2.1.5, and may now result in setting the nominated flag for the pair learned from the original request.
7.1.3.3. Check List and Timer State Updates
Regardless of whether the check was successful or failed, the completion of the transaction may require updating of check list and timer states. If all of the pairs in the check list are now either in the Failed or Succeeded state: o If there is not a pair in the valid list for each component of the media stream, the state of the check list is set to Failed. o For each frozen check list, the agent * groups together all of the pairs with the same foundation, and * for each group, sets the state of the pair with the lowest component ID to Waiting. If there is more than one such pair, the one with the highest priority is used. If none of the pairs in the check list are in the Waiting or Frozen state, the check list is no longer considered active, and will not count towards the value of N in the computation of timers for ordinary checks as described in Section 5.8.

7.2. STUN Server Procedures

An agent MUST be prepared to receive a Binding request on the base of each candidate it included in its most recent offer or answer. This requirement holds even if the peer is a lite implementation.
ToP   noToC   RFC5245 - Page 47
   The agent MUST use a short-term credential to authenticate the
   request and perform a message integrity check.  The agent MUST
   consider the username to be valid if it consists of two values
   separated by a colon, where the first value is equal to the username
   fragment generated by the agent in an offer or answer for a session
   in-progress.  It is possible (and in fact very likely) that an
   offerer will receive a Binding request prior to receiving the answer
   from its peer.  If this happens, the agent MUST immediately generate
   a response (including computation of the mapped address as described
   in Section 7.2.1.2).  The agent has sufficient information at this
   point to generate the response; the password from the peer is not
   required.  Once the answer is received, it MUST proceed with the
   remaining steps required, namely, 7.2.1.3, 7.2.1.4, and 7.2.1.5 for
   full implementations.  In cases where multiple STUN requests are
   received before the answer, this may cause several pairs to be queued
   up in the triggered check queue.

   An agent MUST NOT utilize the ALTERNATE-SERVER mechanism, and MUST
   NOT support the backwards-compatibility mechanisms to RFC 3489.  It
   MUST utilize the FINGERPRINT mechanism.

   If the agent is using Diffserv Codepoint markings [RFC2475] in its
   media packets, it SHOULD apply those same markings to its responses
   to Binding requests.  The same would apply to any layer 2 markings
   the endpoint might be applying to media packets.

7.2.1. Additional Procedures for Full Implementations

This subsection defines the additional server procedures applicable to full implementations.
7.2.1.1. Detecting and Repairing Role Conflicts
Normally, the rules for selection of a role in Section 5.2 will result in each agent selecting a different role -- one controlling and one controlled. However, in unusual call flows, typically utilizing third party call control, it is possible for both agents to select the same role. This section describes procedures for checking for this case and repairing it. An agent MUST examine the Binding request for either the ICE- CONTROLLING or ICE-CONTROLLED attribute. It MUST follow these procedures: o If neither ICE-CONTROLLING nor ICE-CONTROLLED is present in the request, the peer agent may have implemented a previous version of this specification. There may be a conflict, but it cannot be detected.
ToP   noToC   RFC5245 - Page 48
   o  If the agent is in the controlling role, and the ICE-CONTROLLING
      attribute is present in the request:

      *  If the agent's tie-breaker is larger than or equal to the
         contents of the ICE-CONTROLLING attribute, the agent generates
         a Binding error response and includes an ERROR-CODE attribute
         with a value of 487 (Role Conflict) but retains its role.

      *  If the agent's tie-breaker is less than the contents of the
         ICE-CONTROLLING attribute, the agent switches to the controlled
         role.

   o  If the agent is in the controlled role, and the ICE-CONTROLLED
      attribute is present in the request:

      *  If the agent's tie-breaker is larger than or equal to the
         contents of the ICE-CONTROLLED attribute, the agent switches to
         the controlling role.

      *  If the agent's tie-breaker is less than the contents of the
         ICE-CONTROLLED attribute, the agent generates a Binding error
         response and includes an ERROR-CODE attribute with a value of
         487 (Role Conflict) but retains its role.

   o  If the agent is in the controlled role and the ICE-CONTROLLING
      attribute was present in the request, or the agent was in the
      controlling role and the ICE-CONTROLLED attribute was present in
      the request, there is no conflict.

   A change in roles will require an agent to recompute pair priorities
   (Section 5.7.2), since those priorities are a function of controlling
   and controlled roles.  The change in role will also impact whether
   the agent is responsible for selecting nominated pairs and generated
   updated offers upon conclusion of ICE.

   The remaining sections in Section 7.2.1 are followed if the server
   generated a successful response to the Binding request, even if the
   agent changed roles.

7.2.1.2. Computing Mapped Address
For requests being received on a relayed candidate, the source transport address used for STUN processing (namely, generation of the XOR-MAPPED-ADDRESS attribute) is the transport address as seen by the TURN server. That source transport address will be present in the XOR-PEER-ADDRESS attribute of a Data Indication message, if the Binding request was delivered through a Data Indication. If the
ToP   noToC   RFC5245 - Page 49
   Binding request was delivered through a ChannelData message, the
   source transport address is the one that was bound to the channel.

7.2.1.3. Learning Peer Reflexive Candidates
If the source transport address of the request does not match any existing remote candidates, it represents a new peer reflexive remote candidate. This candidate is constructed as follows: o The priority of the candidate is set to the PRIORITY attribute from the request. o The type of the candidate is set to peer reflexive. o The foundation of the candidate is set to an arbitrary value, different from the foundation for all other remote candidates. If any subsequent offer/answer exchanges contain this peer reflexive candidate in the SDP, it will signal the actual foundation for the candidate. o The component ID of this candidate is set to the component ID for the local candidate to which the request was sent. This candidate is added to the list of remote candidates. However, the agent does not pair this candidate with any local candidates.
7.2.1.4. Triggered Checks
Next, the agent constructs a pair whose local candidate is equal to the transport address on which the STUN request was received, and a remote candidate equal to the source transport address where the request came from (which may be the peer reflexive remote candidate that was just learned). The local candidate will either be a host candidate (for cases where the request was not received through a relay) or a relayed candidate (for cases where it is received through a relay). The local candidate can never be a server reflexive candidate. Since both candidates are known to the agent, it can obtain their priorities and compute the candidate pair priority. This pair is then looked up in the check list. There can be one of several outcomes: o If the pair is already on the check list: * If the state of that pair is Waiting or Frozen, a check for that pair is enqueued into the triggered check queue if not already present.
ToP   noToC   RFC5245 - Page 50
      *  If the state of that pair is In-Progress, the agent cancels the
         in-progress transaction.  Cancellation means that the agent
         will not retransmit the request, will not treat the lack of
         response to be a failure, but will wait the duration of the
         transaction timeout for a response.  In addition, the agent
         MUST create a new connectivity check for that pair
         (representing a new STUN Binding request transaction) by
         enqueueing the pair in the triggered check queue.  The state of
         the pair is then changed to Waiting.

      *  If the state of the pair is Failed, it is changed to Waiting
         and the agent MUST create a new connectivity check for that
         pair (representing a new STUN Binding request transaction), by
         enqueueing the pair in the triggered check queue.

      *  If the state of that pair is Succeeded, nothing further is
         done.

      These steps are done to facilitate rapid completion of ICE when
      both agents are behind NAT.

   o  If the pair is not already on the check list:

      *  The pair is inserted into the check list based on its priority.

      *  Its state is set to Waiting.

      *  The pair is enqueued into the triggered check queue.

   When a triggered check is to be sent, it is constructed and processed
   as described in Section 7.1.2.  These procedures require the agent to
   know the transport address, username fragment, and password for the
   peer.  The username fragment for the remote candidate is equal to the
   part after the colon of the USERNAME in the Binding request that was
   just received.  Using that username fragment, the agent can check the
   SDP messages received from its peer (there may be more than one in
   cases of forking), and find this username fragment.  The
   corresponding password is then selected.

7.2.1.5. Updating the Nominated Flag
If the Binding request received by the agent had the USE-CANDIDATE attribute set, and the agent is in the controlled role, the agent looks at the state of the pair computed in Section 7.2.1.4: o If the state of this pair is Succeeded, it means that the check generated by this pair produced a successful response. This would have caused the agent to construct a valid pair when that success
ToP   noToC   RFC5245 - Page 51
      response was received (see Section 7.1.3.2.2).  The agent now sets
      the nominated flag in the valid pair to true.  This may end ICE
      processing for this media stream; see Section 8.

   o  If the state of this pair is In-Progress, if its check produces a
      successful result, the resulting valid pair has its nominated flag
      set when the response arrives.  This may end ICE processing for
      this media stream when it arrives; see Section 8.

7.2.2. Additional Procedures for Lite Implementations

If the check that was just received contained a USE-CANDIDATE attribute, the agent constructs a candidate pair whose local candidate is equal to the transport address on which the request was received, and whose remote candidate is equal to the source transport address of the request that was received. This candidate pair is assigned an arbitrary priority, and placed into a list of valid candidates called the valid list. The agent sets the nominated flag for that pair to true. ICE processing is considered complete for a media stream if the valid list contains a candidate pair for each component.


(page 51 continued on part 3)

Next Section