XEP-0322: Efficient XML Interchange (EXI) Format

1. Introduction
2. Use Cases
    2.1. Two approaches to use EXI
    2.2. Stream Compression
       2.2.1. Invalid setup
       2.2.2. Proposing compression parameters
       2.2.3. Uploading new schema files
       2.2.4. Uploading compressed schema files
       2.2.5. Downloading new schema files on server
       2.2.6. Accessing quick configurations
       2.2.7. Quick configuration failure
       2.2.8. Start compression
    2.3. EXI-specific stream elements
       2.3.1. streamStart
       2.3.2. streamEnd
    2.4. Alternative Transport Binding for EXI/XMPP over TCP
       2.4.1. DNS SRV lookup
       2.4.2. Fallback Process
       2.4.3. Default Payload Encoding Options for EXI/XMPP
3. Implementation Notes
    3.1. EXI Encoding Preprocessing and Postprocessing
    3.2. EXI options
       3.2.1. Evaluations of Options
    3.3. Transmission of EXI bodies and Session-wide Buffers
    3.4. Preserving prefixes
    3.5. Networks containing clients having limited memory
    3.6. Caching schema files
    3.7. Uploading vs. Downloading schemas
    3.8. Server decompression and recompression vs. binary forwarding
    3.9. Snapshot Repository for Well-known Schemas
    3.10. Generation of Canonic Schemas
    3.11. Using EXI Option Documents for Shortcut Setup
       3.11.1. Shortcut Setup for Alternative Transport Binding
    3.12. XMPP Schema files and their hash values
    3.13. Known problems with existing schemas
       3.13.1. Patch to avoid UPA for streams.xsd
       3.13.2. Patch for missing wildcards in extensible schemas
    3.14. Default schema for alternative bindings
    3.15. Reserved Schema IDs
4. Security Considerations
5. IANA Considerations
6. XMPP Registrar Considerations
7. XML Schema
8. For more information
9. Acknowledgements

Appendices
    A: Document Information
    B: Author Information
    C: Legal Notices
    D: Relation to XMPP
    E: Discussion Venue
    F: Requirements Conformance
    G: Notes
    H: Revision History

2.1 Two approaches to use EXI

There are two ways to use EXI to make efficient XMPP communication. The first method describes how to activate EXI-compression using Stream Compression (XEP-0138) [2] (XEP-0138). The second method describes an alternative binding. This method does not use Stream compression as defined in XEP-0138, rather it allows clients to connect to the server and start using EXI directly from the beginning.

2.2 Stream Compression

The following sections assume the client connects through the normal XMPP port, and starts communicating with the server using uncompressed XML fragments. When the client connects to the XMPP Server, it will receive a list of features supported by the server:

Example 1. Search Features

        
    <stream:features>
        <starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>
        <compression xmlns='http://jabber.org/features/compress'>
            <method>zlib</method>
            <method>lzw</method>
            <method>exi</method>
            <method>exi:54321</method>
        </compression>
    </stream:features>
      

Support for EXI compression through the normal XMPP port is detected by the existence of the exi compression method in the features stanza. If a port (static or dynamic) is available for a dedicated binary EXI/XMPP binding, this can be detected by the existence of the exi:PORT compression method, where PORT is replaced by the port number used. More information about this alternative method is available in the Alternative Bindings section.

Note: If the client already knows the port number of the dedicated binary EXI/XMPP binding, it can connect there directly, without the need to check the server features using the normal XMPP port.

