<p>Element renamed from <strong>Friend</strong> to <strong>friend</strong> when recommending friendships.</p>
<p><strong>clearCache</strong> IQ stanzas now of type <strong>set</strong> instead of <strong>get</strong>.</p>
<p>Corrected schema with regards to tokens.</p>
<p>The <strong>getToken</strong> command now takes a base-64 encoded X.509 certificate (public part) instead of arbitrary string IDs.</p>
<p>An additional challenge/response step has been added to make sure the sender of a certificate has access to the private part of the certificate.</p>
<p>Named links to all sections in the document.</p>
<p>Added reference to XEP-0347, for how things can find provisioning servers.</p>
<p>Added method of finding provisioning server, if server hosted as a server component.</p>
<p>Updated examples to reflect a provisioning server hosted as a server component, harmonizing with XEP-0347.</p>
<p>Added a section about token challenges and token propagation.</p>
<p>Added a security note regarding token challenges.</p>
<p>Updated id-attributes in examples.</p>
</remark>
</revision>
<revision>
<version>0.2</version>
<date>2014-03-10</date>
<initials>pw</initials>
<remark>
<p>Corrected downloadPrivileges example.</p>
<p>Made several corrections of the language.</p>
<p>Expanded the introduction.</p>
<p>Changes "Sensor Networks" to "Internet of Things".</p>
<p>Fixed links to documents with new numbers.</p>
<p>Changed namespace urn:xmpp:sn to urn:xmpp:iot</p>
</remark>
</revision>
<revision>
<version>0.1</version>
<date>2013-04-16</date>
<initials>psa</initials>
<remark>
<p>Initial published version approved by the XMPP Council.</p>
</remark>
</revision>
<revision>
<version>0.0.5</version>
<date>2013-04-04</date>
<initials>pw</initials>
<remark>
<p>Added control use cases.</p>
<p>Grouped use cases.</p>
</remark>
</revision>
<revision>
<version>0.0.4</version>
<date>2013-04-01</date>
<initials>pw</initials>
<remark>
<p>Added altitude credentials.</p>
<p>Added resource information of original called to their corresponding JIDs.</p>
<p>Changed the return type of a rejected message.</p>
<p>Made images inline.</p>
<p>Converted the glossary into a definition list.</p>
</remark>
</revision>
<revision>
<version>0.0.3</version>
<date>2013-03-18</date>
<initials>pw</initials>
<remark>
<p>Added information about how to read sensors from large subsystems.</p>
<p>Added friend recommendation message.</p>
<p>Added client/device/service tokens.</p>
</remark>
</revision>
<revision>
<version>0.0.2</version>
<date>2013-03-12</date>
<initials>pw</initials>
<remark>
<p>Added use cases for service access rights and corresponding user privileges.</p>
</remark>
</revision>
<revision>
<version>0.0.1</version>
<date>2013-03-11</date>
<initials>pw</initials>
<remark>
<p>First draft.</p>
</remark>
</revision>
</header>
<section1topic='Introduction'anchor='intro'>
<p>
This specification describes an architecture for efficient provisioning of services, access rights and user privileges in for the Internet of Things, where
communication between Things is done using the XMPP protocol.
</p>
<p>
Note has to be taken, that this XEP, and other Internet of Things-related XEP's, are designed for implementation in small devices, many of which have very limited
amount of memory (both RAM and ROM) or resources (processing power). Therefore, simplicity is of utmost importance. Furthermore, Internet of Things networks can
become huge, easily containing millions or billions of devices in peer-to-peer networks.
</p>
<p>
An added complexity in the provisioning case is that Things (small sensors for example) often have very limited user interface options. Therefore, this document
explains how provisioning can be done efficiently using a trusted third party with more power and options when it comes to user interface design and storage.
</p>
<p>
This document defines the following important operations to allow for efficient provisioning of services in the Internet of Things, based on XMPP:
</p>
<ul>
<li>What Things knows what Things</li>
<li>What Things can read data from what Things, and what data.</li>
<li>What Things can control what Things, and what parts.</li>
<li>Control of Users in the network.</li>
<li>Control of Services in the network.</li>
<li>Control generic boolean User Privileges in the network.</li>
</ul>
<p>
This XEP relies on &xep0323; and &xep0325; for sensor data readout and control interfaces. It relies on &xep0326; for bridging protocols and interfaing entities with multiple devices
behind them. It also ties into &xep0347; for automatic discovery of provisioning servers by things.
</p>
<p>
Internet of Things contain many different architectures and use cases. For this reason, the IoT standards have been divided into multiple XEPs according to the following table:
</p>
<tablecaption='Internet of Things XEPs'>
<tr>
<th>XEP</th>
<th>Description</th>
</tr>
<tr>
<td>xep-0000-IoT-BatteryPoweredSensors</td>
<td>Defines how to handle the peculiars related to battery powered devices, and other devices intermittently available on the network.</td>
</tr>
<tr>
<td>xep-0000-IoT-Events</td>
<td>Defines how Things send events, how event subscription, hysteresis levels, etc., are configured.</td>
</tr>
<tr>
<td>xep-0000-IoT-Interoperability</td>
<td>Defines guidelines for how to achieve interoperability in Internet of Things, publishing interoperability interfaces for different types of devices.</td>
</tr>
<tr>
<td>xep-0000-IoT-Multicast</td>
<td>Defines how sensor data can be multicast in efficient ways.</td>
</tr>
<tr>
<td>xep-0000-IoT-PubSub</td>
<td>Defines how efficient publication of sensor data can be made in Internet of Things.</td>
</tr>
<tr>
<td>xep-0000-IoT-Chat</td>
<td>Defines how human-to-machine interfaces should be constructed using chat messages to be user friendly, automatable and consistent with other IoT extensions and possible underlying architecture.</td>
</tr>
<tr>
<td>XEP-0322</td>
<td>
Defines how to EXI can be used in XMPP to achieve efficient compression of data. Albeit not an Internet of Things specific XEP, this XEP should be considered
in all Internet of Things implementations where memory and packet size is an issue.
</td>
</tr>
<tr>
<td>XEP-0323</td>
<td>
Provides the underlying architecture, basic operations and data structures for sensor data communication over XMPP networks.
It includes a hardware abstraction model, removing any technical detail implemented in underlying technologies. This XEP is used by all other
Internet of Things XEPs.
</td>
</tr>
<tr>
<td>XEP-0324</td>
<td>This specification. Defines how provisioning, the management of access privileges, etc., can be efficiently and easily implemented.</td>
</tr>
<tr>
<td>XEP-0325</td>
<td>Defines how to control actuators and other devices in Internet of Things.</td>
</tr>
<tr>
<td>XEP-0326</td>
<td>Defines how to handle architectures containing concentrators or servers handling multiple Things.</td>
</tr>
<tr>
<td>XEP-0331</td>
<td>Defines extensions for how color parameters can be handled, based on &xep0004;</td>
</tr>
<tr>
<td>XEP-0336</td>
<td>Defines extensions for how dynamic forms can be created, based on &xep0004;, &xep0122;, &xep0137; and &xep0141;.</td>
</tr>
<tr>
<td>XEP-0347</td>
<td>Defines the peculiars of sensor discovery in sensor networks. Apart from discovering sensors by JID, it also defines how to discover sensors based on location, etc.</td>
</tr>
</table>
</section1>
<section1topic='Glossary'anchor='glossary'>
<p>The following table lists common terms and corresponding descriptions.</p>
<dl>
<di>
<dt>Actuator</dt>
<dd>Device containing at least one configurable property or output that can and should be controlled by some other entity or device.</dd>
</di>
<di>
<dt>Authority</dt>
<dd>Used synonymously with Provisioning Server.</dd>
</di>
<di>
<dt>Computed Value</dt>
<dd>A value that is computed instead of measured.</dd>
</di>
<di>
<dt>Concentrator</dt>
<dd>Device managing a set of devices which it publishes on the XMPP network.</dd>
</di>
<di>
<dt>Field</dt>
<dd>
One item of sensor data. Contains information about: Node, Field Name, Value, Precision, Unit, Value Type, Status, Timestamp, Localization information, etc.
Fields should be unique within the triple (Node ID, Field Name, Timestamp).
</dd>
</di>
<di>
<dt>Field Name</dt>
<dd>Name of a field of sensor data. Examples: Energy, Volume, Flow, Power, etc.</dd>
</di>
<di>
<dt>Field Type</dt>
<dd>What type of value the field represents. Examples: Momentary Value, Status Value, Identification Value, Calculated Value, Peak Value, Historical Value, etc.</dd>
</di>
<di>
<dt>Historical Value</dt>
<dd>A value stored in memory from a previous timestamp.</dd>
</di>
<di>
<dt>Identification Value</dt>
<dd>A value that can be used for identification. (Serial numbers, meter IDs, locations, names, etc.)</dd>
</di>
<di>
<dt>Localization information</dt>
<dd>Optional information for a field, allowing the sensor to control how the information should be presented to human viewers.</dd>
</di>
<di>
<dt>Meter</dt>
<dd>A device possible containing multiple sensors, used in metering applications. Examples: Electricity meter, Water Meter, Heat Meter, Cooling Meter, etc.</dd>
</di>
<di>
<dt>Momentary Value</dt>
<dd>A momentary value represents a value measured at the time of the read-out.</dd>
</di>
<di>
<dt>Node</dt>
<dd>
Graphs contain nodes and edges between nodes. In Internet of Things, sensors, actuators, meters, devices, gateways, etc., are often depicted as nodes whereas links between sensors (friendships)
are depicted as edges. In abstract terms, it's easier to talk about a Node, rather than list different possible node types (sensors, actuators, meters, devices, gateways, etc.).
Each Node has a Node ID.
</dd>
</di>
<di>
<dt>Node ID</dt>
<dd>
An ID uniquely identifying a node within its corresponding context. If a globally unique ID is desired, an architecture should be used using a universally accepted
ID scheme.
</dd>
</di>
<di>
<dt>Parameter</dt>
<dd>
Readable and/or writable property on a node/device. The XEP-0326 &xep0326; deals with reading and writing parameters
on nodes/devices. Fields are not parameters, and parameters are not fields.
</dd>
</di>
<di>
<dt>Peak Value</dt>
<dd>A maximum or minimum value during a given period.</dd>
</di>
<di>
<dt>Provisioning Server</dt>
<dd>An application that can configure a network and provide services to users or Things. In Internet of Things, a Provisioning Server knows who knows whom,
what privileges users have, who can read what data and who can control what devices and what parts of these devices.</dd>
</di>
<di>
<dt>Precision</dt>
<dd>
In physics, precision determines the number of digits of precision. In sensor networks however, this definition is not easily applicable. Instead, precision
determines, for example, the number of decimals of precision, or power of precision. Example: 123.200 MWh contains 3 decimals of precision. All entities parsing and
delivering field information in sensor networks should always retain the number of decimals in a message.
</dd>
</di>
<di>
<dt>Sensor</dt>
<dd>
Device measuring at least one digital value (0 or 1) or analog value (value with precision and physical unit). Examples: Temperature sensor, pressure sensor, etc.
Sensor values are reported as fields during read-out. Each sensor has a unique Node ID.
</dd>
</di>
<di>
<dt>SN</dt>
<dd>Sensor Network. A network consisting, but not limited to sensors, where transport and use of sensor data is of primary concern. A sensor network may contain actuators, network applications, monitors, services, etc.</dd>
</di>
<di>
<dt>Status Value</dt>
<dd>A value displaying status information about something.</dd>
</di>
<di>
<dt>Timestamp</dt>
<dd>Timestamp of value, when the value was sampled or recorded.</dd>
</di>
<di>
<dt>Thing</dt>
<dd>
Internet of Things basically consists of Things connected to the Internet. Things can be any device, sensor, actuator etc., that can have an
Internet connection.
</dd>
</di>
<di>
<dt>Thing Registry</dt>
<dd>
A registry where Things can register for simple and secure discovery by the owner of the Thing. The registry can also be used as a database for meta information
about Things in the network.
</dd>
</di>
<di>
<dt>Token</dt>
<dd>
A client, device or user can get a token from a provisioning server. These tokens can be included in requests to other entities in the network, so these entities can validate
access rights with the provisioning server.
</dd>
</di>
<di>
<dt>Unit</dt>
<dd>Physical unit of value. Example: MWh, l/s, etc.</dd>
</di>
<di>
<dt>Value</dt>
<dd>A field value.</dd>
</di>
<di>
<dt>Value Status</dt>
<dd>Status of field value. Contains important status information for Quality of Service purposes. Examples: Ok, Error, Warning, Time Shifted, Missing, Signed, etc.</dd>
</di>
<di>
<dt>Value Type</dt>
<dd>Can be numeric, string, boolean, Date & Time, Time Span or Enumeration.</dd>
</di>
<di>
<dt>WSN</dt>
<dd>Wireless Sensor Network, a sensor network including wireless devices.</dd>
</di>
<di>
<dt>XMPP Client</dt>
<dd>Application connected to an XMPP network, having a JID. Note that sensors, as well as applications requesting sensor data can be XMPP clients.</dd>
</di>
</dl>
</section1>
<section1topic='Use Cases'anchor='usecases'>
<p>
The most basic use case in sensor networks is to read out sensor data from a sensor. However, since protecting end-user integrity and system security is vital, access
rights and user privileges have to be imposed on the network.
</p>
<p>
To store access rights in all sensors might be very impractical. Not only does it consume memory, it's difficult to maintain track of the current system status, make sure
all devices have the latest configuration, distribute changes to the configuration, etc.
</p>
<p>
Furthermore, most sensors and small devices have very limited possibility to provide a rich user interface. Perhaps all it can do is to provide a small LED and a button,
useful perhaps for installing the sensor in the network, but not much more.
</p>
<p>
As an added complexity, the sensor network operator might not even have access to the XMPP Servers used, and provisioning needs to lie outside of the XMPP Server domains.
</p>
<p>
To solve this problem in an efficient manner, an architecture using distributed trusted third parties is proposed. Such third parties would:
</p>
<ul>
<li>Provide a rich user interface and configurable options to end user or back end systems.</li>
<li>Control friendships (who can communicate with whom).</li>
<li>Control content available for different friends (what can be read by whom).</li>
<li>Control operations accessible by different friends (what can be controlled/configured by whom).</li>
<li>Provide additional interoperability services to nodes in the network (for instance, unit conversion).</li>
<section3topic='Delegating original trust to a Provisioning Server'anchor='delegatingoriginaltrust'>
<p>
A provisioning server can be accessed either through a JID published by the provisioning server, or through a subdomain address, if hosted as a server component.
This section will show how to delegate original trust to a Provisioning Server, in the case the server uses a JID to communicate with things.
</p>
<p>
Trust is delegated to a provisioning server by a device, simply by befriending the provisioning server and asking it questions and complying with
its answers. As an illustrative example, following is a short description of how such a trust relationship can be created in a scenario where the sensor only
<li>Somebody is installing the sensor, giving it a connection to an XMPP server and a JID, reachable from the provisioning server.</li>
<li>The provisioning server is told to create a friendship request to the new sensor.</li>
<li>The sensor flashes its LED for a given time (for example: 30 seconds).</li>
<li>Viewing the LED, the person installing the sensor presses the button.</li>
<li>Receiving the button press within the given time period, accepts the friendship request. Optionally, the device can give user feedback using the LED.</li>
<li>The device performs a service discovery of the new friend, having been a manually added friend.</li>
<li>If the new friend supports this provisioning extension, further responsibilities are delegated to this device.</li>
<li>As the last step the device asks the provisioning server for a token. This device token is later used in calls to other devices and can be used to check access rights.</li>
<strong>Note:</strong> In many cases, an address to a provisioning server might be preprogrammed during production of the
device. In these cases, parts of the above procedure may not be necessary. All the client needs to do, if the provisioning server is not available
in the roster of the device, is to send a subscription request to the provisioning server, to alert the server of the existence of the device,
and possibly request a device token.
</p>
<p>
<strong>Note 2:</strong> A certificate token has an undefined lifetime. It can be reused across sessions.
</p>
<p>
The following use cases will assume such a trust relationship has been created between the corresponding device and the provisioning server.
</p>
</section3>
<section3topic='Provisioning Server as a server component'anchor='servercomponent'>
<p>
A provisioning server can also be hosted as a server component, and in these cases be addressed by using the component address, or sub-domain address of the component.
In this case, the client searches through the components hosted by the server to see if one of them is a Provisioning Server. There are no friendship requests and
presence subscriptions necessary, when communicating with a Provisioning Server hosted as a server component.
</p>
<p>
To search for a Provisioning Server hosted as a component on an XMPP Server, you first request a list of available components, as follows:
</p>
<examplecaption="Checking if server supports components">
<section3topic="Tokens and X.509 Certificates"anchor="tokenscertificats">
<p>
The provisioning server contains a set of rules defining what operation can take place and by whom, by participants in the network. Rules can be applied based on JIDs used,
content affected, and also through device, service and user identities based on X.509 Certificates. In order for a service (for instance) to identify itself in the network, it
uses an X.509 certificate. It sends the public part of this certificate to the provisioning server, and receives a token back in the form of a simple string. This token can then
be used in requests and propagated through the network.
</p>
<p>
To validate that the sender is allowed to use the certificate using its token, it encrypts a challenge using the public part of the certificate and sends it to the sender of the
token, who in turn decrypts it using the private part of the certificate and returns it to the server. The provisioning server can also use the public part of the certificate to
perform validation checks on the certificate itself. If the certificate becomes invalid, the provisioning server can invalidate any corresponding rules in the network. If the sender
of a token cannot respond to a token challenge, the provisioning server can also refuse to allow the operation.
</p>
<p>
In case of multiple units being part of an operation, a token can be propagated in the network. For example, a service can read data from U1, who reads data from U2. The service
provides a token to U1, who propagates this token in the request to U2. When U2 asks the provisioning server if the operation should be allowed or not, the server knows what entity
originated the request. If the provisioning server wants to challenge U2, concerning the token, U2 propagates the challenge to U1, who propagates it to the service, who can resolve
the challenge, returns the response back to U1 who returns the response to U2 who in turn returns it to the provisioning server.
<section4topic='Requesting a token'anchor='requesttoken'>
<p>
The following example shows how a device or service can request a token from the provisioning server, by providing the base-64 encoded public part of an X.509 certificate.
This step is optional, but can be used as a method to identify the device (or service), apart from the JID it is using. This might be useful if you want to assign a particular
device or service privileges in the provisioning server, regardless of the JID it uses to perform the action.
The <strong>getToken</strong> element contains the base-64 encoded public version of the certificate that is used to identify the device or service. The server
responds with a challenge in a <strong>getTokenChallenge</strong> response. This challenge is also a base-64 encoded binary block of data, which corresponds to a random
sequence of bytes that is then encrypted using the public certificate. Now, the device, or service, decrypts this challenge using the private part of the certificate, and
returns the base-64 encoded decrypted version of the challenge back to the provisioning server using the <strong>getTokenChallengeResponse</strong> element. The provisioning
server checks the response to the original random sequence of bytes. If equal, the provisioning server responds with a <strong>getTokenResponse</strong> result, containing
the token (a string this time) that can be used when reference to the identity defined by the certificate has to be made. The provisioning server must not return tokens that
contain white space characters.
</p>
<p>
If the response to the challenge is wrong, the server returns a <strong>bad-request</strong> error result, as is shown below.
If the sequence number identifying the challenge is not found on the server, the server returns a <strong>item-not-found</strong> error result, as is shown below.
</p>
<examplecaption='Challenge sequence number not found'>
The server must retain the challenge in memory for at least one minute before assuming the challenge will go unresponded.
</p>
</section4>
<section4topic='Provisioning Server challenging a token'anchor='tokenchallenge'>
<p>
For reasons the provisioning server determines, it can challenge the use of a token in any of the requests made to it. This is done by sending a
iq get stanza with a <strong>tokenChallenge</strong> to the party sending the token. This element contains both the token being challenged, and a binary
challenge. This challenge is made up of a random block of data that is encrypted using the public certificate referred to by the token.
</p>
<p>
The receiver of the challenge, if it has access to the private certificate referenced, decrypts the challenge, and returns the decrypted binary block of data
to the caller (i.e. the Provisioning Server in this case). If the decrypted block of data corresponds to the original random block of data encrypted, the sender
of the token is considered to be allowed to use the token.
</p>
<p>
If the received of the challenge does not have access to the private certificate referenced, but used the token in a propagated request made to it, it can propagate the
request to the original sender of the token. When the response is returned, it returns the response in turn to the sender of the challenge.
</p>
<p>
A challenge/response sequence can look as follows:
<strong>Note:</strong> It is important that a unit only responds to a <strong>tokenChallenge</strong> request from a JID to which the corresponding token
has been sent. If a token challenge is received from a JID to which the token has not been sent the last minute, the following error message must be returned:
The <strong>isFriendResponse</strong> element returned by the provisioning server contains an attribute <strong>secondaryTrustAllowed</strong> that is by default
set to false. If the provisioning server has no problem with allowing multiple trust to be delegated by devices in the network, it can choose to set this
attribute to true in the response. If true, the device knows it has the right to add its own friends, or to add secondary trust relationships.
</p>
<p>
The following diagram continues with the example given above, of how a sensor with a limited user interface, can allow to manually add new friends, including new
trust relationships using a single LED and a button.
When multiple trust is used, the entity (client, user, service, etc.) has one token from each provisioning server. However, when sending a token to a third party,
the sender does not know what provisioning server(s) the third party uses to check access rights and user privileges. Therefore, the client must send all tokens, separated
by a space.
</p>
<p>
When a provisioning server receives a request containing multiple tokens, the most forgiving response must be returned.
</p>
<examplecaption='Readout request using multiple tokens'>
<strong>Note:</strong> When a provisioning server wants to challenge multiple tokens, separate token challenges are sent, one for each token being challenged.
<strong>Note:</strong> The provisioning server implicitly understands which two JIDs that are to be checked: The first one is the sender of the message, the second one
is the JID available in the <strong>jid</strong> attribute in the request.
</p>
<p>
<strong>Note 2:</strong> Any resource information in the JID must be ignored by the provisioning server.
The following diagram displays a friendship request from an external party being rejected as a result of the trusted third party negating the friendship:
If the provisioning server decides that two friends in the network should no longer be friends and communicate with each other, it simply sends a message to
The provisioning server should only send such messages to clients that have previously asked the provisioning server if friendship requests should be accepted or not.
</p>
<p>
<strong>Note:</strong> The device should only honor such messages, if the sender is the trusted third party. Such messages received from other entities not trusted should
The provisioning server can, apart from accepting new friendships and rejecting old friendships, also recommend new friendships. In this case, the provisioning server
simply sends a message to one or both of the soon to be friends, as follows:
Note that the receptor can still ask the provisioning server if it can form a friendship with the suggested friend, using the <strong>isFriend</strong> command.
An important use case for provisioning in sensor networks is who gets to read out sensor data from which sensors. This use case details how communication with a
provisioning server can help the device determine if a client has sufficient access rights to read the values of the device.
<strong>Note:</strong> This use case is an extension of the use case 'Read-out rejected' in the XEP-0323
<linkurl='http://xmpp.org/extensions/xep-0323.html'>Internet of Things - Sensor Data</link>.
</p>
<p>
The following example shows the communication first between the client and the device, then between the device and the provisioning server, and last between the device and the client:
<section3topic='Restricting nodes during read-out'anchor='restrictingnodes'>
<p>
In case the device handles multiple nodes that can be read, the provisioning server has the possibility to grant read-out, but to limit the nodes that can be read out.
The provisioning server does this by returning the list of nodes that can be read.
<strong>Note:</strong> This use case is an extension of the use case 'Read-out of multiple devices' in the XEP-0323
<linkurl='http://xmpp.org/extensions/xep-0323.html'>Internet of Things - Sensor Data</link>.
</p>
<p>
<strong>Note 2:</strong> If the server responds, but without specifying a list of nodes, the device can assume that all nodes available in the original request are allowed
to be read. If no nodes in the request are allowed to be read, the provisioning server must respond with a result='false', so the device can reject the read-out request.
</p>
<p>
The following example shows the communication first between the client and the device, then between the device and the provisioning server, and last between the device and the client:
Note that the provisioning server responds with a <strong>canReadResponse</strong> element, similar to the <strong>canRead</strong> element in the request, except
only the nodes allowed to be read are read. The device must only permit read-out of nodes listed in the response from the provisioning server. Other nodes available
in the request should be ignored.
</p>
</section3>
<section3topic='Restricting fields during read-out'anchor='restrictingfields'>
<p>
In case the provisioning server wants to limit the fields a device can send to a client, the provisioning server has the possibility to grant read-out, but
list a set of fields the device is allowed to send to the corresponding client.
<strong>Note:</strong> If the server responds, but without specifying a list of field names, the device can assume that all fields available in the original request are allowed
to be sent. If no fields in the request are allowed to be sent, the provisioning server must respond with a result='false', so the device can reject the read-out request.
</p>
<p>
The following example shows the communication first between the client and the device, then between the device and the provisioning server, and last between the device and the client:
Note that the provisioning server responds with a <strong>canReadResponse</strong> element, similar to the <strong>canRead</strong> element in the request, except only
the fields allowed to be sent are listed. The client must only send fields having field names in this list.
</p>
<p>
Also note, that the provisioning server can return a list of both allowed nodes and allowed field names in the response. In this case, the device must only send allowed fields
from allowed nodes, and ignore all other fields and/or nodes.
<section3topic='Rejecting control actions'anchor='rejectingcontrolactions'>
<p>
An important use case for provisioning in sensor networks is who gets to control devices, and what they can control. This use case details how communication with a
provisioning server can help the device determine if a client has sufficient access rights to perform control actions on the device.
The following example shows the communication first between the client and the device, then between the device and the provisioning server, and last between the device and the client:
<section3topic='Restricting nodes during control'anchor='restrictingnodescontrol'>
<p>
In case the device handles multiple nodes that can be read, the provisioning server has the possibility to grant control access, but to limit the nodes that can be controlled.
The provisioning server does this by returning the list of nodes that can be controlled.
<strong>Note:</strong> If the server responds, but without specifying a list of nodes, the device can assume that all nodes available in the original request are allowed
to be controlled. If no nodes in the request are allowed to be controlled, the provisioning server must respond with a result='false', so the device can reject the read-out request.
The same is true for parameters: If the provisioning server does not specify parameters in the response, the caller can assume all parameters are allowed.
</p>
<p>
The following example shows the communication first between the client and the device, then between the device and the provisioning server, and last between the device and the client:
</p>
<examplecaption='Restricting nodes during control'>
Note that the provisioning server responds with a <strong>canControlResponse</strong> element, similar to the <strong>canControl</strong> element in the request, except
only the nodes allowed to be controlled are included. The device must only permit control of nodes listed in the response from the provisioning server. Other nodes available
in the request should be ignored.
</p>
<p>
Also note, that the restricted set of nodes and/or parameters returned from the provisioning server must be returned to the original caller, so it can
act on the information that only a partial control action was allowed and taken.
</p>
</section3>
<section3topic='Restricting parameters during control'anchor='restrictingparameterscontrol'>
<p>
In case the provisioning server wants to limit the control parameters a client can control in a device, the provisioning server has the possibility to grant
control access, but list a set of parameters the client is allowed to control in the corresponding device.
<strong>Note:</strong> If the server responds, but without specifying a list of nodes, the device can assume that all nodes available in the original request are allowed
to be controlled. If no nodes in the request are allowed to be controlled, the provisioning server must respond with a result='false', so the device can reject the read-out request.
The same is true for parameters: If the provisioning server does not specify parameters in the response, the caller can assume all parameters are allowed.
</p>
<p>
The following example shows the communication first between the client and the device, then between the device and the provisioning server, and last between the device and the client:
</p>
<examplecaption='Restricting parameters during control'>
Note that the provisioning server responds with a <strong>canControlResponse</strong> element, similar to the <strong>canControl</strong> element in the request, except only
the parameters allowed to be sent are listed. The device must only control parameters included in this list.
</p>
<p>
Also note, that the provisioning server can return a list of both allowed nodes and allowed parameter names in the response back to the client, so it can
act on the information that only a partial control action was allowed and taken.
</p>
</section3>
</section2>
<section2topic='Cache'anchor='cache'>
<section3topic='Clear cache'anchor='clearcache'>
<p>
When the provisioning server updates access rights and user privileges in the system, it will send a <strong>clearCache</strong> command to corresponding devices.
If a device was offline during the change, the provisioning server must send the <strong>clearCache</strong> message when the device comes online again. To acknowledge
the receipt of the command, the client responds with a <strong>clearCacheResponse</strong> element. This response message does not contain any information on what was
done by the client. It simply acknowledges the receipt of the command, to make sure the provisioning server does not resend the clear cache command again.
</p>
<p>
<strong>Note:</strong> The <strong>clearCache</strong> command does not include information on what has been changed, so the device needs to clear the entire cache. This
to avoid complexities in making sure updates made to the provisioning rules works in all cases, and to minimize complexity in the implementation of the protocol on the sensor side.
It is also not deemed to decrease network performance, since changing provisioning rules for a device is an exceptional event and therefore does not affect performance during
<section3topic='Getting a service token'anchor='servicetoken'>
<p>
A service requesting provisioning assistance, needs to retrieve a service token from the provisioning server, by providing a base-64 encoded X.509 certificate.
The following example shows how this can be done.
</p>
<examplecaption='Requesting a service token'>
<