This specification defines an XMPP protocol extension for initiating and managing peer-to-peer media sessions between two XMPP entities in a way that is interoperable with existing Internet standards. The protocol provides a pluggable model that enables the core session management semantics to be used for a wide variety of application types (e.g., voice chat, video chat, file sharing) and with a wide variety of transport methods (e.g., TCP, UDP, ICE, application-specific transports).
NOTICE: This document is currently within Last Call or under consideration by the XMPP Council for advancement to the next stage in the XSF standards process.
Series: XEP
Number: 0166
Publisher: XMPP Standards Foundation
Status:
Proposed
Type:
Standards Track
Version: 0.23
Last Updated: 2008-01-11
Approving Body: XMPP Council
Dependencies: XMPP Core
Supersedes: None
Superseded By: None
Short Name: TO BE ASSIGNED
Wiki Page: <http://wiki.jabber.org/index.php/Jingle (XEP-0166)>
Email:
scottlu@google.com
JabberID:
scottlu@google.com
Email:
jbeda@google.com
JabberID:
jbeda@google.com
JabberID:
stpeter@jabber.org
URI:
https://stpeter.im/
Email:
robert.mcqueen@collabora.co.uk
JabberID:
robert.mcqueen@collabora.co.uk
Email:
seanegan@google.com
JabberID:
seanegan@google.com
Email:
jhildebrand@jabber.com
JabberID:
hildjj@jabber.org
The preferred venue for discussion of this document is the Standards discussion list: <http://mail.jabber.org/mailman/listinfo/standards>.
Errata may be sent to <editor@xmpp.org>.
The Extensible Messaging and Presence Protocol (XMPP) is defined in the XMPP Core (RFC 3920) and XMPP IM (RFC 3921) specifications contributed by the XMPP Standards Foundation to the Internet Standards Process, which is managed by the Internet Engineering Task Force in accordance with RFC 2026. Any protocol defined in this document has been developed outside the Internet Standards Process and is to be understood as an extension to XMPP rather than as an evolution, development, or modification of XMPP itself.
The following keywords as used in this document are to be interpreted as described in RFC 2119: "MUST", "SHALL", "REQUIRED"; "MUST NOT", "SHALL NOT"; "SHOULD", "RECOMMENDED"; "SHOULD NOT", "NOT RECOMMENDED"; "MAY", "OPTIONAL".
1. Introduction
2. How It Works
3. Requirements
4. Terminology
4.1. Glossary
4.2. Conventions
5. Concepts and Approach
5.1. Overall Session Management
6. Session Flow
6.1. Resource Determination
6.2. Initiation
6.3. Receiver Response
6.3.1. Acknowledgement
6.3.2. Errors
6.4. Negotiation
6.5. Acceptance
6.6. Modifying an Active Session
6.7. Termination
6.8. Informational Messages
7. Formal Definition
7.1. Jingle Element
7.2. Content Element
8. Error Handling
9. Determining Support
10. Conformance by Using Protocols
10.1. Application Formats
10.2. Transport Methods
11. Security Considerations
11.1. Denial of Service
11.2. Communication Through Gateways
11.3. Information Exposure
12. IANA Considerations
13. XMPP Registrar Considerations
13.1. Protocol Namespaces
13.2. Jingle Application Formats Registry
13.3. Jingle Transport Methods Registry
13.4. Jingle Reason Codes Registry
13.4.1. Process
13.4.2. Initial Registration
14. XML Schemas
14.1. Jingle
14.2. Jingle Errors
15. History
16. Acknowledgements
Notes
Revision History
The purpose of Jingle is to enable one-to-one, peer-to-peer media sessions between XMPP entities, where the negotiation occurs over the XMPP "channel" and the media is exchanged outside the XMPP channel using technologies such as the Real-time Transport Protocol (RTP; RFC 3550 [1]), the User Datagram Protocol (UDP; RFC 768 [2]), and Interactive Connectivity Establishment (ICE) [3].
One target application for Jingle is simple voice chat (see Jingle Audio via RTP [4]). We stress the word "simple". The purpose of Jingle is not to build a full-fledged telephony application that supports call waiting, call forwarding, call transfer, hold music, IVR systems, find-me-follow-me functionality, conference calls, and the like. These features are of interest to some user populations, but adding support for them to the core Jingle layer would introduce unnecessary complexity into a technology that is designed for basic multimedia interaction.
The purpose of Jingle is not to supplant or replace technologies based on Session Initiation Protocol (SIP; RFC 3261 [5]). Because dual-stack XMPP+SIP clients are difficult to build, Jingle was designed as a pure XMPP signalling protocol. However, Jingle is at the same time designed to interwork with SIP so that the millions of deployed XMPP clients can be added onto existing Voice over Internet Protocol (VoIP) networks, rather than limiting XMPP users to a separate and distinct network.
Jingle is designed in a modular way so that developers can easily add support for multimedia session types other than voice chat, such as video chat (see Jingle Video via RTP [6]), application sharing, file sharing, collaborative editing, whiteboarding, and torrent broadcasting. The transport methods are also modular, so that Jingle implementations can use any appropriate media transport (including proprietary methods not standardized through the XMPP Standards Foundation).
This section provides a friendly introduction to Jingle.
In essence, Jingle enables two XMPP entities (e.g., romeo@montague.lit and juliet@capulet.lit) to set up, manage, and tear down a multimedia session. The negotiation takes place over XMPP, and the media transfer takes place outside of XMPP. The simplest session flow is as follows:
Romeo Juliet | | | session-initiate | |---------------------------->| | ack | |<----------------------------| | session-accept | |<----------------------------| | ack | |---------------------------->| | MEDIA SESSION | |<===========================>| | session-terminate | |<----------------------------| | ack | |---------------------------->| | |
Naturally, more complex scenarios are probable; such scenarios are described in other specifications, such as XEP-0167 for voice chat.
The simplest flow might happen as follows. The example is that of a voice chat (see XEP-0167) initiated by Romeo, where the transport is Jingle Raw UDP Transport Method [7].
Example 1. Initiator sends session-initiate
<iq from='romeo@montague.lit/orchard'
id='jingle1'
to='juliet@capulet.lit/balcony'
type='set'>
<jingle xmlns='urn:xmpp:tmp:jingle'
action='session-initiate'
initiator='romeo@montague.lit/orchard'
sid='a73sjjvkla37jfea'>
<content creator='initiator' name='this-is-the-audio-content' profile='RTP/AVP'>
<description xmlns='urn:xmpp:tmp:jingle:apps:audio-rtp'>
<payload-type id='96' name='speex' clockrate='16000'/>
<payload-type id='97' name='speex' clockrate='8000'/>
<payload-type id='18' name='G729'/>
<payload-type id='103' name='L16' clockrate='16000' channels='2'/>
<payload-type id='98' name='x-ISAC' clockrate='8000'/>
</description>
<transport xmlns='urn:xmpp:tmp:jingle:transports:raw-udp'>
<candidate ip='10.1.1.104' port='13540' generation='0'/>
</transport>
</content>
</jingle>
</iq>
Example 2. Receiver acknowledges session-initiate
<iq from='juliet@capulet.lit/balcony'
id='jingle1'
to='romeo@montague.lit/orchard'
type='result'/>
If the proposed session is acceptable, the responder definitively accepts it.
Example 3. Receiver sends session-accept
<iq from='juliet@capulet.lit/balcony'
id='accept1'
to='romeo@montague.lit/orchard'
type='set'>
<jingle xmlns='urn:xmpp:tmp:jingle'
action='session-accept'
initiator='romeo@montague.lit/orchard'
responder='juliet@capulet.lit/balcony'
sid='a73sjjvkla37jfea'>
<content creator='initiator' name='this-is-the-audio-content' profile='RTP/AVP'>
<description xmlns='urn:xmpp:tmp:jingle:apps:audio-rtp'>
<payload-type id='97' name='speex' clockrate='8000'/>
<payload-type id='18' name='G729'/>
<payload-type id='0' name='PCMU' />
<payload-type id='102' name='iLBC'/>
<payload-type id='4' name='G723'/>
<payload-type id='8' name='PCMA'/>
<payload-type id='13' name='CN'/>
</description>
<transport xmlns='urn:xmpp:tmp:jingle:transports:raw-udp'>
<candidate ip='208.245.212.67' port='9876' generation='0'/>
</transport>
</content>
</jingle>
</iq>
The initiator then acknowledges the session-accept action.
Example 4. Initiator acknowledges session-accept
<iq from='romeo@montague.lit/orchard'
id='accept1'
to='juliet@capulet.lit/balcony'
type='result'/>
The parties then begin to exchange media. In this case they would exchange audio using the Speex codec at a clockrate of 8000 since that is the highest-priority codec for the responder (as determined by the XML order of the <payload-type/> children).
The parties may continue the session as long as desired.
Eventually, one of the parties terminates the session.
Example 5. Receiver terminates the session
<iq from='juliet@capulet.lit/balcony'
id='term1'
to='romeo@montague.lit/orchard'
type='set'>
<jingle xmlns='urn:xmpp:tmp:jingle'
action='session-terminate'
initiator='romeo@montague.lit/orchard'
reasoncode='no-error'
reasontext='Sorry, gotta go!'
sid='a73sjjvkla37jfea'/>
</iq>
The other party MUST then acknowledge termination of the session.
Example 6. Initiator acknowledges termination
<iq from='romeo@montague.lit/orchard'
id='term1'
to='juliet@capulet.lit/balcony'
type='result'/>
The protocol defined herein is designed to meet the following requirements:
This document defines the signalling protocol only. Additional documents specify the following:
Various application formats (audio, video, etc.) and, where possible, mapping of those types to the Session Description Protocol (SDP; see RFC 4566 [8]); examples include Jingle Audio via RTP and Jingle Video via RTP.
Various transport methods; examples include Jingle ICE-UDP Transport Method [9] and Raw UDP Transport.
Procedures for mapping the Jingle signalling protocol to existing signalling standards such as the IETF's Session Initiation Protocol (SIP) and the ITU's H.323 protocol (see H.323 [10]); these documents are forthcoming.
| Term | Definition |
|---|---|
| Application Format | The data format of the content type being established, which formally declares one purpose of the session (e.g., "voice" or "video"). This is the 'what' of the session (i.e., the bits to be transferred), such as the acceptable codecs when establishing a voice conversation. In Jingle XML syntax the application format is the namespace of the <description/> element. |
| Component | A numbered stream of data that needs to be transmitted between the endpoints for a given content type in the context of a given session. It is up to the transport to negotiate the details of each component. Depending on the content type, multiple components may be needed (e.g., two components might be needed, one to transmit an RTP stream and another to transmit RTCP timing information). |
| Content Type | A pair formed by the combination of one application format and one transport method. |
| Session | One or more content types negotiated between two entities. It is delimited in time by an initiate request and session ending events. During the lifetime of a session, content types can be added or removed. A session consists of at least one content type at a time. |
| Transport Method | The method for establishing data stream(s) between entities. Possible transports might include ICE-TCP, Raw UDP, inband data, etc. This is the 'how' of the session. In Jingle XML syntax this is the namespace of the <transport/> element. The transport method defines how to transfer bits from one host to another. Each transport method must specify whether it is lossy (thus suitable for applications where some packet loss is tolerable) or reliable (thus suitable for applications where packet loss is not tolerable). |
In diagrams, the following conventions are used:
Jingle consists of three parts, each with its own syntax and semantics:
This document defines the semantics and syntax for overall session management. It also provides pluggable "slots" for application formats and transport methods, which are specified in separate documents.
At the most basic level, the process for negotiating a Jingle session is as follows:
If the parties later discover a better candidate, they perform a "content-modify" negotiation and then switch to the better candidate. Naturally they can also modify various other parameters related to the session (e.g., adding video to a voice chat).
The state machine for overall session management (i.e., the state per Session ID) is as follows:
o
|
| session-initiate
|
| +-----------------------+
|/ |
PENDING o---------------------+ |
| | content-accept, | |
| | content-modify, | |
| | content-remove, | |
| | session-info, | |
| | transport-info | |
| +------------------+ |
| |
| session-accept |
| |
ACTIVE o---------------------+ |
| | content-accept, | |
| | content-add, | |
| | content-modify, | |
| | content-remove, | |
| | session-info, | |
| | transport-info | |
| +------------------+ |
| |
+-------------------------+
|
| session-terminate
|
o ENDED
There are three overall session states:
The actions related to management of the overall Jingle session are as follows:
| Action | Description |
|---|---|
| content-accept | Accept a content-add or content-modify action received from another party. |
| content-add | Add one or more new content types to the session. The sender MUST specify only the added content-type(s), not the added content-type(s) plus the existing content-type(s). Therefore it is the responsibility of the recipient to maintain a local copy of the current content type definition. This action MUST NOT be sent while the session is in the PENDING state. When a party sends a content-add, it MUST ignore any actions received from the other party until it receives acknowledgement of the content-add. [11] |
| content-modify | Change an existing content type. The sender SHOULD specify only the aspects for which a modification is desired (e.g., if a party wishes to change only the profile then it would send an empty <content/> element with a modified value for the 'profile' attribute; if a party wishes to change only the transport, then it would send a <content/> element that contains only a <transport/> child; etc.). Therefore it is the responsibility of the recipient to maintain a local copy of the current content type definition. The recipient MUST NOT reply to a content-modify action with another content-modify action. [12] |
| content-remove | Remove one or more content types from the session. The sender MUST specify only the removed content-type(s), not the removed content-type(s) plus the remaining content-type(s). Therefore it is the responsibility of the recipient to maintain a local copy of the current content type definition. [13] [14] [15] |
| session-accept | Definitively accept a session negotiation (implicitly this action also serves as a content-accept). |
| session-info | Send session-level information / messages, such as (for Jingle audio) a ringing message. |
| session-initiate | Request negotiation of a new Jingle session. |
| session-terminate | End an existing session. |
| transport-info | Exchange transport candidates; it is mainly used in XEP-0176 but may be used in other transport specifications. |
This section defines the high-level flow of a Jingle session. More detailed descriptions are provided in the specifications for Jingle application formats and transport methods.
In order to initiate a Jingle session, the initiator must determine which of the responder's XMPP resources is best for the desired application format. Methods for doing so are out of scope for this specification. However, see the Determining Support section of this document (and associated specifications) for relevant information.
Once the initiator has discovered which of the responder's XMPP resources is ideal for the desired application format, it sends a session initiation request to the responder. This request is an IQ-set containing a <jingle/> element qualified by the 'urn:xmpp:tmp:jingle' namespace (see Protocol Namespaces regarding issuance of one or more permanent namespaces), where the value of the 'action' attribute is "session-initiate" and where the <jingle/> element contains one or more <content/> elements. Each <content/> element defines a content type to be transferred during the session, and each <content/> element in turn contains one <description/> child element that specifies a desired application format and one <transport/> child element that specifies a potential transport method. If either party wishes to propose the use of multiple transport methods for the same application format, it must send multiple <content/> elements.
Note: The syntax and semantics of the <description/> and <transport/> elements are out of scope for this specification, since they are defined in related specifications. The syntax and semantics of the <jingle/> and <content/> elements are specified in this document under Formal Definition.
Note: In order to expedite session establishment, the initiator MAY send transport candidates (e.g., for negotiation of the ICE transport) immediately after sending the "session-initiate" message and before receiving acknowledgement from the responder (i.e., the initiator MUST consider the session to be PENDING even before receiving acknowledgement). Given in-order delivery, the responder should receive such "transport-info" messages after receiving the "session-initiate" message (if not, it is appropriate for the responder to return <unknown-session/> errors since according to its state machine the session does not exist).
Example 7. Receiver returns unknown-session error
<iq from='juliet@capulet.lit/balcony'
id='jingle1'
to='romeo@montague.lit/orchard'
type='error'>
<error type='cancel'>
<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
<unknown-session xmlns='urn:xmpp:tmp:jingle-errors'/>
</error>
</iq>
Unless one of the following errors occurs, the responder SHOULD acknowledge receipt of the initiation request.
Example 8. Receiver acknowledges session-initiate
<iq from='juliet@capulet.lit/balcony'
id='jingle1'
to='romeo@montague.lit/orchard'
type='result'/>
However, after acknowledging the session initiation request, the responder may subsequently determine that it cannot proceed with negotiation of the session (e.g., because it does not support any of the offered application formats or transport methods, because a human user is busy or unable to accept the session, because a human user wishes to formally decline the session, etc.). In these cases, the responder SHOULD immediately acknowledge the session initiation request but then terminate the session with an appropriate reasoncode as described in the Termination section of this document.
If the responder acknowledges receipt of the initation request, both parties must consider the session to be in the PENDING state.
There are several reasons why the responder might immediately return an error instead of acknowledging receipt of the initiation request:
If the initiator is unknown to the responder (e.g., via presence subscription as defined in RFC 3921 [16] or stanza session negotiation as defined in Stanza Session Negotiation [17]) and the responder has a policy of not communicating via Jingle with unknown entities, it SHOULD return a <service-unavailable/> error.
Example 9. Initiator is unknown to responder
<iq from='juliet@capulet.lit/balcony'
id='jingle1'
to='romeo@montague.lit/orchard'
type='error'>
<error type='cancel'>
<service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
</error>
</iq>
If the responder does not support Jingle, it MUST return a <service-unavailable/> error.
Example 10. Receiver does not support Jingle
<iq from='juliet@capulet.lit/balcony'
id='jingle1'
to='romeo@montague.lit/orchard'
type='error'>
<error type='cancel'>
<service-unavailable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
</error>
</iq>
If the responder wishes to redirect the request to another address, it SHOULD return a <redirect/> error.
Example 11. Receiver redirection
<iq from='juliet@capulet.lit/balcony'
id='jingle1'
to='romeo@montague.lit/orchard'
type='error'>
<error type='cancel'>
<redirect xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'>
voicemail@capulet.lit
</redirect>
</error>
</iq>
If the responder does not have sufficient resources to participate in a session, it SHOULD return a <resource-constraint/> error.
Example 12. Receiver has insufficent resources
<iq from='juliet@capulet.lit/balcony'
id='jingle1'
to='romeo@montague.lit/orchard'
type='error'>
<error type='wait'>
<resource-constraint xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
</error>
</iq>
If the initiation request was malformed, the responder MUST return a <bad-request/> error.
Example 13. Initiation request malformed
<iq from='juliet@capulet.lit/balcony'
id='jingle1'
to='romeo@montague.lit/orchard'
type='error'>
<error type='cancel'>
<bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
</error>
</iq>
In general, negotiation will be necessary before the parties can agree on an acceptable set of application formats and transport methods. There are many potential parameter combinations, as defined in the relevant specifications for various application formats and transport methods.
The allowable negotiations (including content-level and transport-level negotiations) are as follows:
If (after negotiation of transport methods and application formats as well as checking of transport candidates) the responder determines that it will be able to establish a connection, it sends a definitive acceptance to the initiator.
Note: In the session-accept stanza, the <jingle/> element MUST contain one or more <content/> elements, each of which MUST contain one <description/> element and one <transport/> element. The <jingle/> element SHOULD possess a 'responder' attribute that explicitly specifies the full JID of the responding entity; after sending acknowledgement of the session-accept, the initiator SHOULD send all future commmunications about this Jingle session to the JID provided in the 'responder' attribute and note the new JID in the user interface.
The initiator then acknowledges the responder's definitive acceptance, after which the parties can exchange media over the negotiated connection.
If one of the parties cannot find a suitable transport method or candidate, it SHOULD terminate the session as described below.
Once a session is in the ACTIVE state, it may be modified via a content-add, content-modify, content-remove, or transport-info action. Examples of such modifications are shown in the specifications for various application formats and transport methods.
In order to gracefully end the session (which MAY be done at any point after acknowledging receipt of the initiation request, including immediately thereafter in order to decline the request), either the responder or the initiator MUST send a "terminate" action to the other party.
The party that terminates the session SHOULD include a 'reasoncode' attribute that specifies why the session is being terminated. Examples follow.
One reason for terminating the session is that the terminating party is busy; in this case, the recommended reasoncode is "busy".
Example 14. Terminating the session (busy)
<iq from='juliet@capulet.lit/balcony'
id='term1'
to='romeo@montague.lit/orchard'
type='set'>
<jingle xmlns='urn:xmpp:tmp:jingle'
action='session-terminate'
initiator='romeo@montague.lit/orchard'
reasoncode='busy'
sid='a73sjjvkla37jfea'/>
</iq>
Another reason for terminating the session is that the terminating party wishes to formally decline the session; in this case, the recommended reasoncode is "decline".
Example 15. Terminating the session (session formally declined)
<iq from='juliet@capulet.lit/balcony'
id='term1'
to='romeo@montague.lit/orchard'
type='set'>
<jingle xmlns='urn:xmpp:tmp:jingle'
action='session-terminate'
initiator='romeo@montague.lit/orchard'
reasoncode='decline'
sid='a73sjjvkla37jfea'/>
</iq>
Another reason for terminating the session is that the terminating party already has an existing session with the other party and wishes to use that session rather than initiate a new session; in this case, the recommended reasoncode is "alternative-session" and the terminating party should include the session ID of the atlernative session in the 'reasontext' attribute.
Example 16. Terminating the session (existing session)
<iq from='juliet@capulet.lit/balcony'
id='term1'
to='romeo@montague.lit/orchard'
type='set'>
<jingle xmlns='urn:xmpp:tmp:jingle'
action='session-terminate'
initiator='romeo@montague.lit/orchard'
reasoncode='alternative-session'
reasontext='b84tkkwlmb48kgfb'/>
sid='a73sjjvkla37jfea'/>
</iq>
Another reason for terminating the session is that the terminating party does not support any of the offered application formats; in this case, the recommended reasoncode is "unsupported-applications".
Example 17. Terminating the session (no offered application format supported)
<iq from='juliet@capulet.lit/balcony'
id='term1'
to='romeo@montague.lit/orchard'
type='set'>
<jingle xmlns='urn:xmpp:tmp:jingle'
action='session-terminate'
initiator='romeo@montague.lit/orchard'
reasoncode='unsupported-applications'
sid='a73sjjvkla37jfea'/>
</iq>
Another reason for terminating the session is that the terminating party does not support any of the offered transport methods; in this case, the recommended reasoncode is "unsupported-transports".
Example 18. Terminating the session (no offered transport method supported)
<iq from='juliet@capulet.lit/balcony'
id='term1'
to='romeo@montague.lit/orchard'
type='set'>
<jingle xmlns='urn:xmpp:tmp:jingle'
action='session-terminate'
initiator='romeo@montague.lit/orchard'
reasoncode='unsupported-transports'
sid='a73sjjvkla37jfea'/>
</iq>
Upon receiving an action of "session-terminate", the other party MUST then acknowledge termination of the session:
Example 19. Acknowledging termination
<iq from='romeo@montague.lit/orchard'
id='term1'
to='juliet@capulet.lit/balcony'
type='result'/>
Note: As soon as an entity sends a "session-terminate" action, it MUST consider the session to be in the ENDED state (even before receiving acknowledgement from the other party). If the terminating entity receives additional Jingle-related IQ-sets from the other party after sending the "session-terminate" action, it MUST reply with an <unknown-session/> error.
Unfortunately, not all sessions end gracefully. In applications of Jingle that also involve the exchange of presence information, receipt of <presence type='unavailable'/> from the other party MAY be considered a session-ending event. However, in this case there is nothing for the party to acknowledge.
At any point after initiation of a Jingle session, either entity MAY send an informational message to the other party, for example to change a transport method, inform the other party that a device is ringing or that a scheduled event has occurred or will occur, etc.
An informational message MUST be an IQ-set containing a <jingle/> element whose 'action' attribute is set to a value of "session-info" or "transport-info"; the <jingle/> element MUST further contain a payload child element (specific to the session or to a transport method) that specifies the information being communicated. If the party that receives an informational message does not understand the payload, it MUST return a <feature-not-implemented/> error with a Jingle-specific error condition of <unsupported-info/>.
Example 20. Receiver returns unsupported-info error
<iq from='juliet@capulet.lit/balcony'
id='info1'
to='romeo@montague.lit/orchard'
type='error'>
<error type='modify'>
<feature-not-implemented xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/>
<unsupported-info xmlns='urn:xmpp:tmp:jingle-errors'/>
</error>
</iq>
If either party receives an empty "session-info" message for an active session, it MUST send an empty IQ result; this way, an empty "session-info" message may be used as a "ping" to determine session vitality.
Informational messages are specific to a particular application type or transport method and therefore are described in specifications other than this one.
The <jingle/> element MAY be empty or contain one or more <content/> elements (for which see Content Element).
The attributes of the <jingle/> element are as follows.
Table 3: Attributes of Jingle Element
| Attribute | Definition | Inclusion |
|---|---|---|
| action | A Jingle action as listed in this document (e.g., "session-terminate"). | REQUIRED |
| initiator | The full JID of the entity that has initiated the session flow (which may be different from the 'from' address on the IQ-set). | REQUIRED |
| reasoncode | A machine-readable purpose for the action being sent (e.g., "connectivity-error" for a session-terminate action). | OPTIONAL |
| reasontext | A human-readable purpose for the action being sent (e.g., "Sorry, gotta go!" for a session-terminate action). | OPTIONAL |
| responder | The full JID of the entity that has replied to the initiation, which may be different from the 'to' address on the IQ-set. | RECOMMENDED |
| sid | A random session identifier generated by the initiator, which effectively maps to the local-part of a SIP "Call-ID" parameter; this SHOULD match the XML Nmtoken production [18] so that XML character escaping is not needed for characters such as '&'. | REQUIRED |
The attributes of the <content/> element are as follows.
Table 4: Attributes of Content Element
| Attribute | Definition | Inclusion |
|---|---|---|
| creator | Which party originally generated the content type (used to prevent race conditions regarding modifications). | REQUIRED |
| name | A unique name or identifier for the content type (this identifier is opaque and does not have semantic meaning). | REQUIRED |
| profile | The profile in use (e.g., "RTP/AVP" in the context of the Real-time Transport Protocol). | RECOMMENDED |
| senders | Which parties in the session will be generating content; the allowable values are "initiator", "responder", or "both" (where "both" is the default). | RECOMMENDED |
The Jingle-specific error conditions are as follows. These condition elements are qualified by the 'urn:xmpp:tmp:jingle-errors' namespace (see Protocol Namespaces regarding issuance of one or more permanent namespaces).
| Jingle Condition | XMPP Condition | Description |
|---|---|---|
| <out-of-order/> | <unexpected-request/> | The request cannot occur at this point in the state machine (e.g., session-initiate after session-accept). |
| <unknown-session/> | <bad-request/> | The 'sid' attribute specifies a session that is unknown to the recipient (e.g., no longer live according to the recipient's state machine because the recipient previously terminated the session). |
| <unsupported-info/> | <feature-not-implemented/> | The recipient does not support the informational payload of a session-info message. |
If an entity supports Jingle, it MUST advertise that fact by returning a feature of "urn:xmpp:tmp:jingle" (see Protocol Namespaces regarding issuance of one or more permanent namespaces) in response to a Service Discovery [19] information request. The response MUST also include features for the application formats and transport methods supported by the responding entity, as described in the relevant specifications.
Example 21. Service Discovery Information Request
<iq from='romeo@montague.lit/orchard'
id='disco1'
to='juliet@capulet.lit/balcony'
type='get'>
<query xmlns='http://jabber.org/protocol/disco#info'/>
</iq>
Example 22. Service Discovery Information Response
<iq from='juliet@capulet.lit/balcony'
id='disco1'
to='romeo@montague.lit/orchard'
type='result'>
<query xmlns='http://jabber.org/protocol/disco#info'>
...
<feature var='urn:xmpp:tmp:jingle'/>
...
</query>
</iq>
Naturally, support MAY also be determined via the dynamic, presence-based profile of Service Discovery defined in XEP-0115.
A document that specifies a Jingle application format (e.g., audio via RTP) MUST define:
A document that specifies a Jingle transport method (e.g., Raw UDP) MUST define:
Jingle sessions may be resource-intensive. Therefore, it is possible to launch a denial-of-service attack against an entity by burdening it with too many Jingle sessions. Care must be taken to accept sessions only from known entities and only if the entity's device is able to process such sessions.
Jingle communications may be enabled through gateways to non-XMPP networks, whose security characteristics may be quite different from those of XMPP networks. (For example, on some SIP networks authentication is optional and "from" addresses can be easily forged.) Care must be taken in communicating through such gateways.
Mere negotiation of a Jingle session may expose sensitive information about the parties (e.g., IP addresses). Care must be taken in communicating such information, and end-to-end encryption should be used if the parties do not trust the intermediate servers or gateways.
This document requires no interaction with the Internet Assigned Numbers Authority (IANA) [20].
Until this specification advances to a status of Draft, its associated namespaces shall be:
Upon advancement of this specification, the XMPP Registrar [21] shall issue permanent namespaces in accordance with the process defined in Section 4 of XMPP Registrar Function [22].
The following namespaces are requested, and are thought to be unique per the XMPP Registrar's requirements:
The XMPP Registrar shall maintain a registry of Jingle application formats. All application format registrations shall be defined in separate specifications (not in this document). Application types defined within the XEP series MUST be registered with the XMPP Registrar, resulting in protocol URNs of the form "urn:xmpp:jingle:app:name" (where "name" is the registered name of the application format).
In order to submit new values to this registry, the registrant must define an XML fragment of the following form and either include it in the relevant XMPP Extension Protocol or send it to the email address <registrar@xmpp.org>:
<application>
<name>the name of the application format</name>
<desc>a natural-language summary of the application format</desc>
<transport>
whether the media can be sent over a "reliable" transport, a "lossy" transport, or "both"
</transport>
<doc>the document in which this application format is specified</doc>
</application>
The XMPP Registrar shall maintain a registry of Jingle transport methods. All transport method registrations shall be defined in separate specifications (not in this document). Transport methods defined within the XEP series MUST be registered with the XMPP Registrar, resulting in protocol URNs of the form "urn:xmpp:jingle:transport:name" (where "name" is the registered name of the transport method).
In order to submit new values to this registry, the registrant must define an XML fragment of the following form and either include it in the relevant XMPP Extension Protocol or send it to the email address <registrar@xmpp.org>:
<transport>
<name>the name of the transport method</name>
<desc>a natural-language summary of the transport method</desc>
<type>whether the transport method can be "reliable", "lossy", or "both"</type>
<doc>the document in which this transport method is specified</doc>
</transport>
The XMPP Registrar shall maintain a registry of reason codes related to Jingle actions.
In order to submit new values to this registry, the registrant must define an XML fragment of the following form and either include it in the relevant XMPP Extension Protocol or send it to the email address <registrar@xmpp.org>:
<reason>
<code>the value of the 'reasoncode' attribute</name>
<desc>a natural-language summary of the reason code</desc>
<doc>the document in which this reason code is specified</doc>
</reason>
The following submission registers reasoncodes currently in use. Refer to the registry itself for a complete and current list of reasoncodes.
<reason>
<code>alternative-session</code>
<desc>
the party prefers to use an existing session with the peer
rather than initiate a new session; the session ID of the
alternative session should be provided in the reasontext
attribute
</desc>
<doc>XEP-0166</doc>
</reason>
<reason>
<code>busy</code>
<desc>the party is busy</desc>
<doc>XEP-0166</doc>
</reason>
<reason>
<code>decline</code>
<desc>the party wishes to formally decline the session</desc>
<doc>XEP-0166</doc>
</reason>
<reason>
<code>connectivity-error</code>
<desc>the action is related to connectivity problems</desc>
<doc>XEP-0166</doc>
</reason>
<reason>
<code>general-error</code>
<desc>the action is related to a non-specific application error</desc>
<doc>XEP-0166</doc>
</reason>
<reason>
<code>media-error</code>
<desc>the action is related to media processing problems</desc>
<doc>XEP-0166</doc>
</reason>
<reason>
<code>no-error</code>
<desc>the action is generated during the normal course of state management</desc>
<doc>XEP-0166</doc>
</reason>
<reason>
<code>unsupported-applications</code>
<desc>the party supports none of the offered application formats</desc>
<doc>XEP-0166</doc>
</reason>
<reason>
<code>unsupported-transports</code>
<desc>the party supports none of the offered transport methods</desc>
<doc>XEP-0166</doc>
</reason>
<?xml version='1.0' encoding='UTF-8'?>
<xs:schema
xmlns:xs='http://www.w3.org/2001/XMLSchema'
targetNamespace='urn:xmpp:tmp:jingle'
xmlns='urn:xmpp:tmp:jingle'
elementFormDefault='qualified'>
<xs:element name='jingle'>
<xs:complexType>
<xs:sequence minOccurs='1' maxOccurs='unlimited'>
<xs:element ref='content'/>
</xs:sequence>
<xs:attribute name='action' use='required'>
<xs:simpleType>
<xs:restriction base='xs:NCName'>
<xs:enumeration value='content-accept'/>
<xs:enumeration value='content-add'/>
<xs:enumeration value='content-modify'/>
<xs:enumeration value='content-remove'/>
<xs:enumeration value='session-accept'/>
<xs:enumeration value='session-info'/>
<xs:enumeration value='session-initiate'/>
<xs:enumeration value='session-terminate'/>
<xs:enumeration value='transport-info'/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name='initiator' type='xs:string' use='required'/>
<xs:attribute name='reasoncode' type='xs:string' use='optional'/>
<xs:attribute name='reasontext' type='xs:string' use='optional'/>
<xs:attribute name='responder' type='xs:string' use='optional'/>
<xs:attribute name='sid' type='xs:NMTOKEN' use='required'/>
</xs:complexType>
</xs:element>
<xs:element name='content'>
<xs:complexType>
<xs:sequence>
<xs:any namespace='##other' minOccurs='0' maxOccurs='unbounded'/>
</xs:sequence>
<xs:attribute name='creator' use='required'>
<xs:simpleType>
<xs:restriction base='xs:NCName'>
<xs:enumeration value='initiator'>
<xs:enumeration value='responder'/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name='name' use='required' type='xs:string'/>
<xs:attribute name='profile' use='optional' type='xs:string'/>
<xs:attribute name='senders' use='optional' default='both'>
<xs:simpleType>
<xs:restriction base='xs:NCName'>
<xs:enumeration value='both'>
<xs:enumeration value='initiator'>
<xs:enumeration value='responder'/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:complexType>
</xs:element>
</xs:schema>
<?xml version='1.0' encoding='UTF-8'?>
<xs:schema
xmlns:xs='http://www.w3.org/2001/XMLSchema'
targetNamespace='urn:xmpp:tmp:jingle-errors'
xmlns='urn:xmpp:tmp:jingle-errors'
elementFormDefault='qualified'>
<xs:element name='out-of-order' type='empty'/>
<xs:element name='unknown-session' type='empty'/>
<xs:element name='unsupported-info' type='empty'/>
<xs:simpleType name='empty'>
<xs:restriction base='xs:string'>
<xs:enumeration value=''/>
</xs:restriction>
</xs:simpleType>
</xs:schema>
Until Jingle was developed, there existed no widely-adopted standard for initiating and managing peer-to-peer interactions between XMPP entities. Although several large service providers and Jabber client teams had written and implemented their own proprietary XMPP extensions for peer-to-peer signalling (usually only for voice), those technologies were not open and did not always take into account requirements to interoperate with SIP-based technologies. The only existing open protocol was A Transport for Initiating and Negotiating Sessions [23], which made it possible to initiate and manage peer-to-peer sessions, but which did not provide enough of the key signalling semantics to be easily implemented in Jabber/XMPP clients. [24]
The result was an unfortunate fragmentation within the XMPP community regarding signalling protocols. Essentially, there were two possible approaches to solving the problem:
Implementation experience indicates that a dual-stack approach may not be feasible on all the computing platforms for which Jabber clients have been written, or even desirable on platforms where it is feasible. [25] Therefore, it seemed reasonable to define an XMPP signalling protocol that could provide the necessary session management semantics while also making it relatively straightforward to interoperate with existing Internet standards.
As a result of feedback received on XEP-0111, the original authors of this document (Joe Hildebrand and Peter Saint-Andre) began to define such a signalling protocol, code-named Jingle. Upon communication with members of the Google Talk team, [26] it was discovered that the emerging Jingle approach was conceptually (and even syntactically) quite similar to the signalling protocol used in the Google Talk application. Therefore, in the interest of interoperability and adoption, we decided to harmonize the two approaches. The signalling protocol specified herein is, therefore, substantially equivalent to the original Google Talk protocol, with several adjustments based on feedback received from implementors as well as for publication by the XMPP Standards Foundation.
The authors would like to thank Rohan Mahy for his valuable input on early versions of this document. Thiago Camargo, Dafydd Harries, Antti Ijäs, Lauri Kaila, Justin Karneges, Jussi Laako, Anthony Minessale, Matt O'Gorman, Rob Taylor, Matt Tucker, Saku Vainio, Brian West, and others have also provided helpful input. Thanks also to those who have commented on the Standards SIG [27] and (earlier) Jingle [28] mailing lists.
1. RFC 3550: RTP: A Transport Protocol for Real-Time Applications <http://tools.ietf.org/html/rfc3550>.
2. RFC 768: User Datagram Protocol <http://tools.ietf.org/html/rfc0768>.
3. Interactive Connectivity Establishment (ICE): A Methodology for Network Address Translator (NAT) Traversal for Offer/Answer Protocols <http://tools.ietf.org/html/draft-ietf-mmusic-ice>. Work in progress.
4. XEP-0167: Jingle Audio via RTP <http://www.xmpp.org/extensions/xep-0167.html>.
5. RFC 3261: Session Initiation Protocol (SIP) <http://tools.ietf.org/html/rfc3261>.
6. XEP-0180: Jingle Video via RTP <http://www.xmpp.org/extensions/xep-0180.html>.
7. XEP-0177: Jingle Raw UDP Transport Method <http://www.xmpp.org/extensions/xep-0177.html>.
8. RFC 4566: SDP: Session Description Protocol <http://tools.ietf.org/html/rfc4566>.
9. XEP-0176: Jingle ICE-UDP Transport Method <http://www.xmpp.org/extensions/xep-0176.html>.
10. ITU Recommendation H.323: Packet-based Multimedia Communications Systems (September 1999).
11. In the event that a session contains two unidirectional streams of the same type because a content-add was issued simultaneously by both parties, it is RECOMMENDED that participants close the duplicate stream in favour of that created by the session initiator, which should be made bidirectional with a 'content-modify' action by the responder.
12. If both parties send modify messages at the same time, the modify message from the session initiator MUST trump the modify message from the recipient and the initiator SHOULD return an <unexpected-request/> error to the other party.
13. The recipient SHOULD NOT send a content-accept with the new content type definition after receiving a content-remove.
14. A client MUST NOT return an error upon receipt of a 'content-remove' action for a content type that is received after a 'content-remove' action has been sent but before the action has been acknowledged by the peer.
15. If the content-remove results in zero content types for the session, the entity that receives the content-remove SHOULD send a session-terminate action to the other party (since a session with no content types is void).
16. RFC 3921: Extensible Messaging and Presence Protocol (XMPP): Instant Messaging and Presence <http://tools.ietf.org/html/rfc3921>.
17. XEP-0155: Stanza Session Negotiation <http://www.xmpp.org/extensions/xep-0155.html>.
18. See <http://www.w3.org/TR/2000/WD-xml-2e-20000814#NT-Nmtoken>
19. XEP-0030: Service Discovery <http://www.xmpp.org/extensions/xep-0030.html>.
20. The Internet Assigned Numbers Authority (IANA) is the central coordinator for the assignment of unique parameter values for Internet protocols, such as port numbers and URI schemes. For further information, see <http://www.iana.org/>.
21. The XMPP Registrar maintains a list of reserved protocol namespaces as well as registries of parameters used in the context of XMPP extension protocols approved by the XMPP Standards Foundation. For further information, see <http://www.xmpp.org/registrar/>.
22. XEP-0053: XMPP Registrar Function <http://www.xmpp.org/extensions/xep-0053.html>.
23. XEP-0111: A Transport for Initiating and Negotiating Sessions <http://www.xmpp.org/extensions/xep-0111.html>.
24. It is true that TINS made it relatively easy to implement an XMPP-to-SIP gateway; however, in line with the long-time Jabber philosophy of "simple clients, complex servers", it would be better to force complexity onto the server-side gateway and to keep the client as simple as possible.
25. For example, one large ISP decided to switch to a pure XMPP approach after having implemented and deployed a dual-stack client for several years.
26. Google Talk is a messaging and voice chat service and client provided by Google; see <http://www.google.com/talk/>.
27. The Standards SIG is a standing Special Interest Group devoted to development of XMPP Extension Protocols. The discussion list of the Standards SIG is the primary venue for discussion of XMPP protocol extensions, as well as for announcements by the XMPP Extensions Editor and XMPP Registrar. To subscribe to the list or view the list archives, visit <http://mail.jabber.org/mailman/listinfo/standards/>.
28. Before this specification was formally accepted by the XMPP Standards Foundation as an XMPP Extension Protocol, it was discussed on the semi-private <jingle@jabber.org> mailing list; although that list is no longer used since the standards@xmpp.org list is the preferred discussion venue, for historical purposes it is publicly archived at <http://mail.jabber.org/pipermail/jingle/>.
Removed content-accept after content-remove; removed errors for unsupported-content and unsupported-transports since they are handled via session-terminate; clarified handling of responder attribute.
(psa)Modified session flows for busy, unsupported application formats, and unsupported transport methods to enable separation between Jingle core and distinct modules for applications and transports; moved resource determination recommendations to XEP-208.
(psa)Further editorial review.
(psa)Editorial review and consistency check; moved voice chat scenarios to XEP-0167.
(psa)Added scenario for handling of busy state, including Jingle-specific error code and modified error flow (no longer an instance of decline).
(psa)Added scenarios for various session flows; clarified handling of content-add, content-modify, and content-remove actions; clarified rules for codec priority.
(psa)Added <unsupported-info/> error.
(psa)Clarified resource determination process and updated text to reflect modifications to XEP-0168.
(psa)Rewrote introduction and moved historical text to separate section.
(psa)Clarified session lifetime; defined reason attribute and associated registry; further specified conformance requirements.
(psa)Simplified signalling process and state chart; Removed session-redirect action (use redirect error instead); removed content-decline action; removed transport-* actions (except transport-info for ICE negotiation); removed description-* actions; simplified syntax to allow only one transport per content type; corrected syntax of creator attribute to be either initiator or responder (not JIDs); added profile attribute to content element in order to specify RTP profile in use.
(psa/ram)Added creator attribute to content element for prevention of race condition; modified spec to use provisional namespace before advancement to Draft (per XEP-0053).
(psa/ram)Completed clarifications and corrections throughout; added section on Jingle Actions.
(psa)Made several corrections to the state machines and examples.
(ram/psa)Further cleaned up state machines and state-related actions.
(ram/psa)Changed channels to components in line with ICE; changed various action names for consistency; added session-extend and session-reduce actions to add and remove description/transport pairs; added description-modify action; added sender attribute to specify directionality.
(ram/psa)Added implementation note about handling multiple content types.
(psa)Changed media type to content type.
(se/psa)Further clarified state machine diagrams; specified that session accept must include agreed-upon media format and transport description; moved deployment notes to appropriate transport spec.
(psa/jb)Added glossary; clarified state machines; updated to reflect publication of XEP-0176 and XEP-0177.
(psa/jb)Provided more detail about modify scenarios; defined media-specific and transport-specific actions and adjusted state machine accordingly.
(psa/jb)Per agreement among the co-authors, moved transport definition to separate specification, simplified state machine, and made other associated changes to the text, examples, and schemas; also harmonized redirect, decline, and terminate processes.
(psa/jb)Initial version.
(psa)More fully documented burst mode, connectivity checks, error cases, etc.
(psa)Restructured document flow; provided example of burst mode.
(psa)Distinguished between dribble mode and burst mode, including mode attribute, service discovery features, and implementation notes; provided detailed resource discovery examples; corrected state chart; specified session termination; specified error conditions; specified semantics of informational messages; began to define security considerations; added Joe Beda as co-author.
(psa/sl/jb)Added more detail to basic session flow; harmonized candidate negotiation process with ICE.
(psa)Added XMPP Registrar considerations; defined schema; completed slight syntax cleanup.
(psa)Separated method description formats from signalling protocol.
(psa/sl)Harmonized basic session flow with Google Talk protocol; added Scott Ludwig as co-author.
(psa/sl)Added more detail to basic session flow.
(psa)Protocol cleanup.
(psa/jjh)First draft.
(psa/jjh)END