Following is a list of use cases displaying how the client can configure and activate EXI compression on the current binding.

          
    <compress xmlns='http://jabber.org/protocol/compress'>
        <method>exi</method>
    </compress>

    <failure xmlns='http://jabber.org/protocol/compress'>
        <setup-failed/>
    </failure>
        

          
    <setup xmlns='http://jabber.org/protocol/compress/exi' version='1' strict='true' blockSize='1024'
           valueMaxLength='32' valuePartitionCapacity='100'>
        <schema ns='http://www.w3.org/XML/1998/namespace' bytes='4726' md5Hash='2e2cf9072dc058dcda41b7ee77a5cb54'/>
        <schema ns='http://etherx.jabber.org/streams' bytes='3450' md5Hash='68719b98725477c46a70958d1ea7c781'/>
        <schema ns='jabber:client' bytes='6968' md5Hash='5e2d5cbf0506e3f16336d295093d66c4'/>
        <schema ns='jabber:server' bytes='6948' md5Hash='dd95bd3055dfdd69984ed427cd6356e0'/>
        <schema ns='jabber:x:roster' bytes='1077' md5Hash='00cb233dee83919067559c5dcee04f3d'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-sasl' bytes='2769' md5Hash='fd9a83f5c75628486ce18c0eb3a35995'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-streams' bytes='3315' md5Hash='75cd95aecb9f1fd66110c3ddcf00c9b8'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-tls' bytes='688' md5Hash='dc18bc4da35bc1be7a6c52aa43330825'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-stanzas' bytes='3133' md5Hash='1a8d21588424f9134dc497de64b10c3f'/>
        <schema ns='http://jabber.org/protocol/compress/exi' bytes='15094' md5Hash='8b8f91b95d9101f0781e0ba9b4e106be'/>
        <schema ns='urn:xmpp:iot:control' bytes='6293' md5Hash='74dcea52300e8c8df8c4de2c9e90495b'/>
        <schema ns='urn:xmpp:iot:sensordata' bytes='8092' md5Hash='49b101e7deea39ccc31340a3c7871c43'/>
        <schema ns='urn:xmpp:iot:interoperability' bytes='1275' md5Hash='5d39845a0082715ff8807691698353bb'/>
        <schema ns='urn:xmpp:iot:provisioning' bytes='6303' md5Hash='3ed5360bc17eadb2a8949498c9af3f0c'/>
    </setup>
        

          
    <setupResponse xmlns='http://jabber.org/protocol/compress/exi' version='1' strict='true'
                   blockSize='1024' valueMaxLength='32' valuePartitionCapacity='100'>
        <schema ns='http://www.w3.org/XML/1998/namespace' bytes='4726' md5Hash='2e2cf9072dc058dcda41b7ee77a5cb54'/>
        <schema ns='http://etherx.jabber.org/streams' bytes='3450' md5Hash='68719b98725477c46a70958d1ea7c781'/>
        <schema ns='jabber:client' bytes='6968' md5Hash='5e2d5cbf0506e3f16336d295093d66c4'/>
        <schema ns='jabber:server' bytes='6948' md5Hash='dd95bd3055dfdd69984ed427cd6356e0'/>
        <schema ns='jabber:x:roster' bytes='1077' md5Hash='00cb233dee83919067559c5dcee04f3d'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-sasl' bytes='2769' md5Hash='fd9a83f5c75628486ce18c0eb3a35995'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-streams' bytes='3315' md5Hash='75cd95aecb9f1fd66110c3ddcf00c9b8'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-tls' bytes='688' md5Hash='dc18bc4da35bc1be7a6c52aa43330825'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-stanzas' bytes='3133' md5Hash='1a8d21588424f9134dc497de64b10c3f'/>
        <schema ns='http://jabber.org/protocol/compress/exi' bytes='15094' md5Hash='8b8f91b95d9101f0781e0ba9b4e106be'/>
        <schema ns='urn:xmpp:iot:control' bytes='6293' md5Hash='74dcea52300e8c8df8c4de2c9e90495b'/>
        <schema ns='urn:xmpp:iot:sensordata' bytes='8092' md5Hash='49b101e7deea39ccc31340a3c7871c43'/>
        <schema ns='urn:xmpp:iot:interoperability' bytes='1275' md5Hash='5d39845a0082715ff8807691698353bb'/>
        <missingSchema ns='urn:xmpp:iot:provisioning' bytes='6303' md5Hash='3ed5360bc17eadb2a8949498c9af3f0c'/>
    </setupResponse>
        

          
    <uploadSchema xmlns='http://jabber.org/protocol/compress/exi' contentType='Text'>
        PD94bWwgdmVyc2lvbj0nMS4wJyBlbmNvZGluZz0nVVRGLTgnPz4NCjx4czpzY2hlbWENCiAgICB4
        bWxuczp4cz0naHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEnDQogICAgdGFyZ2V0TmFt
        ZXNwYWNlPSd1cm46eG1wcDpzbjpwcm92aXNpb25pbmcnDQogICAgeG1sbnM9J3Vybjp4bXBwOnNu

        ...

        dmlsZWdlJz4NCgkJPHhzOmF0dHJpYnV0ZSBuYW1lPSdpZCcgdHlwZT0nUHJpdmlsZWdlSWQnIHVz
        ZT0ncmVxdWlyZWQnLz4NCgk8L3hzOmNvbXBsZXhUeXBlPg0KIA0KPC94czpzY2hlbWE+DQo=
    </uploadSchema>
        

          
    <setup xmlns='http://jabber.org/protocol/compress/exi' version='1' strict='true' blockSize='1024'
           valueMaxLength='32' valuePartitionCapacity='100'>
        <schema ns='http://www.w3.org/XML/1998/namespace' bytes='4726' md5Hash='2e2cf9072dc058dcda41b7ee77a5cb54'/>
        <schema ns='http://etherx.jabber.org/streams' bytes='3450' md5Hash='68719b98725477c46a70958d1ea7c781'/>
        <schema ns='jabber:client' bytes='6968' md5Hash='5e2d5cbf0506e3f16336d295093d66c4'/>
        <schema ns='jabber:server' bytes='6948' md5Hash='dd95bd3055dfdd69984ed427cd6356e0'/>
        <schema ns='jabber:x:roster' bytes='1077' md5Hash='00cb233dee83919067559c5dcee04f3d'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-sasl' bytes='2769' md5Hash='fd9a83f5c75628486ce18c0eb3a35995'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-streams' bytes='3315' md5Hash='75cd95aecb9f1fd66110c3ddcf00c9b8'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-tls' bytes='688' md5Hash='dc18bc4da35bc1be7a6c52aa43330825'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-stanzas' bytes='3133' md5Hash='1a8d21588424f9134dc497de64b10c3f'/>
        <schema ns='http://jabber.org/protocol/compress/exi' bytes='15094' md5Hash='8b8f91b95d9101f0781e0ba9b4e106be'/>
        <schema ns='urn:xmpp:iot:control' bytes='6293' md5Hash='74dcea52300e8c8df8c4de2c9e90495b'/>
        <schema ns='urn:xmpp:iot:sensordata' bytes='8092' md5Hash='49b101e7deea39ccc31340a3c7871c43'/>
        <schema ns='urn:xmpp:iot:interoperability' bytes='1275' md5Hash='5d39845a0082715ff8807691698353bb'/>
        <schema ns='urn:xmpp:iot:provisioning' bytes='6303' md5Hash='3ed5360bc17eadb2a8949498c9af3f0c'/>
    </setup>
        

          
    <setupResponse xmlns='http://jabber.org/protocol/compress/exi' version='1' strict='true'
                   blockSize='1024' valueMaxLength='32' valuePartitionCapacity='100' agreement='true'
                   configurationId='c76ab4ec-4993-4285-8c7a-098060581bb8'>
        <schema ns='http://www.w3.org/XML/1998/namespace' bytes='4726' md5Hash='2e2cf9072dc058dcda41b7ee77a5cb54'/>
        <schema ns='http://etherx.jabber.org/streams' bytes='3450' md5Hash='68719b98725477c46a70958d1ea7c781'/>
        <schema ns='jabber:client' bytes='6968' md5Hash='5e2d5cbf0506e3f16336d295093d66c4'/>
        <schema ns='jabber:server' bytes='6948' md5Hash='dd95bd3055dfdd69984ed427cd6356e0'/>
        <schema ns='jabber:x:roster' bytes='1077' md5Hash='00cb233dee83919067559c5dcee04f3d'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-sasl' bytes='2769' md5Hash='fd9a83f5c75628486ce18c0eb3a35995'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-streams' bytes='3315' md5Hash='75cd95aecb9f1fd66110c3ddcf00c9b8'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-tls' bytes='688' md5Hash='dc18bc4da35bc1be7a6c52aa43330825'/>
        <schema ns='urn:ietf:params:xml:ns:xmpp-stanzas' bytes='3133' md5Hash='1a8d21588424f9134dc497de64b10c3f'/>
        <schema ns='http://jabber.org/protocol/compress/exi' bytes='15094' md5Hash='8b8f91b95d9101f0781e0ba9b4e106be'/>
        <schema ns='urn:xmpp:iot:control' bytes='6293' md5Hash='74dcea52300e8c8df8c4de2c9e90495b'/>
        <schema ns='urn:xmpp:iot:sensordata' bytes='8092' md5Hash='49b101e7deea39ccc31340a3c7871c43'/>
        <schema ns='urn:xmpp:iot:interoperability' bytes='1275' md5Hash='5d39845a0082715ff8807691698353bb'/>
        <missingSchema ns='urn:xmpp:iot:provisioning' bytes='6303' md5Hash='3ed5360bc17eadb2a8949498c9af3f0c'/>
    </setupResponse>
        

          
    <downloadSchema xmlns='http://jabber.org/protocol/compress/exi' url='http://schemavault.example.org/compress/sn/provisioning.xsd'/>
        

          
    <downloadSchemaResponse xmlns='http://jabber.org/protocol/compress/exi' url='http://schemavault.example.org/compress/sn/provisioning.xsd' result='true'/>
        

          
    <downloadSchemaResponse xmlns='http://jabber.org/protocol/compress/exi' url='http://schemavault.example.org/compress/sn/provisioning.xsd' result='false'>
        <httpError code='404' message='NotFound'/>
    </downloadSchemaResponse>
        

          
    <downloadSchemaResponse xmlns='http://jabber.org/protocol/compress/exi' url='urk://example.com/schema.xsd' result='false'>
        <invalidUrl message='Unrecognized schema.'/>
    </downloadSchemaResponse>
        

          
    <downloadSchemaResponse xmlns='http://jabber.org/protocol/compress/exi' url='http://schemavault.example.org/compress/sn/provisioning.xsd' result='false'>
        <timeout message='No response returned.'/>
    </downloadSchemaResponse>
        

          
    <downloadSchemaResponse xmlns='http://jabber.org/protocol/compress/exi' url='http://schemavault.example.org/compress/sn/provisioning.xsd' result='false'>
        <invalidContentType contentTypeReturned='text/html'/>
    </downloadSchemaResponse>
        

          
    <downloadSchemaResponse xmlns='http://jabber.org/protocol/compress/exi' url='http://schemavault.example.org/compress/sn/provisioning.xsd' result='false'>
        <error message='No free space left.'/>
    </downloadSchemaResponse>
        

          
    <setup xmlns='http://jabber.org/protocol/compress/exi' configurationId='c76ab4ec-4993-4285-8c7a-098060581bb8'/>
        

          
    <setupResponse xmlns='http://jabber.org/protocol/compress/exi' agreement='true' configurationId='c76ab4ec-4993-4285-8c7a-098060581bb8'/>
        

          
    <setupResponse xmlns='http://jabber.org/protocol/compress/exi' agreement='false' configurationId='c76ab4ec-4993-4285-8c7a-098060581bb8'/>
        

          
    <compress xmlns='http://jabber.org/protocol/compress'>
        <method>exi</method>
    </compress>
        

          
    <compressed xmlns='http://jabber.org/protocol/compress'/>
        

2.3 EXI-specific stream elements

Becuase EXI engines need to close all open XML elements before decompressing, it cannot start the stream by sending only an open <stream> element, and close the stream by sending a closing </stream> element. Instead separate streamStart and streamEnd elements have to be sent, allowing for similar semantics on the EXI-compressed channel, as described in the following subsections.

For clarity, examples in this section are displayed in XML for readability. But it is understood that the elements are sent using EXI compression and using the options defined during setup.

          
    <exi:streamStart from='client@im.example.com'
                     to='im.example.com'
                     version='1.0'
                     xml:lang='en'
                     xmlns:exi='http://jabber.org/protocol/compress/exi'>
        <exi:xmlns prefix='' namespace='jabber:client'/>
        <exi:xmlns prefix='streams' namespace='http://etherx.jabber.org/streams'/>
        <exi:xmlns prefix='exi' namespace='http://jabber.org/protocol/compress/exi'/>
    </exi:streamStart>
        

          
    <exi:streamEnd xmlns:exi='http://jabber.org/protocol/compress/exi'/>
        

2.4 Alternative Transport Binding for EXI/XMPP over TCP

Alternative binding for EXI/XMPP is suitable for use cases such as factory automation, smart grid appliances, and other embedded use of communications. It works best if clients are constrained and does not update its specification frequently. In addition, the network should allow clients and servers to use not well-known port because this commeunication involves alternative TCP port.

Typical steps of communication is as follows (based on RFC 6120 [3]).

1. (Optional) A client (foo@example.net) try to resolve a server with alternative binding for EXI/XMPP with DNS SRV lookup (ex. _xmpp-bclient._tcp.example.net. IN SRV)

2. (Optional) A DNS server tells a set of DNS RR to notify a server accepts EXI/XMPP binding (ex. SRV 10 10 15222 srv.example.net.) (Optional: the DNS server may tell the version of the default schema supported by the server. Currently there is only one version and has no effect. For further discussion, see draft-doi-exi-messaging-requirement.

3. The client connects to srv.example.net. 15222 with TCP and the server accepts the connection.

4. The client sends out 'EXI Cookie' (e.g. '$EXI') and starts EXI stream with an EXI Header without any option document (implies default encoding parameters). It sends out EXI events corresponds to start tag of <stream:stream>. Following shows XML Equivalent and EXI events

   Example 22. XML equivalent of stream start element (Client to Server)

               
               
   <?xml version="1.0"?>
   <exi:streamStart xmlns:exi='http://jabber.org/protocol/compress/exi' version="1.0" to="jabber.example.org" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace" >
    <exi:xmlns prefix="stream" namespace="http://etherx.jabber.org/streams" />
    <exi:xmlns prefix="" namespace="jabber:client" />
    <exi:xmlns prefix="xml" namespace="http://www.w3.org/XML/1998/namespace" />
   </exi:streamStart>
   
             

   Example 23. Actual EXI Stream with EXI Header

               
               
   0000000 8a 40 8c ad c0 28 d4 c2 c4 c4 ca e4 5c ca f0 c2
   0000020 da e0 d8 ca 5c de e4 ce 00 20 04 89 a1 d1 d1 c0
   0000040 e8 bc bd 95 d1 a1 95 c9 e0 b9 a9 85 89 89 95 c8
   0000060 b9 bd c9 9c bd cd d1 c9 95 85 b5 cc 21 cd d1 c9
   0000100 95 85 b4 07 b5 30 b1 31 32 b9 1d 31 b6 34 b2 b7
   0000120 3a 01 02 66 87 47 47 03 a2 f2 f7 77 77 72 e7 73
   0000140 32 e6 f7 26 72 f5 84 d4 c2 f3 13 93 93 82 f6 e6
   0000160 16 d6 57 37 06 16 36 50 57 86 d6 ca
   0000174
   
             

5. The server responds with EXI stream, with EXI cookie, without EXI option, and with appropriate events for stream tag.

   Example 24. XML equivalent of stream start element (Server to Client)

               
               
   <?xml version="1.0"?>
   <exi:streamStart xmlns:exi='http://jabber.org/protocol/compress/exi' version="1.0" from="jabber.example.org" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace" >
    <exi:xmlns prefix="stream" namespace="http://etherx.jabber.org/streams" />
    <exi:xmlns prefix="" namespace="jabber:client" />
    <exi:xmlns prefix="xml" namespace="http://www.w3.org/XML/1998/namespace" />
   </exi:streamStart>
   
             

   Example 25. Actual EXI Stream with EXI Header

               
               
   0000000 8a 02 8d 4c 2c 4c 4c ae 45 cc af 0c 2d ae 0d 8c
   0000020 a5 cd ee 4c e2 08 ca dc 20 10 02 44 d0 e8 e8 e0
   0000040 74 5e 5e ca e8 d0 ca e4 f0 5c d4 c2 c4 c4 ca e4
   0000060 5c de e4 ce 5e e6 e8 e4 ca c2 da e6 10 e6 e8 e4
   0000100 ca c2 da 03 da 98 58 98 99 5c 8e 98 db 1a 59 5b
   0000120 9d 00 81 33 43 a3 a3 81 d1 79 7b bb bb b9 73 b9
   0000140 99 73 7b 93 39 7a c2 6a 61 79 89 c9 c9 c1 7b 73
   0000160 0b 6b 2b 9b 83 0b 1b 28 2b c3 6b 65
   0000174
   
   
             

6. If client needs TLS or SASL negotiation, it should be done at this step. As specified in Section 4.3.3 of RFC6120, both parties MUST not send events corresponds to </stream:stream> tag. (e.g. exi:streamEnd element)

7. If client needs to use different encoding option or schema than the default encoding options or the default schema, then the client shall start schema negotiation. The streams with alternate options/schemas SHOULD NOT have an EXI Options document to indicate the parameter is negotiated via previous XMPP stream.

   For example, the client want to use MUC option (XEP-0045)), the following communication will occur. First, client try to renegotiate XML schema used in the communication.

   Example 26. XML equivalent of setup element (Client to Server)

               
               
   <?xml version="1.0"?>
   <exi:setup xmlns:exi='http://jabber.org/protocol/compress/exi'>
     <exi:schema ns="http://jabber.org/protocol/muc" bytes="1322" md5Hash="853ad555f102bb2b71da9a2f2787f4f9" />
     <exi:schema ns="http://jabber.org/protocol/muc#owner" bytes="1284" md5Hash="6e4e2257c1a4ba937fbdf71664a7e793" />
   </exi:setup>
   
             

   Example 27. Actual EXI Stream

               
               
   0000000 7b 0a a0 a2 24 14 6a 69 4a 57 84 02 5a c4 b3 85
   0000020 aa 4a 84 f1 1d 07 79 1e 92 06 87 47 47 03 a2 f2
   0000040 f6 a6 16 26 26 57 22 e6 f7 26 72 f7 07 26 f7 46
   0000060 f6 36 f6 c2 f6 d7 56 32 10 28 88 ce 23 84 22 9d
   0000100 81 51 16 a4 8c ef 5b 5e 70 98 c4 51 dc 74 8c 99
   0000120 a1 d1 d1 c0 e8 bc bd a9 85 89 89 95 c8 b9 bd c9
   0000140 9c bd c1 c9 bd d1 bd 8d bd b0 bd b5 d5 8c 8d bd
   0000160 dd b9 95 ca
   0000164
   
             

8. In the response the server accepts schema change.

   Example 28. XML equivalent of setup element (Server to Client)

               
               
   <?xml version="1.0"?>
   <exi:setupResponse xmlns:exi='http://jabber.org/protocol/compress/exi' agreement="true" configurationId="a83b19b31e016409d3001331d9f084fc">
     <exi:schema ns="http://jabber.org/protocol/muc" bytes="1322" md5Hash="853ad555f102bb2b71da9a2f2787f4f9" />
     <exi:schema ns="http://jabber.org/protocol/muc#owner" bytes="1284" md5Hash="6e4e2257c1a4ba937fbdf71664a7e793" />
   </exi:setupResponse>
   
             

   Example 29. Actual EXI Stream

               
               
   0000000 7c 08 c9 8d cd 8c 58 58 58 98 cc 0b 58 4c 8d 4d
   0000020 4b 4d 18 8e 58 8b 4e 0e 58 4c 4b 4d 18 d8 8e 0d
   0000040 4e 4d 4d 4e 4d 8e 4c 72 a8 28 89 05 1a 9a 52 95
   0000060 e1 00 96 b1 2c e1 6a 92 a1 3c 47 41 de 47 a4 81
   0000100 a1 d1 d1 c0 e8 bc bd a9 85 89 89 95 c8 b9 bd c9
   0000120 9c bd c1 c9 bd d1 bd 8d bd b0 bd b5 d5 8c 84 0a
   0000140 22 33 88 e1 08 a7 60 54 45 a9 23 3b d6 d7 9c 26
   0000160 31 14 77 1d 23 26 68 74 74 70 3a 2f 2f 6a 61 62
   0000200 62 65 72 2e 6f 72 67 2f 70 72 6f 74 6f 63 6f 6c
   0000220 2f 6d 75 63 23 6f 77 6e 65 72 c0
   0000233
   
             

   Note that the server may deny the negotiation with agreement="false" setupResponse (example omitted).

9. Just after receiving the setupResponse, client re-opens the stream. The new stream should have EXI header and may have EXI option header with updated options.

   Example 30. XML equivalent of stream start element (Client to Server)

               
               
   <?xml version="1.0"?>
   <exi:streamStart xmlns:exi='http://jabber.org/protocol/compress/exi' version="1.0" to="jabber.example.org" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace">
    <exi:xmlns prefix="stream" namespace="http://etherx.jabber.org/streams" />
    <exi:xmlns prefix="" namespace="jabber:client" />
    <exi:xmlns prefix="xml" namespace="http://www.w3.org/XML/1998/namespace" />
   </exi:streamStart>
   
   
             

   Example 31. Actual EXI Stream

               
               
   0000000 98 40 8c ad c0 28 d4 c2 c4 c4 ca e4 5c ca f0 c2
   0000020 da e0 d8 ca 5c de e4 ce 00 20 04 89 a1 d1 d1 c0
   0000040 e8 bc bd 95 d1 a1 95 c9 e0 b9 a9 85 89 89 95 c8
   0000060 b9 bd c9 9c bd cd d1 c9 95 85 b5 cc 21 cd d1 c9
   0000100 95 85 b4 07 b5 30 b1 31 32 b9 1d 31 b6 34 b2 b7
   0000120 3a 01 02 66 87 47 47 03 a2 f2 f7 77 77 72 e7 73
   0000140 32 e6 f7 26 72 f5 84 d4 c2 f3 13 93 93 82 f6 e6
   0000160 16 d6 57 37 06 16 36 50 57 86 d6 ca
   0000174
   
             

10. In response, server re-opens the stream with exi:streamStart tag.

    Example 32. XML equivalent of stream start element (Server to Client)

                
                
    <?xml version="1.0"?>
    <!-- configuration id 761aabc0-a255-4b9b-89a1-4cb859559691 -->
    <exi:streamStart xmlns:exi='http://jabber.org/protocol/compress/exi' version="1.0" to="jabber.example.org" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace" >
     <exi:xmlns prefix="stream" namespace="http://etherx.jabber.org/streams" />
     <exi:xmlns prefix="" namespace="jabber:client" />
     <exi:xmlns prefix="xml" namespace="http://www.w3.org/XML/1998/namespace" />
    </exi:streamStart>
    
              

    Example 33. Actual EXI Stream

                
                
    0000000 98 02 8d 4c 2c 4c 4c ae 45 cc af 0c 2d ae 0d 8c
    0000020 a5 cd ee 4c e2 08 ca dc 20 10 02 44 d0 e8 e8 e0
    0000040 74 5e 5e ca e8 d0 ca e4 f0 5c d4 c2 c4 c4 ca e4
    0000060 5c de e4 ce 5e e6 e8 e4 ca c2 da e6 10 e6 e8 e4
    0000100 ca c2 da 03 da 98 58 98 99 5c 8e 98 db 1a 59 5b
    0000120 9d 00 81 33 43 a3 a3 81 d1 79 7b bb bb b9 73 b9
    0000140 99 73 7b 93 39 7a c2 6a 61 79 89 c9 c9 c1 7b 73
    0000160 0b 6b 2b 9b 83 0b 1b 28 2b c3 6b 65
    0000174
    
              

11. After an exi:streamStart from the server to the client, they can communicate with EXI stream. The first level element in conventional XMPP is encoded as root element of EXI message. For example, a client may send MUC query with EXI.

    Example 34. XML equivalent of MUC chat message (Client to Server)

                
                
    <?xml version="1.0"?>
    <iq xmlns="jabber:client" type="set" to="sensors@conference.example.org" id="ab26a" >
    <query xmlns="http://jabber.org/protocol/muc#owner">
    <x xmlns="jabber:x:data" type="submit" />
    </query>
    </iq>
    
              

    Example 35. Actual EXI Stream with EXI Header

                
                
    0000000 42 20 73 65 6e 73 6f 72 73 40 63 6f 6e 66 65 72
    0000020 65 6e 63 65 2e 65 78 61 6d 70 6c 65 2e 6f 72 67
    0000040 07 61 62 32 36 61 47 d9 5e 1a 50 1a 98 58 98 99
    0000060 5c 8b 99 5e 18 5b 5c 1b 19 4b 9b dc 99 cb dc d9
    0000100 5b 9c db dc a8
    0000105
    
              

    This message has a query element under muc#owner namespace. This is performed efficiently because this series of messages from the last streamStart element has been encoded with the set of schemas and the set inclues schemas for MUC. Otherwise, the encoding will become 'built-in grammar' even if the encoder and the decoder uses non-strict schema-informed grammar. This is not possible if either encoder or decoder does not support built-in grammar or the stream uses strict schema-informed grammar. In such cases, the whole message that contains undefined element or attribute SHOULD be dropped.

12. The client and the server may end the stream with exi:streamEnd tag anytime.

    Example 36. XML equivalent of stream end element (Client to Server)

                
                
    <?xml version="1.0"?>
    <streamEnd xmlns='http://jabber.org/protocol/compress/exi' />
    
              

    Example 37. Actual EXI Stream

                
                
    0000000 96
    0000001
    
              

    Exactly same message should be sent from the server to the client to close the opposite way of the stream (example omitted).

13. The client now can start a preconfigured EXI/XMPP stream with explicit EXI option with the encoding option and canoinc schema used in the previous negotiated session (shortcut setup)

    Example 38. EXI Option Document used for Shortcut Setup (Client to Server)

                
                
    <?xml version="1.0"?>
    <header xmlns="http://www.w3.org/2009/exi" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
     <common>
      <schemaId>c:761aabc0-a255-4b9b-89a1-4cb859559691</schemaId>
     </common>
    </header>
                
              

    Example 39. XML Equivalent of streamStart

                
                
    <?xml version="1.0"?>
    <exi:streamStart xmlns:exi='http://jabber.org/protocol/compress/exi' version="1.0" to="jabber.example.org" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace">
     <exi:xmlns prefix="stream" namespace="http://etherx.jabber.org/streams" />
     <exi:xmlns prefix="" namespace="jabber:client" />
     <exi:xmlns prefix="xml" namespace="http://www.w3.org/XML/1998/namespace" />
    </exi:streamStart>
                
              

14. The server may respond with the given configuration ID. This can skip the configuration setup and the communication can continue with preconfigured schemas.

    Example 40. EXI Option Document used for Shortcut Setup (Server to Client)

                
                
    <?xml version="1.0"?>
    <header xmlns="http://www.w3.org/2009/exi" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
     <common>
      <schemaId>c:761aabc0-a255-4b9b-89a1-4cb859559691</schemaId>
     </common>
    </header>
                
              

    Example 41. XML Equivalent of streamStart in response

                
                
    <?xml version="1.0"?>
    <exi:streamStart xmlns:exi='http://jabber.org/protocol/compress/exi' version="1.0" from="jabber.example.org" xml:lang="en" xmlns:xml="http://www.w3.org/XML/1998/namespace" >
     <exi:xmlns prefix="stream" namespace="http://etherx.jabber.org/streams" />
     <exi:xmlns prefix="" namespace="jabber:client" />
     <exi:xmlns prefix="xml" namespace="http://www.w3.org/XML/1998/namespace" />
    </exi:streamStart>
    
              

    Or server may deny to start the new communication by just sending streamEnd tag with default encoding.

    Example 42. XML Equivalent of streamEnd to deny the configuration

                
    <?xml version="1.0"?>
    <streamEnd xmlns='http://jabber.org/protocol/compress/exi' />
                
              

          <p xmlns="http://www.w3.org/2009/exi"
          xmlns:xsd="http://www.w3.org/2001/XMLSchema"
          xsi:type="xsd:decimal">1.1</p>
        

3.1 EXI Encoding Preprocessing and Postprocessing

This section describes a common view on programming model between EXI/XMPP servers and clients. This is just an example and an implementation may do it in different ways. However, messages exchanged as a result should be identical.

As shown in this document, XMPP documents represented by EXI is slightly different from documents represented in XML. For example, each stanzas and first level elements under <stream:stream> tags must be encoded as a standalone EXI body (document). If namespace prefixes are declared in the root element of XML process (<stream:stream> tag), the prefix should be recovered on decoded XML on the receiver side (EXI may or may not preserve prefix). Therefore, some preprocessing and postprocessing is required to make current XMPP implementations work properly over EXI/XMPP channel. An example of the configuration is described in the following figure.

Example 43. Example configuration of communication channels.

        
+-------------------------+               +-----------------------+
| +----+          |               |                +----+ |
| |    | <------------------ Plain XMPP Channel ----------------> |    | |
| |XMPP|               |                             |                   |XMPP| |
| |    | <-[Proc]-[EXI]<------- EXI Channel ------>[EXI]-[Proc]-> |    | |
| +----+                       |                  |              +----+ |
+-------------------------+                  +-----------------------+
        

      

In the example, the box XMPP is conventional XMPP process. [EXI] represents EXI processor (encoder and decoder). [Proc] means preprocessor and postprocessor. Following pre-process must be applied to XML streams from XMPP process before giving the stream to EXI processors.

1. <stream:stream> start tag must be converted to standalone <exi:streamStart> element. All attributes defined in the input XML except namespace declarations should be copied as is. Namespace declarations and prefixes must be converted to exi:xmlns element under exi:streamStart element.
2. All first level elements under the root <stream:stream> element must be converted to standalone (root) element of corresponding stanza elements. If there are missing namespace declarations in the element, appropriate prefix declarations should be added to the element before giving the element to the EXI encoder as a document. Contents of the elements should not be modified.
3. </stream:stream> end tag must be converted to standalone <exi:streamEnd> element.

Following post-process must be applied to XML streams from EXI processors before giving the stream to XMPP process.

1. Received <exi:streamStart> element must be converted to <stream:stream> start tag with appropriate attributes and namespace declarations. Prefixies defined in the <exi:streamStart> content must be saved under the current connection context of postprocessor.
2. Received EXI messages must be reproduced as elements under <stream:stream> root element. In addition, the namespace declarations in the element must be replaced to prefixes given in the streamStart tag content if there is a corresponding namespace declaration.
3. <exi:streamEnd> element must be converted to </stream:stream> end tag. The context created under the connection may be released.

3.2 EXI options

There are many EXI options in EXI Format. Followings are brief description for use in XMPP.

The alignment option is to control how the values are encoded. The default option 'bit-packed' fits most of communication use cases. If TLS compression is used at the same time, pre-compression will make the best result.

The compression option is a Boolean to specify additional entropy-based compression is performed over EXI encoding. This option works best for larger documents. Usual use cases expected in XMPP/EXI may not give much additional compactness to messages.

The strict option is a Boolean to let EXI grammars (schema-informed grammars) work more strictly. With a strict schema-informed grammar, only valid data with the schema is allowed in streams. This makes best compactness of a grammar and messages without additional entropy-based compression. With nonstrict schema-informed grammar, derived elements and attributes could be encoded in the built-in grammar. The built-in grammar is a dynamic, self-learning grammar model that gives full flexibility, with larger message size.

The preserve option is a set of Booleans to alter some production of events. Usually, all false (no preservation of comments, processing instructions, DTDs, namespace declarations and its prefixes, and lexical values) makes no problem on XMPP communication. However, uploading a binary schema may require the schema encoded with preserved namespace prefixes. The prefixes are used in type definitions, and without prefix preservation binding between type definition references and actual definitions will be lost.

The selfContained option is a Boolean to enable self contained encoding of elements. Self contained element has no dependency to context (string table state in EXI processors) and can be copied to other context with the same grammar. However, self contained elements cannot use external string tables in EXI processors and may result larger size.

The datatypeRepresentationMap option can be used to modify how types encoded in EXI. If encoders and decoders have special encoding, it can be specified here. In most use cases in XMPP/EXI, this option will not be used.

The blockSize option specifies the block size used for EXI compression. It has no effect if compression is not used.

The valueMaxLength option specifies the maximum length of re-used string in a stream. Larger value makes more strings captured in string tables in EXI processors. This means more memory needs to be allocated to process a stream. Because some use cases, such as Internet of Things, expects constrained nodes in the network, default value specified in ths XEP is very small (64 characters).

The valuePartitionCapacity option specifies how many strings should be kept in a string table in a time. Default value of this is also small in this XEP (64 strings).

To control buffer and string table life time, this XEP adds a new option: sessionWideBuffers. If set to true, all buffers, string tables, etc. will be maintained during the entire session. This may improve performance during time since strings can be omitted in the compressed binary stream, but it might also in some cases degrade performance since more options are available in the tables, requiring more bits to encode strings. The default value is false, meaning that buffers, string tables, etc., are cleared between each stanza. (This option is EXI/XMPP specific.)

3.3 Transmission of EXI bodies and Session-wide Buffers

The transmission of EXI-compressed stanzas takes the form of a sequence of EXI bodies. In order for the recipient to be able to correctly interpret these incoming EXI bodies, the sender is required to flush any pending bits at the end of the last End Document (ED) event for each stanza and then send any pending bytes available in the output buffer. Since this makes sure each EXI body starts at an even byte boundary, it permits the recipient to decompress the body into an XML stanza.

Therefore, each stanza sent on the stream, must be compressed separately, reusing the same options as used by the stream. (Options are not sent on the stream, only the generated EXI bodies).

Compression of the stanza must be done in document mode, not fragment mode, including the Start Document (SD) and End Document (ED) events. If there are unwritten bits pending after the last End Document (ED) event (after the end of the stanza), Zero-bits are written until a byte boundary is created. The receptor must ignore bits in the last byte after the last End Document event has been received.

During setup of the EXI compression engine, the client can choose if buffers are to be reused between stanzas, or cleared between each stanza. This is done using the EXI over XMPP specific option sessionWideBuffers, which is false by default, meaning buffers and string tables are cleared between each stanza.

There may be cases where maintaining buffers and string tables throughout the session is preferrable. Since strings are already available in the buffers, they don't need to be output in the stream the first time they appear in a stanza. However, the number of strings in tables increase, and so does the number of bits required to encode them. Depending on what type of communication is performed, this option might give better results one way or another. If the same type of message is always sent, maintaining string buffers may be more efficient. But if the client sends many many different types of messages, clearing buffers may be more efficient.

Note that the stream of EXI bodies is indefinite. It only stops when the session is closed, i.e. when the socket connection is dropped. Therefore, the buffers can grow indefinitely unless control is maintained on what types of messages are sent, their contents (specifically string values), and to whom they are sent (JIDs being strings). All string tables and buffers must be cleared when a connection is lost.

Note also that if you want the option to enter a session in the middle of the flow to listen to the communication, you need to clear tables and buffers between each stanza, or you will not be able to decode the binary stream appropriately.

3.4 Preserving prefixes

Normally, prefixes are not preserved during EXI compression and decompression. If the communicating parties (sending client, XMPP server(s) and receiving clients) interpret incoming stanzas and content according to namespace, this should be sufficient. However, some implementations do not check namespaces, but prefix names used. In such cases, all communicating parties are required to enable the preserve prefixes option during negotionating.

Note: It is not sufficient that one party enable this option. Both sender and received are required to enable this option, or prefix names will be lost in the transmission.

Note also, that preserving prefix names result in less efficient compression. Therefore, all clients implementing EXI compression should strive to parse incoming XML based on namespace, not prefix name.

3.5 Networks containing clients having limited memory

To successfully implement a network with clients having limited memory, such as sensor networks, care should be taken to make sure necessary schema files are preinstalled on the server, to avoid the necessity to upload schema files from the clients. Clients with limited memory might be unable to perform this task.

An alternative may be to install a richer client, that can upload the schema files to the server dynamically, and installing it into the network. Any client uploading a schema file, will make that schema file available for EXI compression to any other client in the network.

3.6 Caching schema files

Schema files uploaded to the server should be cached on the server in some kind of schema repository. If memory is limited on the server, schema files should be sorted by last access. Schema files with the oldest last access timestamp could be removed to maintain the cache within an approved cache size.

Note that schema files have three keys: Target namespace, byte size and MD5 Hash. Multiple versions of a schema file may exist (that is, with the same target namespace but different byte sizes or MD5 hash codes). Note also, that for any practical purpose, schema files can be stored using only the MD5 hash as a key, since it is highly improbable that two different schema files will have the same MD5 hash (unless consciously created that way). MD5 hash values are always in lower case.

3.7 Uploading vs. Downloading schemas

When the server lacks information about a given XML schema, the client has two options for updating the server. Either it uploads the schema, or it asks the server to download one.

Uploading a schema has the advantage, that the client knows exactly the version that the server requires. It has the disadvantage, that the client needs to store the schema and send a possible large schema to the server. If EXI is used because the device has limited memory, uploading a schema might not be an option.

Downloading a schema has the advantage, that size of schema does not matter. The disadvantage is that asynchronous errors might occur, so the client needs to pay attention to the responses returned by the server when downloading schemas. Also, downloading a schema, might download a version which does not correspond to the desired version of the schema. So, it's more important in this case that the client checks that the server actually has the version of the schema required by the client.

3.8 Server decompression and recompression vs. binary forwarding

If two XMPP clients communicate with each other through an XMPP server, and both clients use EXI compression, the server must only forward binary packets if both EXI compressed channels have exactly the same setup. If any parameter is different, the server MUST always recompress packets sent through it.

Since the server always needs to decompress incoming EXI compressed packets to decode headers, omitting the compression part might save the server some processing power, but not all. Note that, in some networks it might be common using similar compression settings, while in others different compression settings are most common.

Also note that binary forwarding is only possible if session-wide buffers are not used.

3.9 Snapshot Repository for Well-known Schemas

Errata and other updates may happen to well-known schemas. Slightest modification to XML schemas may break interoperability of EXI nodes. However, negotiating everything is not efficient. Well-known and aged schemas that referred from the schema for EXI/XMPP shall be snapshoted for use in EXI processors.

Actual snapshot is located in (TBD-URL).

3.10 Generation of Canonic Schemas

The interface between the XMPP engine, whether in the client or the server, and the EXI compression engine is required to provide the engine with ONE XML Schema to use during the compression. The Efficient XML Interchange (EXI) Format also specifies the use of Schema IDs identifying the schema to use.

However, in the XMPP case, the schema to provide to the EXI compression engine must be created dynamically based on the handshake provided during setup of the connection. Since this generation must be done both on the server side as well as the client side, it is important that the schemas be created semantically equivalent. This section describes how to create such schemas, henceforth called Canonical Schemas is described in this section.

A canonical schema is simply a wrapper importing each of the schemas negotiated for the connection. The schemas MUST be imported in ascending namespace order.

After generating the canonical schema, it's a good idea to create a corresponding Configuration ID. The Configuration ID however, includes not only the schemas imported into the canonical schema, but also the EXI options to use during compression/decompression. The canonical schema should be persisted for simple reuse when quick setup is used.

The target namespace of the canonical schema MUST be urn:xmpp:exi:cs.

The Schema ID to use is irrelevant in the XMPP layer of communiction. Therefore, the server and client can create their own Schema IDs, according to some algorithm. It is not important if the Schema IDs match, since they are not used in data transmitted between the client and server.

3.11 Using EXI Option Documents for Shortcut Setup

The configurationId attribute has a similar attribute called configurationLocation. This attribute provides a mechanism to setup an EXI connection rapidly using option documents installed as files on the server or available on the network accessible through an URL.

A client may specify a configurationId or configurationLocation on exi:setup element. If the server has corresponding setup configuration, the server may respond with an exi:setupResponse with agreement="true". If the server does not know the configurationId or does not be able to use the given configurationLocation, the server shall respond with an exi:setupResponse with agreement="false".

This specification does not define the format of this Configuration Location attribute, and so it is server specific, or if it is supported. If used on a server not supporting this attribute, or if the contents of the attribute is invalid, the server returns an agreement=false response. Otherwise the semantics of the configurationLocation attribute is the same as for the configurationId attribute, except it provide a mechism for static configurations, while the configurationId provides a mechanism for dynamic configurations.

The format for these opton documents or locations is beyond the scope of this specification.

The format for these opton documents or locations is beyond the scope of this specification.

3.12 XMPP Schema files and their hash values

The following table lists XMPP schemas at the time of writing, and their corresponding bytes sizes and MD5 Hash values.

3.13 Known problems with existing schemas

The following sections list some known problems that might affect already defined schemas. For these schemas to be used together with EXI compression, the recommended procedures should be considered. If changes to the schema is required, new byte sizes and hash values must be computed for the changed schema correspondingly.

Patched version of XML schemas may be placed in the snapshot repository for well-known schemas to avoid wild patches (and too many derived schema for the same model).

          --- streams.xsd    2013-03-25 17:37:52.733451313 +0900
          +++ streams-UPA-patched.xsd    2013-03-25 17:57:44.889469868 +0900
          @@ -32,10 +32,12 @@
          <xs:any namespace='urn:ietf:params:xml:ns:xmpp-sasl'
          minOccurs='0'
          maxOccurs='1'/>
          +        <xs:element name="delim" type="xs:boolean" minOccurs="1" maxOccurs="1" />
          <xs:any namespace='##other'
          minOccurs='0'
          maxOccurs='unbounded'
          processContents='lax'/>
          +        <xs:element name="delim" type="xs:boolean" minOccurs="1" maxOccurs="1" />
          <xs:choice minOccurs='0' maxOccurs='1'>
          <xs:choice minOccurs='0' maxOccurs='unbounded'>
          <xs:element ref='client:message'/>
          @@ -77,6 +79,7 @@
          <xs:element ref='err:text'
          minOccurs='0'
          maxOccurs='1'/>
          +        <xs:element name="delim" type="xs:boolean" minOccurs="1" maxOccurs="1" />
          <xs:any     namespace='##other'
          minOccurs='0'
          maxOccurs='1'
        

3.14 Default schema for alternative bindings

Default EXI grammar used in EXI/XMPP SHALL be equivalent to the EXI grammar defined by the following schema. The default EXI grammar is used in initiating connection of EXI/XMPP alternate binding. The default schema is defined by following definition, and all the imported schemas SHOULD be same schemas described in the snapshot and SHOULD have the identical MD5 hash value described in this section.

        
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema
 xmlns:xs="http://www.w3.org/2001/XMLSchema"
 xmlns:stream="http://etherx.jabber.org/streams"
 targetNamespace="urn:xmpp:exi:cs"
 elementFormDefault="qualified">
 <xs:import namespace="http://etherx.jabber.org/streams"
            schemaLocation="${snapshot_url}/streams.xsd" />
 <xs:import namespace="http://jabber.org/protocol/compress/exi"
            schemaLocation="${snapshot_url}/xep-0322-01.xsd" />
</xs:schema>

      

The ${snapshot-url} corresponds to yet-to-be-specified schema snapshot repository described in snapshot repository for well-known schemas section. The schemaId of this schema will is 'urn:xmpp:exi:default'. SchemaId is ID for this instance and not a namespace identifier and intentionally different from the target namespace of the schema.

3.15 Reserved Schema IDs

• Schema IDs starts with "c:". This is used as shortcut setup for alternative transport binding.
• Schema IDs starts with "urn:xmpp". This may be used to describe XEP-based schemas.

      
      
<?xml version='1.0' encoding='UTF-8'?>
<xs:schema
    xmlns:xs='http://www.w3.org/2001/XMLSchema'
    targetNamespace='http://jabber.org/protocol/compress/exi'
    xmlns='http://jabber.org/protocol/compress/exi'
    xmlns:xml="http://www.w3.org/XML/1998/namespace"
    xmlns:client='jabber:client'
    xmlns:streams='http://etherx.jabber.org/streams'
    elementFormDefault='qualified'>

    <xs:import namespace="http://www.w3.org/XML/1998/namespace"/>
    <xs:import namespace="http://etherx.jabber.org/streams"/>

    <xs:element name='setup' type='Setup'/>
    <xs:element name='setupResponse' type='SetupResponse'/>

    <xs:complexType name='Setup'>
        <xs:choice minOccurs='0' maxOccurs='unbounded'>
            <xs:element name='schema' type='Schema'/>
            <xs:element name='datatypeRepresentationMap' type='DatatypeRepresentationMap'/>
        </xs:choice>
        <xs:attributeGroup ref='Options'/>
    <xs:attribute name='configurationId' type='xs:string' use='optional'/>
    <xs:attribute name='configurationLocation' type='xs:string' use='optional'/>
    </xs:complexType>

    <xs:complexType name='SetupResponse'>
        <xs:choice minOccurs='0' maxOccurs='unbounded'>
            <xs:element name='schema' type='Schema'/>
            <xs:element name='datatypeRepresentationMap' type='DatatypeRepresentationMap'/>
        <xs:element name='missingSchema' type='Schema'/>
        </xs:choice>
        <xs:attributeGroup ref='Options'/>
    <xs:attribute name='configurationId' type='xs:string' use='optional'/>
    <xs:attribute name='configurationLocation' type='xs:string' use='optional'/>
    <xs:attribute name='agreement' type='xs:boolean' use='optional' default='false'/>
    </xs:complexType>

    <xs:complexType name='Schema'>
        <xs:attribute name='ns' type='xs:string' use='required'/>
        <xs:attribute name='bytes' type='xs:positiveInteger' use='required'/>
        <xs:attribute name='md5Hash' type='MD5Hash' use='required'/>
    </xs:complexType>

    <xs:complexType name='DatatypeRepresentationMap'>
        <xs:attribute name='type' type='xs:string' use='required'/>
        <xs:attribute name='representAs' type='xs:string' use='required'/>
    </xs:complexType>

    <xs:attributeGroup name='Options'>
        <xs:attribute name='version' type='xs:positiveInteger' use='optional' default='1'/>
        <xs:attribute name='alignment' type='Alignment' use='optional' default='bit-packed'>
            <xs:annotation>
                <xs:documentation>The alignment option is used to control the alignment of event codes and content items. The value is one of bit-packed, byte-alignment or pre-compression, of which bit-packed is the default value assumed when the "alignment" element is absent in the EXI Options document. The option values byte-alignment and pre-compression are effected when "byte" and "pre-compress" elements are present in the EXI Options document, respectively. When the value of compression option is set to true, alignment of the EXI Body is governed by the rules specified in 9. EXI Compression instead of the alignment option value. The "alignment" element MUST NOT appear in an EXI options document when the "compression" element is present.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='compression' type='xs:boolean' use='optional' default='false'>
            <xs:annotation>
                <xs:documentation>The compression option is a Boolean used to increase compactness using additional computational resources. The default value "false" is assumed when the "compression" element is absent in the EXI Options document whereas its presence denotes the value "true". When set to true, the event codes and associated content are compressed according to 9. EXI Compression regardless of the alignment option value. As mentioned above, the "compression" element MUST NOT appear in an EXI options document when the "alignment" element is present.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='strict' type='xs:boolean' use='optional' default='false'>
            <xs:annotation>
                <xs:documentation>The strict option is a Boolean used to increase compactness by using a strict interpretation of the schemas and omitting preservation of certain items, such as comments, processing instructions and namespace prefixes. The default value "false" is assumed when the "strict" element is absent in the EXI Options document whereas its presence denotes the value "true". When set to true, those productions that have NS, CM, PI, ER, and SC terminal symbols are omitted from the EXI grammars, and schema-informed element and type grammars are restricted to only permit items declared in the schemas. A note in section 8.5.4.4.2 Adding Productions when Strict is True describes some additional restrictions consequential of the use of this option. The "strict" element MUST NOT appear in an EXI options document when one of "dtd", "prefixes", "comments", "pis" or "selfContained" element is present in the same options document.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='preserveComments' type='xs:boolean' use='optional' default='false'>
            <xs:annotation>
                <xs:documentation>Comments are preserved. Must not be used together with the strict option.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='preservePIs' type='xs:boolean' use='optional' default='false'>
            <xs:annotation>
                <xs:documentation>Processing instructions are preserved. Must not be used together with the strict option.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='preserveDTD' type='xs:boolean' use='optional' default='false'>
            <xs:annotation>
                <xs:documentation>DTD is preserved. Must not be used together with the strict option.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='preservePrefixes' type='xs:boolean' use='optional' default='false'>
            <xs:annotation>
                <xs:documentation>Prefixes are preserved. Must not be used together with the strict option.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='preserveLexical' type='xs:boolean' use='optional' default='false'>
            <xs:annotation>
                <xs:documentation>Lexical form of element and attribute values can be preserved in value content items. Can be used together with the strict option.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='selfContained' type='xs:boolean' use='optional' default='false'>
            <xs:annotation>
                <xs:documentation>The selfContained option is a Boolean used to enable the use of self-contained elements in the EXI stream. Self-contained elements may be read independently from the rest of the EXI body, allowing them to be indexed for random access. The "selfContained" element MUST NOT appear in an EXI options document when one of "compression", "pre-compression" or "strict" elements are present in the same options document. The default value "false" is assumed when the "selfContained" element is absent from the EXI Options document whereas its presence denotes the value "true".</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='blockSize' type='xs:positiveInteger' use='optional' default='1000000'>
            <xs:annotation>
                <xs:documentation>The blockSize option specifies the block size used for EXI compression. When the "blockSize" element is absent in the EXI Options document, the default blocksize of 1,000,000 is used. The default blockSize is intentionally large but can be reduced for processing large documents on devices with limited memory.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='valueMaxLength' type='xs:positiveInteger' use='optional'>
            <xs:annotation>
                <xs:documentation>The valueMaxLength option specifies the maximum length of value content items to be considered for addition to the string table. The default value "unbounded" is assumed when the "valueMaxLength" element is absent in the EXI Options document.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
        <xs:attribute name='valuePartitionCapacity' type='xs:positiveInteger' use='optional'>
            <xs:annotation>
                <xs:documentation>The valuePartitionCapacity option specifies the maximum number of value content items in the string table at any given time. The default value "unbounded" is assumed when the "valuePartitionCapacity" element is absent in the EXI Options document. Section 7.3.3 Partitions Optimized for Frequent use of String Literals specifies the behavior of the string table when this capacity is reached.</xs:documentation>
            </xs:annotation>
        </xs:attribute>
    <xs:attribute name='sessionWideBuffers' type='xs:boolean' use='optional' default='false'>
        <xs:annotation>
        <xs:documentation>If set to true, all buffers, string tables, etc. will be maintained during the entire session. This may improve performance during time since strings
        can be omitted in the compressed binary stream, but it might also in some cases degrade performance since more options are available in the tables, requiring more bits
        to encode strings. The default value is false, meaning that buffers, string tables, etc., are cleared between each stanza.</xs:documentation>
        </xs:annotation>
    </xs:attribute>
    </xs:attributeGroup>

    <xs:simpleType name='MD5Hash'>
        <xs:restriction base='xs:string'>
            <xs:pattern value='[0-9a-f]{32}'/>
        </xs:restriction>
    </xs:simpleType>

    <xs:simpleType name='Alignment'>
        <xs:restriction base='xs:string'>
            <xs:enumeration value='bit-packed'>
                <xs:annotation>
                    <xs:documentation>The alignment option value bit-packed indicates that the event codes and associated content are packed in bits without any padding in-between.</xs:documentation>
                </xs:annotation>
            </xs:enumeration>
            <xs:enumeration value='byte-alignment'>
                <xs:annotation>
                    <xs:documentation>The alignment option value byte-alignment indicates that the event codes and associated content are aligned on byte boundaries. While byte-alignment generally results in EXI streams of larger sizes compared with their bit-packed equivalents, byte-alignment may provide a help in some use cases that involve frequent copying of large arrays of scalar data directly out of the stream. It can also make it possible to work with data in-place and can make it easier to debug encoded data by allowing items on aligned boundaries to be easily located in the stream.</xs:documentation>
                </xs:annotation>
            </xs:enumeration>
            <xs:enumeration value='pre-compression'>
                <xs:annotation>
                    <xs:documentation>The alignment option value pre-compression indicates that all steps involved in compression (see section 9. EXI Compression) are to be done with the exception of the final step of applying the DEFLATE algorithm. The primary use case of pre-compression is to avoid a duplicate compression step when compression capability is built into the transport protocol. In this case, pre-compression just prepares the stream for later compression.</xs:documentation>
                </xs:annotation>
            </xs:enumeration>
        </xs:restriction>
    </xs:simpleType>

    <xs:element name='uploadSchema'>
    <xs:complexType>
        <xs:simpleContent>
        <xs:extension base='xs:base64Binary'>
            <xs:attribute name='contentType' type='ContentType' use='optional' default='Text'/>
            <xs:attribute name='bytes' type='xs:positiveInteger' use='optional'/>
            <xs:attribute name='md5Hash' type='MD5Hash' use='optional'/>
        </xs:extension>
        </xs:simpleContent>
    </xs:complexType>
    </xs:element>

    <xs:simpleType name='ContentType'>
    <xs:restriction base='xs:string'>
        <xs:enumeration value='Text'/>
        <xs:enumeration value='ExiBody'/>
        <xs:enumeration value='ExiDocument'/>
    </xs:restriction>
    </xs:simpleType>

    <xs:element name='downloadSchema' type='DownloadSchema'/>
    <xs:element name='downloadSchemaResponse' type='DownloadSchemaResponse'/>

    <xs:complexType name='DownloadSchema'>
        <xs:attribute name='url' type='xs:string' use='required'/>
    </xs:complexType>

    <xs:complexType name='DownloadSchemaResponse'>
        <xs:complexContent>
            <xs:extension base='DownloadSchema'>
        <xs:choice minOccurs='0' maxOccurs='1'>
            <xs:element name='httpError'>
            <xs:complexType>
                <xs:attribute name='code' type='xs:positiveInteger' use='required'/>
                <xs:attribute name='message' type='xs:string' use='required'/>
            </xs:complexType>
            </xs:element>
            <xs:element name='invalidUrl'>
            <xs:complexType>
                <xs:attribute name='message' type='xs:string' use='required'/>
            </xs:complexType>
            </xs:element>
            <xs:element name='timeout'>
            <xs:complexType>
                <xs:attribute name='message' type='xs:string' use='required'/>
            </xs:complexType>
            </xs:element>
            <xs:element name='invalidContentType'>
            <xs:complexType>
                <xs:attribute name='contentTypeReturned' type='xs:string' use='required'/>
            </xs:complexType>
            </xs:element>
            <xs:element name='error'>
            <xs:complexType>
                <xs:attribute name='message' type='xs:string' use='required'/>
            </xs:complexType>
            </xs:element>
        </xs:choice>
                <xs:attribute name='result' type='xs:boolean' use='required'/>
            </xs:extension>
        </xs:complexContent>
    </xs:complexType>

    <xs:element name='streamStart'>
    <xs:complexType>
        <xs:sequence>
        <xs:element name='xmlns' minOccurs='0' maxOccurs='unbounded'>
            <xs:complexType>
            <xs:attribute name='prefix' type='xs:string' use='required'/>
            <xs:attribute name='namespace' type='xs:string' use='required'/>
            </xs:complexType>
        </xs:element>
        <xs:element ref='streams:features'
                minOccurs='0'
                maxOccurs='1'/>
        <xs:any namespace='urn:ietf:params:xml:ns:xmpp-tls'
            minOccurs='0'
            maxOccurs='1'/>
        <xs:any namespace='urn:ietf:params:xml:ns:xmpp-sasl'
            minOccurs='0'
            maxOccurs='1'/>
        <xs:element ref='streams:error' minOccurs='0' maxOccurs='1'/>
        </xs:sequence>
        <xs:attribute name='from' type='xs:string' use='optional'/>
        <xs:attribute name='id' type='xs:string' use='optional'/>
        <xs:attribute name='to' type='xs:string' use='optional'/>
        <xs:attribute name='version' type='xs:decimal' use='optional'/>
        <xs:attribute ref='xml:lang' use='optional'/>
        <xs:anyAttribute namespace='##other' processContents='lax'/>
    </xs:complexType>
    </xs:element>

    <xs:element name='streamEnd'>
    <xs:complexType/>
    </xs:element>

</xs:schema>

    

Peter Waher

Email: peter.waher@clayster.com
JabberID: peter.waher@jabber.org
URI: http://www.linkedin.com/in/peterwaher

Yusuke DOI

Email: yusuke.doi@toshiba.co.jp
JabberID: yusuke.doi@gmail.com
URI: http://www.linkedin.com/in/yusukedoi

Copyright

Permissions

Disclaimer of Warranty

Limitation of Liability

IPR Conformance

1. Efficient XML Interchange (EXI) Format <http://www.w3.org/TR/exi/>.

2. XEP-0138: Stream Compression <http://xmpp.org/extensions/xep-0138.html>.

3. RFC 6120: Extensible Messaging and Presence Protocol (XMPP): Core <http://tools.ietf.org/html/rfc6120>.

Version 0.4 (2014-03-10)

Version 0.3 (2013-07-19)

Version 0.2 (2013-06-27)

Version 0.1 (2013-04-16)

Version 0.0.4 (2013-03-19)

Version 0.0.3 (2013-03-15)

Version 0.0.2 (2013-03-13)

Version 0.0.1 (2013-03-12)