Merge branch 'xep_0323_325' of git://github.com/joachimlindborg/SleekXMPP into joachimlindborg-xep_0323_325

Conflicts:
	sleekxmpp/plugins/__init__.py

19 files changed, 5605 insertions, 0 deletions

diff --git a/examples/IoT_TestDevice.py b/examples/IoT_TestDevice.py
new file mode 100644
index 00000000..c754cfb4
--- /dev/null
+++ b/examples/IoT_TestDevice.py
@@ -0,0 +1,202 @@
+#!/usr/bin/env python
+
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import os
+import sys
+# This can be used when you are in a test environment and need to make paths right
+sys.path=['/Users/jocke/Dropbox/06_dev/SleekXMPP']+sys.path
+
+import logging
+import unittest
+import distutils.core
+import datetime
+
+from glob import glob
+from os.path import splitext, basename, join as pjoin
+from optparse import OptionParser
+from urllib import urlopen
+
+import sleekxmpp
+# Python versions before 3.0 do not use UTF-8 encoding
+# by default. To ensure that Unicode is handled properly
+# throughout SleekXMPP, we will set the default encoding
+# ourselves to UTF-8.
+if sys.version_info < (3, 0):
+    from sleekxmpp.util.misc_ops import setdefaultencoding
+    setdefaultencoding('utf8')
+else:
+    raw_input = input
+    
+from sleekxmpp.plugins.xep_0323.device import Device
+
+#from sleekxmpp.exceptions import IqError, IqTimeout
+
+class IoT_TestDevice(sleekxmpp.ClientXMPP):
+
+    """
+    A simple IoT device that can act as server or client
+    """
+    def __init__(self, jid, password):
+        sleekxmpp.ClientXMPP.__init__(self, jid, password)
+        self.add_event_handler("session_start", self.session_start)
+        self.add_event_handler("message", self.message)
+        self.device=None
+        self.releaseMe=False
+        self.beServer=True
+        self.clientJID=None
+
+    def datacallback(self,from_jid,result,nodeId=None,timestamp=None,fields=None,error_msg=None):
+        """
+        This method will be called when you ask another IoT device for data with the xep_0323
+        se script below for the registration of the callback
+        """
+        logging.debug("we got data %s from %s",str(result),from_jid)
+
+    def beClientOrServer(self,server=True,clientJID=None ):
+        if server:
+            self.beServer=True
+            self.clientJID=None
+        else:
+            self.beServer=False
+            self.clientJID=clientJID
+            
+    def testForRelease(self):
+        # todo thread safe
+        return self.releaseMe
+
+    def doReleaseMe(self):
+        # todo thread safe
+        self.releaseMe=True
+        
+    def addDevice(self, device):
+        self.device=device
+        
+    def session_start(self, event):
+        self.send_presence()
+        self.get_roster()
+        # tell your preffered friend that you are alive 
+        self.send_message(mto='jocke@jabber.sust.se', mbody=self.boundjid.bare +' is now online use xep_323 stanza to talk to me')
+
+        if not(self.beServer):
+            session=self['xep_0323'].request_data(self.boundjid.full,self.clientJID,self.datacallback)
+
+    def message(self, msg):
+        if msg['type'] in ('chat', 'normal'):
+            logging.debug("got normal chat message" + str(msg))
+            ip=urlopen('http://icanhazip.com').read()
+            msg.reply("Hi I am " + self.boundjid.full + " and I am on IP " + ip).send()
+        else:
+            logging.debug("got unknown message type %s", str(msg['type']))
+            
+class TheDevice(Device):
+    """
+    This is the actual device object that you will use to get information from your real hardware
+    You will be called in the refresh method when someone is requesting information from you
+    """
+    def __init__(self,nodeId):
+        Device.__init__(self,nodeId)
+        self.counter=0
+
+    def refresh(self,fields):
+        """
+        the implementation of the refresh method
+        """
+        self._set_momentary_timestamp(self._get_timestamp())
+        self.counter+=self.counter
+        self._add_field_momentary_data(self, "Temperature", self.counter) 
+        
+if __name__ == '__main__':
+
+    # Setup the command line arguments.
+    #
+    # This script can act both as
+    #   "server" an IoT device that can provide sensorinformation
+    #   python IoT_TestDevice.py -j "serverjid@yourdomain.com" -p "password" -n "TestIoT" --debug
+    #
+    #   "client" an IoT device or other party that would like to get data from another device
+    
+    optp = OptionParser()
+
+    # Output verbosity options.
+    optp.add_option('-q', '--quiet', help='set logging to ERROR',
+                    action='store_const', dest='loglevel',
+                    const=logging.ERROR, default=logging.INFO)
+    optp.add_option('-d', '--debug', help='set logging to DEBUG',
+                    action='store_const', dest='loglevel',
+                    const=logging.DEBUG, default=logging.INFO)
+    optp.add_option('-v', '--verbose', help='set logging to COMM',
+                    action='store_const', dest='loglevel',
+                    const=5, default=logging.INFO)
+    optp.add_option('-t', '--pingto', help='set jid to ping',
+                    action='store', type='string', dest='pingjid',
+                    default=None)
+
+    # JID and password options.
+    optp.add_option("-j", "--jid", dest="jid",
+                    help="JID to use")
+    optp.add_option("-p", "--password", dest="password",
+                    help="password to use")
+
+    # IoT test
+    optp.add_option("-c", "--sensorjid", dest="sensorjid",
+                    help="Another device to call for data on", default=None)
+    optp.add_option("-n", "--nodeid", dest="nodeid",
+                    help="I am a device get ready to be called", default=None)
+    
+    opts, args = optp.parse_args()
+
+     # Setup logging.
+    logging.basicConfig(level=opts.loglevel,
+                        format='%(levelname)-8s %(message)s')
+
+    if opts.jid is None:
+        opts.jid = raw_input("Username: ")
+    if opts.password is None:
+        opts.password = getpass.getpass("Password: ")
+        
+
+    xmpp = IoT_TestDevice(opts.jid,opts.password)
+    xmpp.register_plugin('xep_0030')
+    #xmpp['xep_0030'].add_feature(feature='urn:xmpp:iot:sensordata',
+    #                             node=None,
+    #    jid=None)
+    xmpp.register_plugin('xep_0323')
+    xmpp.register_plugin('xep_0325')
+
+    if opts.nodeid:
+
+        # xmpp['xep_0030'].add_feature(feature='urn:xmpp:sn',
+        # node=opts.nodeid,
+        # jid=xmpp.boundjid.full)
+
+        myDevice = TheDevice(opts.nodeid);
+        # myDevice._add_field(name="Relay", typename="numeric", unit="Bool");
+        myDevice._add_field(name="Temperature", typename="numeric", unit="C");
+        myDevice._set_momentary_timestamp("2013-03-07T16:24:30")
+        myDevice._add_field_momentary_data("Temperature", "23.4", flags={"automaticReadout": "true"});
+        
+        xmpp['xep_0323'].register_node(nodeId=opts.nodeid, device=myDevice, commTimeout=10);
+        xmpp.beClientOrServer(server=True)
+        while not(xmpp.testForRelease()):
+            xmpp.connect()
+            xmpp.process(block=True)    
+            logging.debug("lost connection")
+    if opts.sensorjid:
+        logging.debug("will try to call another device for data")
+        xmpp.beClientOrServer(server=False,clientJID=opts.sensorjid)
+        xmpp.connect()
+        xmpp.process(block=True)
+        logging.debug("ready ending")
+        
+    else:
+       print "noopp didn't happen"
+
diff --git a/sleekxmpp/plugins/__init__.py b/sleekxmpp/plugins/__init__.py
index ed1fea9e..951f31eb 100644
--- a/sleekxmpp/plugins/__init__.py
+++ b/sleekxmpp/plugins/__init__.py
@@ -81,4 +81,6 @@ __all__ = [
     'xep_0308',  # Last Message Correction
     'xep_0313',  # Message Archive Management
     'xep_0319',  # Last User Interaction in Presence
+    'xep_0323',  # IoT Systems Sensor Data
+    'xep_0325',  # IoT Systems Control
 ]
diff --git a/sleekxmpp/plugins/xep_0323/__init__.py b/sleekxmpp/plugins/xep_0323/__init__.py
new file mode 100644
index 00000000..10779ada
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0323/__init__.py
@@ -0,0 +1,18 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.plugins.xep_0323.sensordata import XEP_0323
+from sleekxmpp.plugins.xep_0323 import stanza
+
+register_plugin(XEP_0323)
+
+xep_0323=XEP_0323
diff --git a/sleekxmpp/plugins/xep_0323/device.py b/sleekxmpp/plugins/xep_0323/device.py
new file mode 100644
index 00000000..23bdd153
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0323/device.py
@@ -0,0 +1,255 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import datetime
+import logging
+
+class Device(object):
+	"""
+	Example implementation of a device readout object. 
+    Is registered in the XEP_0323.register_node call
+    The device object may be any custom implementation to support 
+    specific devices, but it must implement the functions:
+          has_field
+          request_fields
+	"""
+
+	def __init__(self, nodeId, fields={}):
+		self.nodeId = nodeId
+		self.fields = fields # see fields described below
+		# {'type':'numeric',
+		#  'name':'myname',
+		#  'value': 42,
+		#  'unit':'Z'}];
+		self.timestamp_data = {}
+		self.momentary_data = {}
+		self.momentary_timestamp = ""
+		logging.debug("Device object started nodeId %s",nodeId)
+
+	def has_field(self, field):
+		"""
+		Returns true if the supplied field name exists in this device.
+
+        Arguments:
+            field      -- The field name		
+		"""
+		if field in self.fields.keys():
+			return True;
+		return False;
+	
+	def refresh(self, fields):
+		"""
+		override method to do the refresh work
+		refresh values from hardware or other
+		"""
+		pass
+		
+
+	def request_fields(self, fields, flags, session, callback):
+		"""
+		Starts a data readout. Verifies the requested fields,
+		refreshes the data (if needed) and calls the callback
+		with requested data.
+
+
+        Arguments:
+            fields   -- List of field names to readout
+            flags    -- [optional] data classifier flags for the field, e.g. momentary
+                        Formatted as a dictionary like { "flag name": "flag value" ... }
+            session  -- Session id, only used in the callback as identifier
+            callback -- Callback function to call when data is available.
+	    
+					The callback function must support the following arguments:
+
+				session  -- Session id, as supplied in the request_fields call
+				nodeId   -- Identifier for this device
+            	result   -- The current result status of the readout. Valid values are:
+                               "error"  - Readout failed.
+                               "fields" - Contains readout data.
+                               "done"   - Indicates that the readout is complete. May contain 
+                                          readout data.
+            	timestamp_block -- [optional] Only applies when result != "error" 
+                               The readout data. Structured as a dictionary:
+              	  { 
+                	timestamp:     timestamp for this datablock,
+                	fields:        list of field dictionary (one per readout field).
+                  	  readout field dictionary format:
+                  	  {
+                    	type:      The field type (numeric, boolean, dateTime, timeSpan, string, enum)
+                    	name:      The field name
+                    	value:     The field value
+                    	unit:      The unit of the field. Only applies to type numeric.
+                    	dataType:  The datatype of the field. Only applies to type enum.
+                    	flags:     [optional] data classifier flags for the field, e.g. momentary
+                               Formatted as a dictionary like { "flag name": "flag value" ... }
+                  	  }  
+              	  }
+            	error_msg -- [optional] Only applies when result == "error".
+                                Error details when a request failed. 
+
+		"""
+                logging.debug("request_fields called looking for fields %s",fields)
+		if len(fields) > 0:
+			# Check availiability
+			for f in fields:
+				if f not in self.fields.keys():
+					self._send_reject(session, callback)
+					return False;
+		else:
+			# Request all fields
+			fields = self.fields.keys();
+
+
+		# Refresh data from device
+		# ...
+		logging.debug("about to refresh device fields %s",fields)
+		self.refresh(fields)
+
+		if "momentary" in flags and flags['momentary'] == "true" or \
+		   "all" in flags and flags['all'] == "true":
+			ts_block = {};
+			timestamp = "";
+
+			if len(self.momentary_timestamp) > 0:
+				timestamp = self.momentary_timestamp;
+			else:
+				timestamp = self._get_timestamp();
+
+			field_block = [];
+			for f in self.momentary_data:
+				if f in fields:
+					field_block.append({"name": f, 
+							    "type": self.fields[f]["type"], 
+							    "unit": self.fields[f]["unit"],
+							    "dataType": self.fields[f]["dataType"],
+							    "value": self.momentary_data[f]["value"], 
+							    "flags": self.momentary_data[f]["flags"]});
+			ts_block["timestamp"] = timestamp;
+			ts_block["fields"] = field_block;
+
+			callback(session, result="done", nodeId=self.nodeId, timestamp_block=ts_block);
+			return
+
+		from_flag = self._datetime_flag_parser(flags, 'from')
+		to_flag = self._datetime_flag_parser(flags, 'to')
+
+		for ts in sorted(self.timestamp_data.keys()):
+			tsdt = datetime.datetime.strptime(ts, "%Y-%m-%dT%H:%M:%S")
+			if not from_flag is None: 
+				if tsdt < from_flag: 
+					#print (str(tsdt) + " < " + str(from_flag))
+					continue
+			if not to_flag is None: 
+				if tsdt > to_flag: 
+					#print (str(tsdt) + " > " + str(to_flag))
+					continue
+	
+			ts_block = {};
+			field_block = [];
+
+			for f in self.timestamp_data[ts]:
+				if f in fields:
+					field_block.append({"name": f, 
+							    "type": self.fields[f]["type"], 
+							    "unit": self.fields[f]["unit"],
+							    "dataType": self.fields[f]["dataType"],
+							    "value": self.timestamp_data[ts][f]["value"], 
+							    "flags": self.timestamp_data[ts][f]["flags"]});
+
+			ts_block["timestamp"] = ts;
+			ts_block["fields"] = field_block;
+			callback(session, result="fields", nodeId=self.nodeId, timestamp_block=ts_block);
+		callback(session, result="done", nodeId=self.nodeId, timestamp_block=None);
+
+	def _datetime_flag_parser(self, flags, flagname):
+		if not flagname in flags:
+			return None
+		
+		dt = None
+		try:
+			dt = datetime.datetime.strptime(flags[flagname], "%Y-%m-%dT%H:%M:%S")
+		except ValueError:
+			# Badly formatted datetime, ignore it
+			pass
+		return dt
+
+
+	def _get_timestamp(self):
+		"""
+		Generates a properly formatted timestamp of current time
+		"""
+		return datetime.datetime.now().replace(microsecond=0).isoformat()
+
+	def _send_reject(self, session, callback):
+		"""
+		Sends a reject to the caller
+
+        Arguments:
+            session  -- Session id, see definition in request_fields function
+            callback -- Callback function, see definition in request_fields function
+		"""
+		callback(session, result="error", nodeId=self.nodeId, timestamp_block=None, error_msg="Reject");
+
+	def _add_field(self, name, typename, unit=None, dataType=None):
+		"""
+		Adds a field to the device
+
+        Arguments:
+            name     -- Name of the field
+            typename -- Type of the field (numeric, boolean, dateTime, timeSpan, string, enum)
+            unit     -- [optional] only applies to "numeric". Unit for the field.
+            dataType -- [optional] only applies to "enum". Datatype for the field.
+		"""
+		self.fields[name] = {"type": typename, "unit": unit, "dataType": dataType};
+
+	def _add_field_timestamp_data(self, name, timestamp, value, flags=None):
+		"""
+		Adds timestamped data to a field
+
+        Arguments:
+            name      -- Name of the field
+            timestamp -- Timestamp for the data (string)
+            value     -- Field value at the timestamp
+            flags     -- [optional] data classifier flags for the field, e.g. momentary
+                         Formatted as a dictionary like { "flag name": "flag value" ... }
+		"""
+		if not name in self.fields.keys():
+			return False;
+		if not timestamp in self.timestamp_data:
+			self.timestamp_data[timestamp] = {};
+
+		self.timestamp_data[timestamp][name] = {"value": value, "flags": flags};
+		return True;
+
+	def _add_field_momentary_data(self, name, value, flags=None):
+		"""
+		Sets momentary data to a field
+
+        Arguments:
+            name      -- Name of the field
+            value     -- Field value at the timestamp
+            flags     -- [optional] data classifier flags for the field, e.g. momentary
+                         Formatted as a dictionary like { "flag name": "flag value" ... }
+		"""
+		if not self.fields.has_key(name):
+			return False;
+		if flags is None:
+			flags = {};
+		
+		flags["momentary"] = "true"
+		self.momentary_data[name] = {"value": value, "flags": flags};
+		return True;
+
+	def _set_momentary_timestamp(self, timestamp):
+		"""
+		This function is only for unit testing to produce predictable results.
+		"""
+		self.momentary_timestamp = timestamp;
+
diff --git a/sleekxmpp/plugins/xep_0323/sensordata.py b/sleekxmpp/plugins/xep_0323/sensordata.py
new file mode 100644
index 00000000..2e2f2470
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0323/sensordata.py
@@ -0,0 +1,723 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import logging
+import time
+import datetime
+from threading import Thread, Lock, Timer
+
+from sleekxmpp.plugins.xep_0323.timerreset import TimerReset
+
+from sleekxmpp.xmlstream import JID
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from sleekxmpp.plugins.base import BasePlugin
+from sleekxmpp.plugins.xep_0323 import stanza
+from sleekxmpp.plugins.xep_0323.stanza import Sensordata
+
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0323(BasePlugin):
+
+    """
+    XEP-0323: IoT Sensor Data 
+
+
+    This XEP 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.
+
+    Also see <http://xmpp.org/extensions/xep-0323.html>
+
+    Configuration Values:
+        threaded -- Indicates if communication with sensors should be threaded.
+                    Defaults to True.
+
+    Events:
+        Sensor side
+        -----------
+        Sensordata Event:Req    -- Received a request for data
+        Sensordata Event:Cancel -- Received a cancellation for a request
+
+        Client side
+        -----------
+        Sensordata Event:Accepted -- Received a accept from sensor for a request
+        Sensordata Event:Rejected -- Received a reject from sensor for a request
+        Sensordata Event:Cancelled -- Received a cancel confirm from sensor
+        Sensordata Event:Fields   -- Received fields from sensor for a request
+                                     This may be triggered multiple times since 
+                                     the sensor can split up its response in
+                                     multiple messages.
+        Sensordata Event:Failure  -- Received a failure indication from sensor 
+                                     for a request. Typically a comm timeout.
+
+    Attributes:
+        threaded -- Indicates if command events should be threaded.
+                    Defaults to True.
+        sessions -- A dictionary or equivalent backend mapping
+                    session IDs to dictionaries containing data
+                    relevant to a request's session. This dictionary is used
+                    both by the client and sensor side. On client side, seqnr
+                    is used as key, while on sensor side, a session_id is used
+                    as key. This ensures that the two will not collide, so 
+                    one instance can be both client and sensor.
+        Sensor side
+        -----------
+        nodes    -- A dictionary mapping sensor nodes that are serviced through
+                    this XMPP instance to their device handlers ("drivers").
+        Client side
+        -----------
+        last_seqnr -- The last used sequence number (integer). One sequence of
+                    communication (e.g. -->request, <--accept, <--fields)
+                    between client and sensor is identified by a unique
+                    sequence number (unique between the client/sensor pair)
+
+    Methods:
+        plugin_init       -- Overrides base_plugin.plugin_init
+        post_init         -- Overrides base_plugin.post_init
+        plugin_end        -- Overrides base_plugin.plugin_end
+
+        Sensor side
+        -----------
+        register_node     -- Register a sensor as available from this XMPP 
+                             instance.
+
+        Client side
+        -----------
+        request_data      -- Initiates a request for data from one or more 
+                             sensors. Non-blocking, a callback function will
+                             be called when data is available.
+
+    """
+
+    name = 'xep_0323'
+    description = 'XEP-0323 Internet of Things - Sensor Data'
+    dependencies = set(['xep_0030']) 
+    stanza = stanza
+
+
+    default_config = {
+        'threaded': True
+#        'session_db': None
+    }
+
+    def plugin_init(self):
+        """ Start the XEP-0323 plugin """
+
+        self.xmpp.register_handler(
+                Callback('Sensordata Event:Req',
+                    StanzaPath('iq@type=get/req'),
+                    self._handle_event_req))
+
+        self.xmpp.register_handler(
+                Callback('Sensordata Event:Accepted',
+                    StanzaPath('iq@type=result/accepted'),
+                    self._handle_event_accepted))
+
+        self.xmpp.register_handler(
+                Callback('Sensordata Event:Rejected',
+                    StanzaPath('iq@type=error/rejected'),
+                    self._handle_event_rejected))
+
+        self.xmpp.register_handler(
+                Callback('Sensordata Event:Cancel',
+                    StanzaPath('iq@type=get/cancel'),
+                    self._handle_event_cancel))
+
+        self.xmpp.register_handler(
+                Callback('Sensordata Event:Cancelled',
+                    StanzaPath('iq@type=result/cancelled'),
+                    self._handle_event_cancelled))
+
+        self.xmpp.register_handler(
+                Callback('Sensordata Event:Fields',
+                    StanzaPath('message/fields'),
+                    self._handle_event_fields))
+
+        self.xmpp.register_handler(
+                Callback('Sensordata Event:Failure',
+                    StanzaPath('message/failure'),
+                    self._handle_event_failure))
+
+        self.xmpp.register_handler(
+                Callback('Sensordata Event:Started',
+                    StanzaPath('message/started'),
+                    self._handle_event_started))
+
+        # Server side dicts
+        self.nodes = {};
+        self.sessions = {};
+
+        self.last_seqnr = 0;
+        self.seqnr_lock = Lock();
+
+        ## For testning only
+        self.test_authenticated_from = ""
+
+    def post_init(self):
+        """ Init complete. Register our features in Serivce discovery. """
+        BasePlugin.post_init(self)
+        self.xmpp['xep_0030'].add_feature(Sensordata.namespace)
+        self.xmpp['xep_0030'].set_items(node=Sensordata.namespace, items=tuple())
+
+    def _new_session(self):
+        """ Return a new session ID. """
+        return str(time.time()) + '-' + self.xmpp.new_id()
+
+    def session_bind(self, jid):
+        logging.debug("setting the Disco discovery for %s" % Sensordata.namespace)
+        self.xmpp['xep_0030'].add_feature(Sensordata.namespace)
+        self.xmpp['xep_0030'].set_items(node=Sensordata.namespace, items=tuple())
+
+
+    def plugin_end(self):
+        """ Stop the XEP-0323 plugin """
+        self.sessions.clear();
+        self.xmpp.remove_handler('Sensordata Event:Req')
+        self.xmpp.remove_handler('Sensordata Event:Accepted')
+        self.xmpp.remove_handler('Sensordata Event:Rejected')
+        self.xmpp.remove_handler('Sensordata Event:Cancel')
+        self.xmpp.remove_handler('Sensordata Event:Cancelled')
+        self.xmpp.remove_handler('Sensordata Event:Fields')
+        self.xmpp['xep_0030'].del_feature(feature=Sensordata.namespace)
+
+
+    # =================================================================
+    # Sensor side (data provider) API
+
+    def register_node(self, nodeId, device, commTimeout, sourceId=None, cacheType=None):
+        """
+        Register a sensor/device as available for serving of data through this XMPP
+        instance. 
+
+        The device object may by any custom implementation to support 
+        specific devices, but it must implement the functions:
+          has_field
+          request_fields
+        according to the interfaces shown in the example device.py file.
+
+        Arguments:
+            nodeId      -- The identifier for the device
+            device      -- The device object
+            commTimeout -- Time in seconds to wait between each callback from device during
+                           a data readout. Float.
+            sourceId    -- [optional] identifying the data source controlling the device
+            cacheType   -- [optional] narrowing down the search to a specific kind of node        
+        """
+        self.nodes[nodeId] = {"device": device, 
+                                "commTimeout": commTimeout,
+                                "sourceId": sourceId, 
+                                "cacheType": cacheType};
+
+    def _set_authenticated(self, auth=''):
+        """ Internal testing function """
+        self.test_authenticated_from = auth;
+
+
+    def _handle_event_req(self, iq):
+        """
+        Event handler for reception of an Iq with req - this is a request.
+
+        Verifies that 
+          - all the requested nodes are available
+          - at least one of the requested fields is available from at least 
+            one of the nodes
+
+        If the request passes verification, an accept response is sent, and
+        the readout process is started in a separate thread.
+        If the verification fails, a reject message is sent.
+        """
+
+        seqnr = iq['req']['seqnr'];
+        error_msg = '';
+        req_ok = True;
+
+        # Authentication
+        if len(self.test_authenticated_from) > 0 and not iq['from'] == self.test_authenticated_from:
+            # Invalid authentication
+            req_ok = False;
+            error_msg = "Access denied";
+
+        # Nodes
+        process_nodes = [];
+        if len(iq['req']['nodes']) > 0:
+            for n in iq['req']['nodes']:
+                if not n['nodeId'] in self.nodes:
+                    req_ok = False;
+                    error_msg = "Invalid nodeId " + n['nodeId'];
+            process_nodes = [n['nodeId'] for n in iq['req']['nodes']];
+        else:
+            process_nodes = self.nodes.keys();
+
+        # Fields - if we just find one we are happy, otherwise we reject
+        process_fields = [];
+        if len(iq['req']['fields']) > 0:
+            found = False
+            for f in iq['req']['fields']:
+                for node in self.nodes:
+                    if self.nodes[node]["device"].has_field(f['name']):
+                        found = True;
+                        break;
+            if not found:
+                req_ok = False;
+                error_msg = "Invalid field " + f['name'];
+            process_fields = [f['name'] for n in iq['req']['fields']];
+
+        req_flags = iq['req']._get_flags();
+
+        request_delay_sec = None
+        if 'when' in req_flags:
+            # Timed request - requires datetime string in iso format
+            # ex. 2013-04-05T15:00:03
+            dt = None
+            try:
+                dt = datetime.datetime.strptime(req_flags['when'], "%Y-%m-%dT%H:%M:%S")
+            except ValueError:
+                req_ok = False;
+                error_msg = "Invalid datetime in 'when' flag, please use ISO format (i.e. 2013-04-05T15:00:03)."
+
+            if not dt is None:
+                # Datetime properly formatted
+                dtnow = datetime.datetime.now()
+                dtdiff = dt - dtnow
+                request_delay_sec = dtdiff.seconds + dtdiff.days * 24 * 3600
+                if request_delay_sec <= 0:
+                    req_ok = False;
+                    error_msg = "Invalid datetime in 'when' flag, cannot set a time in the past. Current time: " + dtnow.isoformat();
+
+        if req_ok:
+            session = self._new_session();
+            self.sessions[session] = {"from": iq['from'], "to": iq['to'], "seqnr": seqnr};
+            self.sessions[session]["commTimers"] = {};
+            self.sessions[session]["nodeDone"] = {};
+
+            #print("added session: " + str(self.sessions))
+
+            iq.reply();
+            iq['accepted']['seqnr'] = seqnr;
+            if not request_delay_sec is None:
+                iq['accepted']['queued'] = "true"
+            iq.send(block=False);
+
+            self.sessions[session]["node_list"] = process_nodes;
+
+            if not request_delay_sec is None:
+                # Delay request to requested time
+                timer = Timer(request_delay_sec, self._event_delayed_req, args=(session, process_fields, req_flags))
+                self.sessions[session]["commTimers"]["delaytimer"] = timer;
+                timer.start();
+                return
+
+            if self.threaded:
+                #print("starting thread")
+                tr_req = Thread(target=self._threaded_node_request, args=(session, process_fields, req_flags))
+                tr_req.start()
+                #print("started thread")
+            else:
+                self._threaded_node_request(session, process_fields, req_flags);
+
+        else:
+            iq.reply();
+            iq['type'] = 'error';
+            iq['rejected']['seqnr'] = seqnr;
+            iq['rejected']['error'] = error_msg;
+            iq.send(block=False);            
+
+    def _threaded_node_request(self, session, process_fields, flags):
+        """ 
+        Helper function to handle the device readouts in a separate thread.
+        
+        Arguments:
+            session         -- The request session id
+            process_fields  -- The fields to request from the devices
+            flags           -- [optional] flags to pass to the devices, e.g. momentary
+                               Formatted as a dictionary like { "flag name": "flag value" ... }
+        """
+        for node in self.sessions[session]["node_list"]:
+            self.sessions[session]["nodeDone"][node] = False;        
+
+        for node in self.sessions[session]["node_list"]:
+            timer = TimerReset(self.nodes[node]['commTimeout'], self._event_comm_timeout, args=(session, node));
+            self.sessions[session]["commTimers"][node] = timer;
+            #print("Starting timer " + str(timer) + ", timeout: " + str(self.nodes[node]['commTimeout']))
+            timer.start();
+            self.nodes[node]['device'].request_fields(process_fields, flags=flags, session=session, callback=self._device_field_request_callback);
+
+    def _event_comm_timeout(self, session, nodeId):
+        """ 
+        Triggered if any of the readout operations timeout.
+        Sends a failure message back to the client, stops communicating
+        with the failing device.
+        
+        Arguments:
+            session         -- The request session id
+            nodeId          -- The id of the device which timed out
+        """
+        msg = self.xmpp.Message();
+        msg['from'] = self.sessions[session]['to'];
+        msg['to'] = self.sessions[session]['from'];
+        msg['failure']['seqnr'] = self.sessions[session]['seqnr'];            
+        msg['failure']['error']['text'] = "Timeout";
+        msg['failure']['error']['nodeId'] = nodeId;
+        msg['failure']['error']['timestamp'] = datetime.datetime.now().replace(microsecond=0).isoformat();
+
+        # Drop communication with this device and check if we are done
+        self.sessions[session]["nodeDone"][nodeId] = True;
+        if (self._all_nodes_done(session)):
+            msg['failure']['done'] = 'true';
+        msg.send();
+        # The session is complete, delete it
+        #print("del session " + session + " due to timeout")
+        del self.sessions[session];
+
+    def _event_delayed_req(self, session, process_fields, req_flags):
+        """
+        Triggered when the timer from a delayed request fires.
+
+        Arguments:
+            session         -- The request session id
+            process_fields  -- The fields to request from the devices
+            flags           -- [optional] flags to pass to the devices, e.g. momentary
+                               Formatted as a dictionary like { "flag name": "flag value" ... }
+        """
+        msg = self.xmpp.Message();
+        msg['from'] = self.sessions[session]['to'];
+        msg['to'] = self.sessions[session]['from'];
+        msg['started']['seqnr'] = self.sessions[session]['seqnr'];
+        msg.send();
+
+        if self.threaded:
+            tr_req = Thread(target=self._threaded_node_request, args=(session, process_fields, req_flags))
+            tr_req.start()
+        else:
+            self._threaded_node_request(session, process_fields, req_flags);
+
+    def _all_nodes_done(self, session):
+        """ 
+        Checks wheter all devices are done replying to the readout.
+        
+        Arguments:
+            session         -- The request session id
+        """
+        for n in self.sessions[session]["nodeDone"]:
+            if not self.sessions[session]["nodeDone"][n]:
+                return False;
+        return True;
+
+    def _device_field_request_callback(self, session, nodeId, result, timestamp_block, error_msg=None):
+        """ 
+        Callback function called by the devices when they have any additional data.
+        Composes a message with the data and sends it back to the client, and resets 
+        the timeout timer for the device.
+        
+        Arguments:
+            session         -- The request session id
+            nodeId          -- The device id which initiated the callback
+            result          -- The current result status of the readout. Valid values are:
+                               "error"  - Readout failed.
+                               "fields" - Contains readout data.
+                               "done"   - Indicates that the readout is complete. May contain 
+                                          readout data.
+            timestamp_block -- [optional] Only applies when result != "error" 
+                               The readout data. Structured as a dictionary:
+              { 
+                timestamp:     timestamp for this datablock,
+                fields:        list of field dictionary (one per readout field).
+                  readout field dictionary format:
+                  {
+                    type:      The field type (numeric, boolean, dateTime, timeSpan, string, enum)
+                    name:      The field name
+                    value:     The field value
+                    unit:      The unit of the field. Only applies to type numeric.
+                    dataType:  The datatype of the field. Only applies to type enum.
+                    flags:     [optional] data classifier flags for the field, e.g. momentary
+                               Formatted as a dictionary like { "flag name": "flag value" ... }
+                  }  
+              }
+            error_msg        -- [optional] Only applies when result == "error".
+                                Error details when a request failed.
+        """
+        if not session in self.sessions:
+            # This can happend if a session was deleted, like in a cancellation. Just drop the data.
+            return
+
+        if result == "error":
+            self.sessions[session]["commTimers"][nodeId].cancel();
+
+            msg = self.xmpp.Message();
+            msg['from'] = self.sessions[session]['to'];
+            msg['to'] = self.sessions[session]['from'];
+            msg['failure']['seqnr'] = self.sessions[session]['seqnr'];
+            msg['failure']['error']['text'] = error_msg;
+            msg['failure']['error']['nodeId'] = nodeId;
+            msg['failure']['error']['timestamp'] = datetime.datetime.now().replace(microsecond=0).isoformat();
+
+            # Drop communication with this device and check if we are done
+            self.sessions[session]["nodeDone"][nodeId] = True;   
+            if (self._all_nodes_done(session)):
+                msg['failure']['done'] = 'true';
+                # The session is complete, delete it
+                # print("del session " + session + " due to error")
+                del self.sessions[session];
+            msg.send();
+        else:
+            msg = self.xmpp.Message();
+            msg['from'] = self.sessions[session]['to'];
+            msg['to'] = self.sessions[session]['from'];
+            msg['fields']['seqnr'] = self.sessions[session]['seqnr'];
+
+            if timestamp_block is not None and len(timestamp_block) > 0:
+                node = msg['fields'].add_node(nodeId);
+                ts = node.add_timestamp(timestamp_block["timestamp"]);
+
+                for f in timestamp_block["fields"]:
+                    data = ts.add_data( typename=f['type'], 
+                                        name=f['name'], 
+                                        value=f['value'], 
+                                        unit=f['unit'], 
+                                        dataType=f['dataType'], 
+                                        flags=f['flags']);
+
+            if result == "done":
+                self.sessions[session]["commTimers"][nodeId].cancel();
+                self.sessions[session]["nodeDone"][nodeId] = True;
+                msg['fields']['done'] = 'true';
+                if (self._all_nodes_done(session)):
+                    # The session is complete, delete it
+                    # print("del session " + session + " due to complete")
+                    del self.sessions[session];
+            else:
+                # Restart comm timer
+                self.sessions[session]["commTimers"][nodeId].reset();
+
+            msg.send();
+
+    def _handle_event_cancel(self, iq):
+        """ Received Iq with cancel - this is a cancel request. 
+        Delete the session and confirm. """
+
+        seqnr = iq['cancel']['seqnr'];
+        # Find the session
+        for s in self.sessions:
+            if self.sessions[s]['from'] == iq['from'] and self.sessions[s]['to'] == iq['to'] and self.sessions[s]['seqnr'] == seqnr:
+                # found it. Cancel all timers
+                for n in self.sessions[s]["commTimers"]:
+                    self.sessions[s]["commTimers"][n].cancel();
+
+                # Confirm
+                iq.reply();
+                iq['type'] = 'result';
+                iq['cancelled']['seqnr'] = seqnr;
+                iq.send(block=False);            
+                
+                # Delete session
+                del self.sessions[s]
+                return
+
+        # Could not find session, send reject
+        iq.reply();
+        iq['type'] = 'error';
+        iq['rejected']['seqnr'] = seqnr;
+        iq['rejected']['error'] = "Cancel request received, no matching request is active.";
+        iq.send(block=False);       
+
+    # =================================================================
+    # Client side (data retriever) API
+
+    def request_data(self, from_jid, to_jid, callback, nodeIds=None, fields=None, flags=None):
+        """ 
+        Called on the client side to initiade a data readout.
+        Composes a message with the request and sends it to the device(s).
+        Does not block, the callback will be called when data is available.
+        
+        Arguments:
+            from_jid        -- The jid of the requester
+            to_jid          -- The jid of the device(s)
+            callback        -- The callback function to call when data is availble. 
+                            
+                            The callback function must support the following arguments:
+
+                from_jid    -- The jid of the responding device(s)
+                result      -- The current result status of the readout. Valid values are:
+                               "accepted"  - Readout request accepted
+                               "queued"    - Readout request accepted and queued
+                               "rejected"  - Readout request rejected
+                               "failure"   - Readout failed.
+                               "cancelled" - Confirmation of request cancellation.
+                               "started"   - Previously queued request is now started
+                               "fields"    - Contains readout data.
+                               "done"      - Indicates that the readout is complete.
+
+                nodeId      -- [optional] Mandatory when result == "fields" or "failure".
+                               The node Id of the responding device. One callback will only
+                               contain data from one device.
+                timestamp   -- [optional] Mandatory when result == "fields".
+                               The timestamp of data in this callback. One callback will only
+                               contain data from one timestamp.
+                fields      -- [optional] Mandatory when result == "fields".
+                               List of field dictionaries representing the readout data. 
+                               Dictionary format:
+                  {
+                    typename:  The field type (numeric, boolean, dateTime, timeSpan, string, enum)
+                    name:      The field name
+                    value:     The field value
+                    unit:      The unit of the field. Only applies to type numeric.
+                    dataType:  The datatype of the field. Only applies to type enum.
+                    flags:     [optional] data classifier flags for the field, e.g. momentary.
+                               Formatted as a dictionary like { "flag name": "flag value" ... }
+                  }  
+
+                error_msg   -- [optional] Mandatory when result == "rejected" or "failure".
+                               Details about why the request is rejected or failed. 
+                               "rejected" means that the request is stopped, but note that the 
+                               request will continue even after a "failure". "failure" only means
+                               that communication was stopped to that specific device, other
+                               device(s) (if any) will continue their readout.
+
+            nodeIds      -- [optional] Limits the request to the node Ids in this list.
+            fields       -- [optional] Limits the request to the field names in this list.
+            flags        -- [optional] Limits the request according to the flags, or sets
+                            readout conditions such as timing.
+
+        Return value:
+            session      -- Session identifier. Client can use this as a reference to cancel
+                            the request.
+        """
+        iq = self.xmpp.Iq();
+        iq['from'] = from_jid;
+        iq['to'] = to_jid;
+        iq['type'] = "get";
+        seqnr = self._get_new_seqnr();
+        iq['id'] = seqnr;
+        iq['req']['seqnr'] = seqnr;
+        if nodeIds is not None:
+            for nodeId in nodeIds:
+                iq['req'].add_node(nodeId);
+        if fields is not None:
+            for field in fields:
+                iq['req'].add_field(field);
+
+        iq['req']._set_flags(flags);
+
+        self.sessions[seqnr] = {"from": iq['from'], "to": iq['to'], "seqnr": seqnr, "callback": callback};
+        iq.send(block=False); 
+
+        return seqnr;
+
+    def cancel_request(self, session):
+        """ 
+        Called on the client side to cancel a request for data readout.
+        Composes a message with the cancellation and sends it to the device(s).
+        Does not block, the callback will be called when cancellation is 
+        confirmed.
+        
+        Arguments:
+            session        -- The session id of the request to cancel
+        """
+        seqnr = session
+        iq = self.xmpp.Iq();
+        iq['from'] = self.sessions[seqnr]['from']
+        iq['to'] = self.sessions[seqnr]['to'];
+        iq['type'] = "get";
+        iq['id'] = seqnr;
+        iq['cancel']['seqnr'] = seqnr;
+        iq.send(block=False);
+
+    def _get_new_seqnr(self):
+        """ Returns a unique sequence number (unique across threads) """
+        self.seqnr_lock.acquire();
+        self.last_seqnr = self.last_seqnr + 1;
+        self.seqnr_lock.release();
+        return str(self.last_seqnr);
+
+    def _handle_event_accepted(self, iq):
+        """ Received Iq with accepted - request was accepted """
+        seqnr = iq['accepted']['seqnr'];
+        result = "accepted"
+        if iq['accepted']['queued'] == 'true':
+            result = "queued"
+
+        callback = self.sessions[seqnr]["callback"];
+        callback(from_jid=iq['from'], result=result);
+
+    def _handle_event_rejected(self, iq):
+        """ Received Iq with rejected - this is a reject. 
+        Delete the session. """
+        seqnr = iq['rejected']['seqnr'];
+        callback = self.sessions[seqnr]["callback"];
+        callback(from_jid=iq['from'], result="rejected", error_msg=iq['rejected']['error']);
+        # Session terminated
+        del self.sessions[seqnr];
+
+    def _handle_event_cancelled(self, iq):
+        """ 
+        Received Iq with cancelled - this is a cancel confirm. 
+        Delete the session. 
+        """
+        #print("Got cancelled")
+        seqnr = iq['cancelled']['seqnr'];
+        callback = self.sessions[seqnr]["callback"];
+        callback(from_jid=iq['from'], result="cancelled");
+        # Session cancelled
+        del self.sessions[seqnr];
+
+    def _handle_event_fields(self, msg):
+        """ 
+        Received Msg with fields - this is a data reponse to a request.
+        If this is the last data block, issue a "done" callback.
+        """
+        seqnr = msg['fields']['seqnr'];
+        callback = self.sessions[seqnr]["callback"];
+        for node in msg['fields']['nodes']:
+            for ts in node['timestamps']:
+                fields = [];
+                for d in ts['datas']:
+                    field_block = {};
+                    field_block["name"] = d['name'];
+                    field_block["typename"] = d._get_typename();
+                    field_block["value"] = d['value'];
+                    if not d['unit'] == "": field_block["unit"] = d['unit'];
+                    if not d['dataType'] == "": field_block["dataType"] = d['dataType'];
+                    flags = d._get_flags();
+                    if not len(flags) == 0:
+                        field_block["flags"] = flags;
+                    fields.append(field_block);
+
+                callback(from_jid=msg['from'], result="fields", nodeId=node['nodeId'], timestamp=ts['value'], fields=fields);
+                
+        if msg['fields']['done'] == "true":
+            callback(from_jid=msg['from'], result="done");
+            # Session done
+            del self.sessions[seqnr];
+
+    def _handle_event_failure(self, msg):
+        """ 
+        Received Msg with failure - our request failed
+        Delete the session. 
+        """
+        seqnr = msg['failure']['seqnr'];
+        callback = self.sessions[seqnr]["callback"];
+        callback(from_jid=msg['from'], result="failure", nodeId=msg['failure']['error']['nodeId'], timestamp=msg['failure']['error']['timestamp'], error_msg=msg['failure']['error']['text']);
+
+        # Session failed
+        del self.sessions[seqnr];
+
+    def _handle_event_started(self, msg):
+        """ 
+        Received Msg with started - our request was queued and is now started. 
+        """
+        seqnr = msg['started']['seqnr'];
+        callback = self.sessions[seqnr]["callback"];
+        callback(from_jid=msg['from'], result="started");
+    
+
diff --git a/sleekxmpp/plugins/xep_0323/stanza/__init__.py b/sleekxmpp/plugins/xep_0323/stanza/__init__.py
new file mode 100644
index 00000000..c039cefa
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0323/stanza/__init__.py
@@ -0,0 +1,12 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.xep_0323.stanza.sensordata import *
+
diff --git a/sleekxmpp/plugins/xep_0323/stanza/base.py b/sleekxmpp/plugins/xep_0323/stanza/base.py
new file mode 100644
index 00000000..1dadcf46
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0323/stanza/base.py
@@ -0,0 +1,13 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.xmlstream import ET
+
+pass
diff --git a/sleekxmpp/plugins/xep_0323/stanza/sensordata.py b/sleekxmpp/plugins/xep_0323/stanza/sensordata.py
new file mode 100644
index 00000000..55e5060f
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0323/stanza/sensordata.py
@@ -0,0 +1,792 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp import Iq, Message
+from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
+from re import match
+
+class Sensordata(ElementBase):
+    """ Placeholder for the namespace, not used as a stanza """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'sensordata'
+    plugin_attrib = name
+    interfaces = set(tuple())
+
+class FieldTypes():
+    """ 
+    All field types are optional booleans that default to False
+    """
+    field_types = set([ 'momentary','peak','status','computed','identity','historicalSecond','historicalMinute','historicalHour', \
+                        'historicalDay','historicalWeek','historicalMonth','historicalQuarter','historicalYear','historicalOther'])
+
+class FieldStatus():
+    """ 
+    All field statuses are optional booleans that default to False
+    """
+    field_status = set([ 'missing','automaticEstimate','manualEstimate','manualReadout','automaticReadout','timeOffset','warning','error', \
+                         'signed','invoiced','endOfSeries','powerFailure','invoiceConfirmed'])
+
+class Request(ElementBase):
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'req'
+    plugin_attrib = name
+    interfaces = set(['seqnr','nodes','fields','serviceToken','deviceToken','userToken','from','to','when','historical','all'])
+    interfaces.update(FieldTypes.field_types);
+    _flags = set(['serviceToken','deviceToken','userToken','from','to','when','historical','all']);
+    _flags.update(FieldTypes.field_types);
+    
+    def __init__(self, xml=None, parent=None):
+        ElementBase.__init__(self, xml, parent);
+        self._nodes = set()
+        self._fields = set()
+
+    def setup(self, xml=None):
+        """
+        Populate the stanza object using an optional XML object.
+
+        Overrides ElementBase.setup
+
+        Caches item information.
+
+        Arguments:
+            xml -- Use an existing XML object for the stanza's values.
+        """
+        ElementBase.setup(self, xml)
+        self._nodes = set([node['nodeId'] for node in self['nodes']])
+        self._fields = set([field['name'] for field in self['fields']])
+
+    def _get_flags(self):
+        """
+        Helper function for getting of flags. Returns all flags in 
+        dictionary format: { "flag name": "flag value" ... } 
+        """
+        flags = {};
+        for f in self._flags:
+            if not self[f] == "":
+                flags[f] = self[f];
+        return flags;
+
+    def _set_flags(self, flags):
+        """
+        Helper function for setting of flags. 
+
+        Arguments:
+            flags -- Flags in dictionary format: { "flag name": "flag value" ... } 
+        """
+        for f in self._flags:
+            if flags is not None and f in flags:
+                self[f] = flags[f];
+            else:
+                self[f] = None;
+
+    def add_node(self, nodeId, sourceId=None, cacheType=None):
+        """
+        Add a new node element. Each item is required to have a
+        nodeId, but may also specify a sourceId value and cacheType.
+
+        Arguments:
+            nodeId    -- The ID for the node.
+            sourceId  -- [optional] identifying the data source controlling the device
+            cacheType -- [optional] narrowing down the search to a specific kind of node        
+        """
+        if nodeId not in self._nodes:
+            self._nodes.add((nodeId))
+            node = RequestNode(parent=self)
+            node['nodeId'] = nodeId
+            node['sourceId'] = sourceId
+            node['cacheType'] = cacheType
+            self.iterables.append(node)
+            return node
+        return None
+
+    def del_node(self, nodeId):
+        """
+        Remove a single node.
+
+        Arguments:
+            nodeId  -- Node ID of the item to remove.
+        """
+        if nodeId in self._nodes:
+            nodes = [i for i in self.iterables if isinstance(i, RequestNode)]
+            for node in nodes:
+                if node['nodeId'] == nodeId:
+                    self.xml.remove(node.xml)
+                    self.iterables.remove(node)
+                    return True
+        return False
+
+    def get_nodes(self):
+        """Return all nodes."""
+        nodes = set()
+        for node in self['substanzas']:
+            if isinstance(node, RequestNode):
+                nodes.add(node)
+        return nodes
+
+    def set_nodes(self, nodes):
+        """
+        Set or replace all nodes. The given nodes must be in a
+        list or set where each item is a tuple of the form:
+            (nodeId, sourceId, cacheType)
+
+        Arguments:
+            nodes -- A series of nodes in tuple format.
+        """
+        self.del_nodes()
+        for node in nodes:
+            if isinstance(node, RequestNode):
+                self.add_node(node['nodeId'], node['sourceId'], node['cacheType'])
+            else:
+                nodeId, sourceId, cacheType = node
+                self.add_node(nodeId, sourceId, cacheType)
+
+    def del_nodes(self):
+        """Remove all nodes."""
+        self._nodes = set()
+        nodes = [i for i in self.iterables if isinstance(i, RequestNode)]
+        for node in nodes:
+            self.xml.remove(node.xml)
+            self.iterables.remove(node)
+
+
+    def add_field(self, name):
+        """
+        Add a new field element. Each item is required to have a
+        name.
+
+        Arguments:
+            name  -- The name of the field.
+        """
+        if name not in self._fields:
+            self._fields.add((name))
+            field = RequestField(parent=self)
+            field['name'] = name
+            self.iterables.append(field)
+            return field
+        return None
+
+    def del_field(self, name):
+        """
+        Remove a single field.
+
+        Arguments:
+            name  -- name of field to remove.
+        """
+        if name in self._fields:
+            fields = [i for i in self.iterables if isinstance(i, RequestField)]
+            for field in fields:
+                if field['name'] == name:
+                    self.xml.remove(field.xml)
+                    self.iterables.remove(field)
+                    return True
+        return False
+
+    def get_fields(self):
+        """Return all fields."""
+        fields = set()
+        for field in self['substanzas']:
+            if isinstance(field, RequestField):
+                fields.add(field)
+        return fields
+
+    def set_fields(self, fields):
+        """
+        Set or replace all fields. The given fields must be in a
+        list or set where each item is RequestField or string
+
+        Arguments:
+            fields -- A series of fields in RequestField or string format.
+        """
+        self.del_fields()
+        for field in fields:
+            if isinstance(field, RequestField):
+                self.add_field(field['name'])
+            else:
+                self.add_field(field)
+
+    def del_fields(self):
+        """Remove all fields."""
+        self._fields = set()
+        fields = [i for i in self.iterables if isinstance(i, RequestField)]
+        for field in fields:
+            self.xml.remove(field.xml)
+            self.iterables.remove(field)
+
+
+class RequestNode(ElementBase):
+    """ Node element in a request """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'node'
+    plugin_attrib = name
+    interfaces = set(['nodeId','sourceId','cacheType'])
+
+class RequestField(ElementBase):
+    """ Field element in a request """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'field'
+    plugin_attrib = name
+    interfaces = set(['name'])
+
+class Accepted(ElementBase):
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'accepted'
+    plugin_attrib = name
+    interfaces = set(['seqnr','queued'])
+
+class Started(ElementBase):
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'started'
+    plugin_attrib = name
+    interfaces = set(['seqnr'])
+
+class Failure(ElementBase):
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'failure'
+    plugin_attrib = name
+    interfaces = set(['seqnr','done'])
+
+class Error(ElementBase):
+    """ Error element in a request failure """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'error'
+    plugin_attrib = name
+    interfaces = set(['nodeId','timestamp','sourceId','cacheType','text'])
+
+    def get_text(self):
+        """Return then contents inside the XML tag."""
+        return self.xml.text
+
+    def set_text(self, value):
+        """Set then contents inside the XML tag.
+
+        :param value: string
+        """
+
+        self.xml.text = value;
+        return self
+
+    def del_text(self):
+        """Remove the contents inside the XML tag."""
+        self.xml.text = ""
+        return self
+
+class Rejected(ElementBase):
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'rejected'
+    plugin_attrib = name
+    interfaces = set(['seqnr','error'])
+    sub_interfaces = set(['error'])
+
+class Fields(ElementBase):
+    """ Fields element, top level in a response message with data """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'fields'
+    plugin_attrib = name
+    interfaces = set(['seqnr','done','nodes'])
+
+    def __init__(self, xml=None, parent=None):
+        ElementBase.__init__(self, xml, parent);
+        self._nodes = set()
+
+    def setup(self, xml=None):
+        """
+        Populate the stanza object using an optional XML object.
+
+        Overrides ElementBase.setup
+
+        Caches item information.
+
+        Arguments:
+            xml -- Use an existing XML object for the stanza's values.
+        """
+        ElementBase.setup(self, xml)
+        self._nodes = set([node['nodeId'] for node in self['nodes']])
+
+
+    def add_node(self, nodeId, sourceId=None, cacheType=None, substanzas=None):
+        """
+        Add a new node element. Each item is required to have a
+        nodeId, but may also specify a sourceId value and cacheType.
+
+        Arguments:
+            nodeId  -- The ID for the node.
+            sourceId  -- [optional] identifying the data source controlling the device
+            cacheType -- [optional] narrowing down the search to a specific kind of node        
+        """
+        if nodeId not in self._nodes:
+            self._nodes.add((nodeId))
+            node = FieldsNode(parent=self)
+            node['nodeId'] = nodeId
+            node['sourceId'] = sourceId
+            node['cacheType'] = cacheType
+            if substanzas is not None:
+                node.set_timestamps(substanzas)
+
+            self.iterables.append(node)
+            return node
+        return None
+
+    def del_node(self, nodeId):
+        """
+        Remove a single node.
+
+        Arguments:
+            nodeId  -- Node ID of the item to remove.
+        """
+        if nodeId in self._nodes:
+            nodes = [i for i in self.iterables if isinstance(i, FieldsNode)]
+            for node in nodes:
+                if node['nodeId'] == nodeId:
+                    self.xml.remove(node.xml)
+                    self.iterables.remove(node)
+                    return True
+        return False
+
+    def get_nodes(self):
+        """Return all nodes."""
+        nodes = set()
+        for node in self['substanzas']:
+            if isinstance(node, FieldsNode):
+                nodes.add(node)
+        return nodes
+
+    def set_nodes(self, nodes):
+        """
+        Set or replace all nodes. The given nodes must be in a
+        list or set where each item is a tuple of the form:
+            (nodeId, sourceId, cacheType)
+
+        Arguments:
+            nodes -- A series of nodes in tuple format.
+        """
+        #print(str(id(self)) + " set_nodes: got " + str(nodes))
+        self.del_nodes()
+        for node in nodes:
+            if isinstance(node, FieldsNode):
+                self.add_node(node['nodeId'], node['sourceId'], node['cacheType'], substanzas=node['substanzas'])
+            else:
+                nodeId, sourceId, cacheType = node
+                self.add_node(nodeId, sourceId, cacheType)
+
+    def del_nodes(self):
+        """Remove all nodes."""
+        self._nodes = set()
+        nodes = [i for i in self.iterables if isinstance(i, FieldsNode)]
+        for node in nodes:
+            self.xml.remove(node.xml)
+            self.iterables.remove(node)
+
+
+class FieldsNode(ElementBase):
+    """ Node element in response fields """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'node'
+    plugin_attrib = name
+    interfaces = set(['nodeId','sourceId','cacheType','timestamps'])
+
+    def __init__(self, xml=None, parent=None):
+        ElementBase.__init__(self, xml, parent);
+        self._timestamps = set()
+
+    def setup(self, xml=None):
+        """
+        Populate the stanza object using an optional XML object.
+
+        Overrides ElementBase.setup
+
+        Caches item information.
+
+        Arguments:
+            xml -- Use an existing XML object for the stanza's values.
+        """
+        ElementBase.setup(self, xml)
+        self._timestamps = set([ts['value'] for ts in self['timestamps']])
+
+    def add_timestamp(self, timestamp, substanzas=None):
+        """
+        Add a new timestamp element. 
+
+        Arguments:
+            timestamp  -- The timestamp in ISO format.
+        """
+        #print(str(id(self)) + " add_timestamp: " + str(timestamp))
+
+        if timestamp not in self._timestamps:
+            self._timestamps.add((timestamp))
+            ts = Timestamp(parent=self)
+            ts['value'] = timestamp
+            if not substanzas is None:
+                ts.set_datas(substanzas);
+                #print("add_timestamp with substanzas: " + str(substanzas))
+            self.iterables.append(ts)
+            #print(str(id(self)) + " added_timestamp: " + str(id(ts)))
+            return ts
+        return None
+
+    def del_timestamp(self, timestamp):
+        """
+        Remove a single timestamp.
+
+        Arguments:
+            timestamp  -- timestamp (in ISO format) of the item to remove.
+        """
+        #print("del_timestamp: ")
+        if timestamp in self._timestamps:
+            timestamps = [i for i in self.iterables if isinstance(i, Timestamp)]
+            for ts in timestamps:
+                if ts['value'] == timestamp:
+                    self.xml.remove(ts.xml)
+                    self.iterables.remove(ts)
+                    return True
+        return False
+
+    def get_timestamps(self):
+        """Return all timestamps."""
+        #print(str(id(self)) + " get_timestamps: ")
+        timestamps = set()
+        for timestamp in self['substanzas']:
+            if isinstance(timestamp, Timestamp):
+                timestamps.add(timestamp)
+        return timestamps
+
+    def set_timestamps(self, timestamps):
+        """
+        Set or replace all timestamps. The given timestamps must be in a
+        list or set where each item is a timestamp
+
+        Arguments:
+            timestamps -- A series of timestamps.
+        """
+        #print(str(id(self)) + " set_timestamps: got " + str(timestamps))
+        self.del_timestamps()
+        for timestamp in timestamps:
+            #print("set_timestamps: subset " + str(timestamp))
+            #print("set_timestamps: subset.substanzas " + str(timestamp['substanzas']))
+            if isinstance(timestamp, Timestamp):
+                self.add_timestamp(timestamp['value'], substanzas=timestamp['substanzas'])
+            else:
+                #print("set_timestamps: got " + str(timestamp))
+                self.add_timestamp(timestamp)
+
+    def del_timestamps(self):
+        """Remove all timestamps."""
+        #print(str(id(self)) + " del_timestamps: ")
+        self._timestamps = set()
+        timestamps = [i for i in self.iterables if isinstance(i, Timestamp)]
+        for timestamp in timestamps:
+            self.xml.remove(timestamp.xml)
+            self.iterables.remove(timestamp)
+
+class Field(ElementBase):
+    """ 
+    Field element in response Timestamp. This is a base class,
+    all instances of fields added to Timestamp must be of types:
+        DataNumeric
+        DataString
+        DataBoolean
+        DataDateTime
+        DataTimeSpan
+        DataEnum
+    """    
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'field'
+    plugin_attrib = name
+    interfaces = set(['name','module','stringIds']);
+    interfaces.update(FieldTypes.field_types);
+    interfaces.update(FieldStatus.field_status);
+
+    _flags = set();
+    _flags.update(FieldTypes.field_types);
+    _flags.update(FieldStatus.field_status);
+
+    def set_stringIds(self, value):
+        """Verifies stringIds according to regexp from specification XMPP-0323.
+
+        :param value: string
+        """
+
+        pattern = re.compile("^\d+([|]\w+([.]\w+)*([|][^,]*)?)?(,\d+([|]\w+([.]\w+)*([|][^,]*)?)?)*$")
+        if pattern.match(value) is not None:
+            self.xml.stringIds = value;
+        else:
+            # Bad content, add nothing
+            pass
+
+        return self
+
+    def _get_flags(self):
+        """
+        Helper function for getting of flags. Returns all flags in 
+        dictionary format: { "flag name": "flag value" ... } 
+        """
+        flags = {};
+        for f in self._flags:
+            if not self[f] == "":
+                flags[f] = self[f];
+        return flags;
+
+    def _set_flags(self, flags):
+        """
+        Helper function for setting of flags. 
+
+        Arguments:
+            flags -- Flags in dictionary format: { "flag name": "flag value" ... } 
+        """
+        for f in self._flags:
+            if flags is not None and f in flags:
+                self[f] = flags[f];
+            else:
+                self[f] = None;
+
+    def _get_typename(self):
+        return "invalid type, use subclasses!";
+
+
+class Timestamp(ElementBase):
+    """ Timestamp element in response Node """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'timestamp'
+    plugin_attrib = name
+    interfaces = set(['value','datas'])
+
+    def __init__(self, xml=None, parent=None):
+        ElementBase.__init__(self, xml, parent);
+        self._datas = set()
+
+    def setup(self, xml=None):
+        """
+        Populate the stanza object using an optional XML object.
+
+        Overrides ElementBase.setup
+
+        Caches item information.
+
+        Arguments:
+            xml -- Use an existing XML object for the stanza's values.
+        """
+        ElementBase.setup(self, xml)
+        self._datas = set([data['name'] for data in self['datas']])
+
+    def add_data(self, typename, name, value, module=None, stringIds=None, unit=None, dataType=None, flags=None):
+        """
+        Add a new data element. 
+
+        Arguments:
+            typename   -- The type of data element (numeric, string, boolean, dateTime, timeSpan or enum)
+            value      -- The value of the data element
+            module     -- [optional] language module to use for the data element
+            stringIds  -- [optional] The stringIds used to find associated text in the language module
+            unit       -- [optional] The unit. Only applicable for type numeric
+            dataType   -- [optional] The dataType. Only applicable for type enum
+        """
+        if name not in self._datas:
+            dataObj = None;
+            if typename == "numeric":
+                dataObj = DataNumeric(parent=self);
+                dataObj['unit'] = unit;
+            elif typename == "string":
+                dataObj = DataString(parent=self);
+            elif typename == "boolean":
+                dataObj = DataBoolean(parent=self);
+            elif typename == "dateTime":
+                dataObj = DataDateTime(parent=self);
+            elif typename == "timeSpan":
+                dataObj = DataTimeSpan(parent=self);
+            elif typename == "enum":
+                dataObj = DataEnum(parent=self);
+                dataObj['dataType'] = dataType;
+
+            dataObj['name'] = name;
+            dataObj['value'] = value;
+            dataObj['module'] = module;
+            dataObj['stringIds'] = stringIds;
+
+            if flags is not None:
+                dataObj._set_flags(flags);
+
+            self._datas.add(name)
+            self.iterables.append(dataObj)
+            return dataObj
+        return None
+
+    def del_data(self, name):
+        """
+        Remove a single data element.
+
+        Arguments:
+            data_name  -- The data element name to remove.
+        """
+        if name in self._datas:
+            datas = [i for i in self.iterables if isinstance(i, Field)]
+            for data in datas:
+                if data['name'] == name:
+                    self.xml.remove(data.xml)
+                    self.iterables.remove(data)
+                    return True
+        return False
+
+    def get_datas(self):
+        """ Return all data elements. """
+        datas = set()
+        for data in self['substanzas']:
+            if isinstance(data, Field):
+                datas.add(data)
+        return datas
+
+    def set_datas(self, datas):
+        """
+        Set or replace all data elements. The given elements must be in a
+        list or set where each item is a data element (numeric, string, boolean, dateTime, timeSpan or enum)
+
+        Arguments:
+            datas -- A series of data elements.
+        """
+        self.del_datas()
+        for data in datas:
+            self.add_data(typename=data._get_typename(), name=data['name'], value=data['value'], module=data['module'], stringIds=data['stringIds'], unit=data['unit'], dataType=data['dataType'], flags=data._get_flags())
+
+    def del_datas(self):
+        """Remove all data elements."""
+        self._datas = set()
+        datas = [i for i in self.iterables if isinstance(i, Field)]
+        for data in datas:
+            self.xml.remove(data.xml)
+            self.iterables.remove(data)
+
+class DataNumeric(Field):
+    """ 
+    Field data of type numeric. 
+    Note that the value is expressed as a string. 
+    """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'numeric'
+    plugin_attrib = name
+    interfaces = set(['value', 'unit']);
+    interfaces.update(Field.interfaces);
+
+    def _get_typename(self):
+        return "numeric"    
+
+class DataString(Field):
+    """ 
+    Field data of type string 
+    """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'string'
+    plugin_attrib = name
+    interfaces = set(['value']);
+    interfaces.update(Field.interfaces);
+
+    def _get_typename(self):
+        return "string"    
+
+class DataBoolean(Field):
+    """ 
+    Field data of type boolean.
+    Note that the value is expressed as a string. 
+    """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'boolean'
+    plugin_attrib = name
+    interfaces = set(['value']);
+    interfaces.update(Field.interfaces);
+
+    def _get_typename(self):
+        return "boolean"    
+
+class DataDateTime(Field):
+    """ 
+    Field data of type dateTime.
+    Note that the value is expressed as a string. 
+    """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'dateTime'
+    plugin_attrib = name
+    interfaces = set(['value']);
+    interfaces.update(Field.interfaces);
+
+    def _get_typename(self):
+        return "dateTime"    
+
+class DataTimeSpan(Field):
+    """ 
+    Field data of type timeSpan.
+    Note that the value is expressed as a string. 
+    """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'timeSpan'
+    plugin_attrib = name
+    interfaces = set(['value']);
+    interfaces.update(Field.interfaces);
+
+    def _get_typename(self):
+        return "timeSpan"    
+
+class DataEnum(Field):
+    """ 
+    Field data of type enum.
+    Note that the value is expressed as a string. 
+    """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'enum'
+    plugin_attrib = name
+    interfaces = set(['value', 'dataType']);
+    interfaces.update(Field.interfaces);
+
+    def _get_typename(self):
+        return "enum"    
+
+class Done(ElementBase):
+    """ Done element used to signal that all data has been transferred """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'done'
+    plugin_attrib = name
+    interfaces = set(['seqnr'])
+
+class Cancel(ElementBase):
+    """ Cancel element used to signal that a request shall be cancelled """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'cancel'
+    plugin_attrib = name
+    interfaces = set(['seqnr'])
+
+class Cancelled(ElementBase):
+    """ Cancelled element used to signal that cancellation is confirmed """
+    namespace = 'urn:xmpp:iot:sensordata'
+    name = 'cancelled'
+    plugin_attrib = name
+    interfaces = set(['seqnr'])
+
+
+register_stanza_plugin(Iq, Request)
+register_stanza_plugin(Request, RequestNode, iterable=True)
+register_stanza_plugin(Request, RequestField, iterable=True)
+
+register_stanza_plugin(Iq, Accepted)
+register_stanza_plugin(Message, Failure)
+register_stanza_plugin(Failure, Error)
+
+register_stanza_plugin(Iq, Rejected)
+
+register_stanza_plugin(Message, Fields)
+register_stanza_plugin(Fields, FieldsNode, iterable=True)
+register_stanza_plugin(FieldsNode, Timestamp, iterable=True)
+register_stanza_plugin(Timestamp, Field, iterable=True)
+register_stanza_plugin(Timestamp, DataNumeric, iterable=True)
+register_stanza_plugin(Timestamp, DataString, iterable=True)
+register_stanza_plugin(Timestamp, DataBoolean, iterable=True)
+register_stanza_plugin(Timestamp, DataDateTime, iterable=True)
+register_stanza_plugin(Timestamp, DataTimeSpan, iterable=True)
+register_stanza_plugin(Timestamp, DataEnum, iterable=True)
+
+register_stanza_plugin(Message, Started)
+
+register_stanza_plugin(Iq, Cancel)
+register_stanza_plugin(Iq, Cancelled)
diff --git a/sleekxmpp/plugins/xep_0323/timerreset.py b/sleekxmpp/plugins/xep_0323/timerreset.py
new file mode 100644
index 00000000..578f1efe
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0323/timerreset.py
@@ -0,0 +1,64 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+from threading import Thread, Event, Timer
+import time
+
+def TimerReset(*args, **kwargs):
+    """ Global function for Timer """
+    return _TimerReset(*args, **kwargs)
+
+
+class _TimerReset(Thread):
+    """Call a function after a specified number of seconds:
+
+    t = TimerReset(30.0, f, args=[], kwargs={})
+    t.start()
+    t.cancel() # stop the timer's action if it's still waiting
+    """
+
+    def __init__(self, interval, function, args=[], kwargs={}):
+        Thread.__init__(self)
+        self.interval = interval
+        self.function = function
+        self.args = args
+        self.kwargs = kwargs
+        self.finished = Event()
+        self.resetted = True
+
+    def cancel(self):
+        """Stop the timer if it hasn't finished yet"""
+        self.finished.set()
+
+    def run(self):
+        #print "Time: %s - timer running..." % time.asctime()
+
+        while self.resetted:
+            #print "Time: %s - timer waiting for timeout in %.2f..." % (time.asctime(), self.interval)
+            self.resetted = False
+            self.finished.wait(self.interval)
+
+        if not self.finished.isSet():
+            self.function(*self.args, **self.kwargs)
+        self.finished.set()
+        #print "Time: %s - timer finished!" % time.asctime()
+
+    def reset(self, interval=None):
+        """ Reset the timer """
+
+        if interval:
+            #print "Time: %s - timer resetting to %.2f..." % (time.asctime(), interval)
+            self.interval = interval
+        else:
+            #print "Time: %s - timer resetting..." % time.asctime()
+            pass
+
+        self.resetted = True
+        self.finished.set()
+        self.finished.clear()
diff --git a/sleekxmpp/plugins/xep_0325/__init__.py b/sleekxmpp/plugins/xep_0325/__init__.py
new file mode 100644
index 00000000..01c38dce
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0325/__init__.py
@@ -0,0 +1,18 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.base import register_plugin
+
+from sleekxmpp.plugins.xep_0325.control import XEP_0325
+from sleekxmpp.plugins.xep_0325 import stanza
+
+register_plugin(XEP_0325)
+
+xep_0325=XEP_0325
diff --git a/sleekxmpp/plugins/xep_0325/control.py b/sleekxmpp/plugins/xep_0325/control.py
new file mode 100644
index 00000000..e34eb2c2
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0325/control.py
@@ -0,0 +1,574 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import logging
+import time
+from threading import Thread, Timer, Lock
+
+from sleekxmpp.xmlstream import JID
+from sleekxmpp.xmlstream.handler import Callback
+from sleekxmpp.xmlstream.matcher import StanzaPath
+from sleekxmpp.plugins.base import BasePlugin
+from sleekxmpp.plugins.xep_0325 import stanza
+from sleekxmpp.plugins.xep_0325.stanza import Control
+
+
+log = logging.getLogger(__name__)
+
+
+class XEP_0325(BasePlugin):
+
+    """
+    XEP-0325: IoT Control 
+
+
+    Actuators are devices in sensor networks that can be controlled through 
+    the network and act with the outside world. In sensor networks and 
+    Internet of Things applications, actuators make it possible to automate 
+    real-world processes. 
+    This plugin implements a mechanism whereby actuators can be controlled 
+    in XMPP-based sensor networks, making it possible to integrate sensors 
+    and actuators of different brands, makes and models into larger 
+    Internet of Things applications.
+
+    Also see <http://xmpp.org/extensions/xep-0325.html>
+
+    Configuration Values:
+        threaded -- Indicates if communication with sensors should be threaded.
+                    Defaults to True.
+
+    Events:
+        Sensor side
+        -----------
+        Control Event:DirectSet    -- Received a control message
+        Control Event:SetReq       -- Received a control request
+
+        Client side
+        -----------
+        Control Event:SetResponse       -- Received a response to a 
+                                           control request, type result
+        Control Event:SetResponseError  -- Received a response to a 
+                                           control request, type error
+
+    Attributes:
+        threaded -- Indicates if command events should be threaded.
+                    Defaults to True.
+        sessions -- A dictionary or equivalent backend mapping
+                    session IDs to dictionaries containing data
+                    relevant to a request's session. This dictionary is used
+                    both by the client and sensor side. On client side, seqnr
+                    is used as key, while on sensor side, a session_id is used
+                    as key. This ensures that the two will not collide, so 
+                    one instance can be both client and sensor.
+        Sensor side
+        -----------
+        nodes    -- A dictionary mapping sensor nodes that are serviced through
+                    this XMPP instance to their device handlers ("drivers").
+        Client side
+        -----------
+        last_seqnr -- The last used sequence number (integer). One sequence of
+                    communication (e.g. -->request, <--accept, <--fields)
+                    between client and sensor is identified by a unique
+                    sequence number (unique between the client/sensor pair)
+
+    Methods:
+        plugin_init       -- Overrides base_plugin.plugin_init
+        post_init         -- Overrides base_plugin.post_init
+        plugin_end        -- Overrides base_plugin.plugin_end
+
+        Sensor side
+        -----------
+        register_node     -- Register a sensor as available from this XMPP 
+                             instance.
+
+        Client side
+        -----------
+        set_request       -- Initiates a control request to modify data in  
+                             sensor(s). Non-blocking, a callback function will
+                             be called when the sensor has responded.
+        set_command       -- Initiates a control command to modify data in  
+                             sensor(s). Non-blocking. The sensor(s) will not
+                             respond regardless of the result of the command,
+                             so no callback is made.
+
+    """
+
+    name = 'xep_0325'
+    description = 'XEP-0325 Internet of Things - Control'
+    dependencies = set(['xep_0030']) 
+    stanza = stanza
+
+
+    default_config = {
+        'threaded': True
+#        'session_db': None
+    }
+
+    def plugin_init(self):
+        """ Start the XEP-0325 plugin """
+
+        self.xmpp.register_handler(
+                Callback('Control Event:DirectSet',
+                    StanzaPath('message/set'),
+                    self._handle_direct_set))
+
+        self.xmpp.register_handler(
+                Callback('Control Event:SetReq',
+                    StanzaPath('iq@type=set/set'),
+                    self._handle_set_req))
+
+        self.xmpp.register_handler(
+                Callback('Control Event:SetResponse',
+                    StanzaPath('iq@type=result/setResponse'),
+                    self._handle_set_response))
+
+        self.xmpp.register_handler(
+                Callback('Control Event:SetResponseError',
+                    StanzaPath('iq@type=error/setResponse'),
+                    self._handle_set_response))
+
+        # Server side dicts
+        self.nodes = {};
+        self.sessions = {};
+
+        self.last_seqnr = 0;
+        self.seqnr_lock = Lock();
+
+        ## For testning only
+        self.test_authenticated_from = ""
+
+    def post_init(self):
+        """ Init complete. Register our features in Serivce discovery. """
+        BasePlugin.post_init(self)
+        self.xmpp['xep_0030'].add_feature(Control.namespace)
+        self.xmpp['xep_0030'].set_items(node=Control.namespace, items=tuple())
+
+    def _new_session(self):
+        """ Return a new session ID. """
+        return str(time.time()) + '-' + self.xmpp.new_id()
+
+    def plugin_end(self):
+        """ Stop the XEP-0325 plugin """
+        self.sessions.clear();
+        self.xmpp.remove_handler('Control Event:DirectSet')
+        self.xmpp.remove_handler('Control Event:SetReq')
+        self.xmpp.remove_handler('Control Event:SetResponse')
+        self.xmpp.remove_handler('Control Event:SetResponseError')
+        self.xmpp['xep_0030'].del_feature(feature=Control.namespace)
+        self.xmpp['xep_0030'].set_items(node=Control.namespace, items=tuple());
+
+
+    # =================================================================
+    # Sensor side (data provider) API
+
+    def register_node(self, nodeId, device, commTimeout, sourceId=None, cacheType=None):
+        """
+        Register a sensor/device as available for control requests/commands 
+        through this XMPP instance. 
+
+        The device object may by any custom implementation to support 
+        specific devices, but it must implement the functions:
+          has_control_field
+          set_control_fields
+        according to the interfaces shown in the example device.py file.
+
+        Arguments:
+            nodeId      -- The identifier for the device
+            device      -- The device object
+            commTimeout -- Time in seconds to wait between each callback from device during
+                           a data readout. Float.
+            sourceId    -- [optional] identifying the data source controlling the device
+            cacheType   -- [optional] narrowing down the search to a specific kind of node        
+        """
+        self.nodes[nodeId] = {"device": device, 
+                                "commTimeout": commTimeout,
+                                "sourceId": sourceId, 
+                                "cacheType": cacheType};
+
+    def _set_authenticated(self, auth=''):
+        """ Internal testing function """
+        self.test_authenticated_from = auth;
+
+    def _get_new_seqnr(self):
+        """ Returns a unique sequence number (unique across threads) """
+        self.seqnr_lock.acquire();
+        self.last_seqnr = self.last_seqnr + 1;
+        self.seqnr_lock.release();
+        return str(self.last_seqnr);
+
+    def _handle_set_req(self, iq):
+        """
+        Event handler for reception of an Iq with set req - this is a 
+        control request.
+
+        Verifies that 
+          - all the requested nodes are available
+            (if no nodes are specified in the request, assume all nodes)
+          - all the control fields are available from all requested nodes
+            (if no nodes are specified in the request, assume all nodes)
+
+        If the request passes verification, the control request is passed
+        to the devices (in a separate thread).
+        If the verification fails, a setResponse with error indication 
+        is sent.
+        """
+
+        error_msg = '';
+        req_ok = True;
+        missing_node = None;
+        missing_field = None;
+
+        # Authentication
+        if len(self.test_authenticated_from) > 0 and not iq['from'] == self.test_authenticated_from:
+            # Invalid authentication
+            req_ok = False;
+            error_msg = "Access denied";
+
+        # Nodes
+        process_nodes = [];
+        if len(iq['set']['nodes']) > 0:
+            for n in iq['set']['nodes']:
+                if not n['nodeId'] in self.nodes:
+                    req_ok = False;
+                    missing_node = n['nodeId'];
+                    error_msg = "Invalid nodeId " + n['nodeId'];
+            process_nodes = [n['nodeId'] for n in iq['set']['nodes']];
+        else:
+            process_nodes = self.nodes.keys();
+
+        # Fields - for control we need to find all in all devices, otherwise we reject
+        process_fields = [];
+        if len(iq['set']['datas']) > 0:
+            for f in iq['set']['datas']:
+                for node in self.nodes:
+                    if not self.nodes[node]["device"].has_control_field(f['name'], f._get_typename()):
+                        req_ok = False;
+                        missing_field = f['name'];
+                        error_msg = "Invalid field " + f['name'];
+                        break;
+            process_fields = [(f['name'], f._get_typename(), f['value']) for f in iq['set']['datas']];
+
+        if req_ok:
+            session = self._new_session();
+            self.sessions[session] = {"from": iq['from'], "to": iq['to'], "seqnr": iq['id']};
+            self.sessions[session]["commTimers"] = {};
+            self.sessions[session]["nodeDone"] = {};
+            # Flag that a reply is exected when we are done
+            self.sessions[session]["reply"] = True;
+
+            self.sessions[session]["node_list"] = process_nodes;
+            if self.threaded:
+                #print("starting thread")
+                tr_req = Thread(target=self._threaded_node_request, args=(session, process_fields))
+                tr_req.start()
+                #print("started thread")
+            else:
+                self._threaded_node_request(session, process_fields);
+
+        else:
+            iq.reply();
+            iq['type'] = 'error';
+            iq['setResponse']['responseCode'] = "NotFound";
+            if missing_node is not None:
+                iq['setResponse'].add_node(missing_node);
+            if missing_field is not None:
+                iq['setResponse'].add_data(missing_field);                
+            iq['setResponse']['error']['var'] = "Output";
+            iq['setResponse']['error']['text'] = error_msg;
+            iq.send(block=False);           
+
+    def _handle_direct_set(self, msg):
+        """
+        Event handler for reception of a Message with set command - this is a 
+        direct control command.
+
+        Verifies that 
+          - all the requested nodes are available
+            (if no nodes are specified in the request, assume all nodes)
+          - all the control fields are available from all requested nodes
+            (if no nodes are specified in the request, assume all nodes)
+
+        If the request passes verification, the control request is passed
+        to the devices (in a separate thread).
+        If the verification fails, do nothing.
+        """
+        req_ok = True;
+
+        # Nodes
+        process_nodes = [];
+        if len(msg['set']['nodes']) > 0:
+            for n in msg['set']['nodes']:
+                if not n['nodeId'] in self.nodes:
+                    req_ok = False;
+                    error_msg = "Invalid nodeId " + n['nodeId'];
+            process_nodes = [n['nodeId'] for n in msg['set']['nodes']];
+        else:
+            process_nodes = self.nodes.keys();
+
+        # Fields - for control we need to find all in all devices, otherwise we reject
+        process_fields = [];
+        if len(msg['set']['datas']) > 0:
+            for f in msg['set']['datas']:
+                for node in self.nodes:
+                    if not self.nodes[node]["device"].has_control_field(f['name'], f._get_typename()):
+                        req_ok = False;
+                        missing_field = f['name'];
+                        error_msg = "Invalid field " + f['name'];
+                        break;
+            process_fields = [(f['name'], f._get_typename(), f['value']) for f in msg['set']['datas']];
+
+        if req_ok:
+            session = self._new_session();
+            self.sessions[session] = {"from": msg['from'], "to": msg['to']};
+            self.sessions[session]["commTimers"] = {};
+            self.sessions[session]["nodeDone"] = {};
+            self.sessions[session]["reply"] = False;
+
+            self.sessions[session]["node_list"] = process_nodes;
+            if self.threaded:
+                #print("starting thread")
+                tr_req = Thread(target=self._threaded_node_request, args=(session, process_fields))
+                tr_req.start()
+                #print("started thread")
+            else:
+                self._threaded_node_request(session, process_fields);
+
+
+    def _threaded_node_request(self, session, process_fields):
+        """ 
+        Helper function to handle the device control in a separate thread.
+        
+        Arguments:
+            session         -- The request session id
+            process_fields  -- The fields to set in the devices. List of tuple format:
+                               (name, datatype, value)
+        """
+        for node in self.sessions[session]["node_list"]:
+            self.sessions[session]["nodeDone"][node] = False;
+
+        for node in self.sessions[session]["node_list"]:
+            timer = Timer(self.nodes[node]['commTimeout'], self._event_comm_timeout, args=(session, node));
+            self.sessions[session]["commTimers"][node] = timer;
+            timer.start();
+            self.nodes[node]['device'].set_control_fields(process_fields, session=session, callback=self._device_set_command_callback);
+
+    def _event_comm_timeout(self, session, nodeId):
+        """ 
+        Triggered if any of the control operations timeout.
+        Stop communicating with the failing device.
+        If the control command was an Iq request, sends a failure 
+        message back to the client. 
+        
+        Arguments:
+            session         -- The request session id
+            nodeId          -- The id of the device which timed out
+        """
+
+        if self.sessions[session]["reply"]:
+            # Reply is exected when we are done
+            iq = self.xmpp.Iq();
+            iq['from'] = self.sessions[session]['to'];
+            iq['to'] = self.sessions[session]['from'];
+            iq['type'] = "error";
+            iq['id'] = self.sessions[session]['seqnr'];
+            iq['setResponse']['responseCode'] = "OtherError";
+            iq['setResponse'].add_node(nodeId);
+            iq['setResponse']['error']['var'] = "Output";            
+            iq['setResponse']['error']['text'] = "Timeout.";
+            iq.send(block=False);
+
+        ## TODO - should we send one timeout per node??
+
+        # Drop communication with this device and check if we are done
+        self.sessions[session]["nodeDone"][nodeId] = True;
+        if (self._all_nodes_done(session)):
+            # The session is complete, delete it
+            del self.sessions[session];
+
+    def _all_nodes_done(self, session):
+        """ 
+        Checks wheter all devices are done replying to the control command.
+        
+        Arguments:
+            session         -- The request session id
+        """
+        for n in self.sessions[session]["nodeDone"]:
+            if not self.sessions[session]["nodeDone"][n]:
+                return False;
+        return True;
+
+    def _device_set_command_callback(self, session, nodeId, result, error_field=None, error_msg=None):
+        """ 
+        Callback function called by the devices when the control command is 
+        complete or failed.
+        If needed, composes a message with the result and sends it back to the 
+        client.
+        
+        Arguments:
+            session         -- The request session id
+            nodeId          -- The device id which initiated the callback
+            result          -- The current result status of the control command. Valid values are:
+                               "error"  - Set fields failed.
+                               "ok"     - All fields were set.
+            error_field      -- [optional] Only applies when result == "error" 
+                                The field name that failed (usually means it is missing)
+            error_msg        -- [optional] Only applies when result == "error".
+                                Error details when a request failed.
+        """
+
+        if not session in self.sessions:
+            # This can happend if a session was deleted, like in a timeout. Just drop the data.
+            return
+
+        if result == "error":
+            self.sessions[session]["commTimers"][nodeId].cancel();
+
+            if self.sessions[session]["reply"]:
+                # Reply is exected when we are done
+                iq = self.xmpp.Iq();
+                iq['from'] = self.sessions[session]['to'];
+                iq['to'] = self.sessions[session]['from'];
+                iq['type'] = "error";
+                iq['id'] = self.sessions[session]['seqnr'];
+                iq['setResponse']['responseCode'] = "OtherError";
+                iq['setResponse'].add_node(nodeId);
+                if error_field is not None:
+                    iq['setResponse'].add_data(error_field);
+                iq['setResponse']['error']['var'] = error_field;            
+                iq['setResponse']['error']['text'] = error_msg;
+                iq.send(block=False);
+
+                # Drop communication with this device and check if we are done
+                self.sessions[session]["nodeDone"][nodeId] = True;   
+                if (self._all_nodes_done(session)):
+                    # The session is complete, delete it
+                    del self.sessions[session];
+        else:
+            self.sessions[session]["commTimers"][nodeId].cancel();
+
+            self.sessions[session]["nodeDone"][nodeId] = True;
+            if (self._all_nodes_done(session)):
+                if self.sessions[session]["reply"]:
+                    # Reply is exected when we are done
+                    iq = self.xmpp.Iq();
+                    iq['from'] = self.sessions[session]['to'];
+                    iq['to'] = self.sessions[session]['from'];
+                    iq['type'] = "result";
+                    iq['id'] = self.sessions[session]['seqnr'];
+                    iq['setResponse']['responseCode'] = "OK";
+                    iq.send(block=False);
+
+                # The session is complete, delete it
+                del self.sessions[session];
+
+
+    # =================================================================
+    # Client side (data controller) API
+
+    def set_request(self, from_jid, to_jid, callback, fields, nodeIds=None):
+        """ 
+        Called on the client side to initiade a control request.
+        Composes a message with the request and sends it to the device(s).
+        Does not block, the callback will be called when the device(s) 
+        has responded.
+        
+        Arguments:
+            from_jid        -- The jid of the requester
+            to_jid          -- The jid of the device(s)
+            callback        -- The callback function to call when data is availble. 
+                            
+                            The callback function must support the following arguments:
+
+                from_jid    -- The jid of the responding device(s)
+                result      -- The result of the control request. Valid values are:
+                               "OK"             - Control request completed successfully
+                               "NotFound"       - One or more nodes or fields are missing
+                               "InsufficientPrivileges" - Not authorized.
+                               "Locked"         - Field(s) is locked and cannot
+                                                  be changed at the moment.
+                               "NotImplemented" - Request feature not implemented.
+                               "FormError"      - Error while setting with 
+                                                  a form (not implemented).
+                               "OtherError"     - Indicates other types of 
+                                                  errors, such as timeout. 
+                                                  Details in the error_msg.
+                           
+
+                nodeId      -- [optional] Only applicable when result == "error" 
+                               List of node Ids of failing device(s). 
+
+                fields      -- [optional] Only applicable when result == "error" 
+                               List of fields that failed.[optional] Mandatory when result == "rejected" or "failure".
+                
+                error_msg   -- Details about why the request failed. 
+
+            fields          -- Fields to set. List of tuple format: (name, typename, value).
+            nodeIds         -- [optional] Limits the request to the node Ids in this list.
+        """
+        iq = self.xmpp.Iq();
+        iq['from'] = from_jid;
+        iq['to'] = to_jid;
+        seqnr = self._get_new_seqnr();
+        iq['id'] = seqnr;
+        iq['type'] = "set";
+        if nodeIds is not None:
+            for nodeId in nodeIds:
+                iq['set'].add_node(nodeId);
+        if fields is not None:
+            for name, typename, value in fields:
+                iq['set'].add_data(name=name, typename=typename, value=value);
+
+        self.sessions[seqnr] = {"from": iq['from'], "to": iq['to'], "callback": callback};
+        iq.send(block=False); 
+
+    def set_command(self, from_jid, to_jid, fields, nodeIds=None):
+        """ 
+        Called on the client side to initiade a control command.
+        Composes a message with the set commandand sends it to the device(s).
+        Does not block. Device(s) will not respond, regardless of result.
+        
+        Arguments:
+            from_jid        -- The jid of the requester
+            to_jid          -- The jid of the device(s)
+
+            fields          -- Fields to set. List of tuple format: (name, typename, value).
+            nodeIds         -- [optional] Limits the request to the node Ids in this list.
+        """
+        msg = self.xmpp.Message();
+        msg['from'] = from_jid;
+        msg['to'] = to_jid;
+        msg['type'] = "set";
+        if nodeIds is not None:
+            for nodeId in nodeIds:
+                msg['set'].add_node(nodeId);
+        if fields is not None:
+            for name, typename, value in fields:
+                msg['set'].add_data(name, typename, value);
+
+        # We won't get any reply, so don't create a session
+        msg.send(); 
+
+    def _handle_set_response(self, iq):
+        """ Received response from device(s) """
+        #print("ooh")
+        seqnr = iq['id'];
+        from_jid = str(iq['from']);
+        result = iq['setResponse']['responseCode'];
+        nodeIds = [n['name'] for n in iq['setResponse']['nodes']];
+        fields = [f['name'] for f in iq['setResponse']['datas']];
+        error_msg = None;
+
+        if not iq['setResponse'].find('error') is None and not iq['setResponse']['error']['text'] == "":
+            error_msg = iq['setResponse']['error']['text'];
+
+        callback = self.sessions[seqnr]["callback"];
+        callback(from_jid=from_jid, result=result, nodeIds=nodeIds, fields=fields, error_msg=error_msg);
+
+    
diff --git a/sleekxmpp/plugins/xep_0325/device.py b/sleekxmpp/plugins/xep_0325/device.py
new file mode 100644
index 00000000..1cb99510
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0325/device.py
@@ -0,0 +1,125 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import datetime
+
+class Device(object):
+	"""
+	Example implementation of a device control object.
+    
+    The device object may by any custom implementation to support 
+    specific devices, but it must implement the functions:
+          has_control_field
+          set_control_fields
+	"""
+
+	def __init__(self, nodeId):
+		self.nodeId = nodeId;
+		self.control_fields = {};
+
+	def has_control_field(self, field, typename):
+		"""
+		Returns true if the supplied field name exists
+		and the type matches for control in this device.
+
+        Arguments:
+            field      -- The field name		
+            typename   -- The expected type
+		"""
+		if field in self.control_fields and self.control_fields[field]["type"] == typename:
+			return True;
+		return False;
+
+	def set_control_fields(self, fields, session, callback):
+		"""
+		Starts a control setting procedure. Verifies the fields,
+		sets the data and (if needed) and calls the callback.
+
+        Arguments:
+            fields   -- List of control fields in tuple format: 
+                        (name, typename, value)
+            session  -- Session id, only used in the callback as identifier
+            callback -- Callback function to call when control set is complete.
+
+					The callback function must support the following arguments:
+
+				session     -- Session id, as supplied in the 
+				               request_fields call
+				nodeId      -- Identifier for this device
+            	result      -- The current result status of the readout. 
+            	               Valid values are:
+                               "error"  - Set fields failed.
+                               "ok"     - All fields were set.
+	            error_field -- [optional] Only applies when result == "error" 
+    	                       The field name that failed 
+    	                       (usually means it is missing)
+        	    error_msg   -- [optional] Only applies when result == "error".
+            	               Error details when a request failed.
+		"""
+
+		if len(fields) > 0:
+			# Check availiability
+			for name, typename, value in fields:
+				if not self.has_control_field(name, typename):
+					self._send_control_reject(session, name, "NotFound", callback)
+					return False;
+
+		for name, typename, value in fields:
+			self._set_field_value(name, value)
+
+		callback(session, result="ok", nodeId=self.nodeId);
+		return True
+
+	def _send_control_reject(self, session, field, message, callback):
+		"""
+		Sends a reject to the caller
+
+        Arguments:
+            session  -- Session id, see definition in 
+                        set_control_fields function
+            callback -- Callback function, see definition in 
+                        set_control_fields function
+		"""
+		callback(session, result="error", nodeId=self.nodeId, error_field=field, error_msg=message);
+
+	def _add_control_field(self, name, typename, value):
+		"""
+		Adds a control field to the device
+
+        Arguments:
+            name     -- Name of the field
+            typename -- Type of the field, one of: 
+                        (boolean, color, string, date, dateTime, 
+                         double, duration, int, long, time)
+            value    -- Field value
+		"""
+		self.control_fields[name] = {"type": typename, "value": value};
+
+	def _set_field_value(self, name, value):
+		"""
+		Set the value of a control field
+
+        Arguments:
+            name     -- Name of the field
+            value    -- New value for the field
+		"""
+		if name in self.control_fields:
+			self.control_fields[name]["value"] = value;
+
+	def _get_field_value(self, name):
+		"""
+		Get the value of a control field. Only used for unit testing.
+
+        Arguments:
+            name     -- Name of the field
+		"""
+		if name in self.control_fields:
+			return self.control_fields[name]["value"];
+		return None;
diff --git a/sleekxmpp/plugins/xep_0325/stanza/__init__.py b/sleekxmpp/plugins/xep_0325/stanza/__init__.py
new file mode 100644
index 00000000..746c2033
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0325/stanza/__init__.py
@@ -0,0 +1,12 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.plugins.xep_0325.stanza.control import *
+
diff --git a/sleekxmpp/plugins/xep_0325/stanza/base.py b/sleekxmpp/plugins/xep_0325/stanza/base.py
new file mode 100644
index 00000000..1dadcf46
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0325/stanza/base.py
@@ -0,0 +1,13 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.xmlstream import ET
+
+pass
diff --git a/sleekxmpp/plugins/xep_0325/stanza/control.py b/sleekxmpp/plugins/xep_0325/stanza/control.py
new file mode 100644
index 00000000..2707191f
--- /dev/null
+++ b/sleekxmpp/plugins/xep_0325/stanza/control.py
@@ -0,0 +1,526 @@
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp import Iq, Message
+from sleekxmpp.xmlstream import register_stanza_plugin, ElementBase, ET, JID
+from re import match
+
+class Control(ElementBase):
+    """ Placeholder for the namespace, not used as a stanza """
+    namespace = 'urn:xmpp:iot:control'
+    name = 'control'
+    plugin_attrib = name
+    interfaces = set(tuple())
+
+class ControlSet(ElementBase):
+    namespace = 'urn:xmpp:iot:control'
+    name = 'set'
+    plugin_attrib = name
+    interfaces = set(['nodes','datas'])
+
+    def __init__(self, xml=None, parent=None):
+        ElementBase.__init__(self, xml, parent);
+        self._nodes = set()
+        self._datas = set()
+
+    def setup(self, xml=None):
+        """
+        Populate the stanza object using an optional XML object.
+
+        Overrides ElementBase.setup
+
+        Caches item information.
+
+        Arguments:
+            xml -- Use an existing XML object for the stanza's values.
+        """
+        ElementBase.setup(self, xml)
+        self._nodes = set([node['nodeId'] for node in self['nodes']])
+        self._datas = set([data['name'] for data in self['datas']])
+
+    def add_node(self, nodeId, sourceId=None, cacheType=None):
+        """
+        Add a new node element. Each item is required to have a
+        nodeId, but may also specify a sourceId value and cacheType.
+
+        Arguments:
+            nodeId    -- The ID for the node.
+            sourceId  -- [optional] identifying the data source controlling the device
+            cacheType -- [optional] narrowing down the search to a specific kind of node        
+        """
+        if nodeId not in self._nodes:
+            self._nodes.add((nodeId))
+            node = RequestNode(parent=self)
+            node['nodeId'] = nodeId
+            node['sourceId'] = sourceId
+            node['cacheType'] = cacheType
+            self.iterables.append(node)
+            return node
+        return None
+
+    def del_node(self, nodeId):
+        """
+        Remove a single node.
+
+        Arguments:
+            nodeId  -- Node ID of the item to remove.
+        """
+        if nodeId in self._nodes:
+            nodes = [i for i in self.iterables if isinstance(i, RequestNode)]
+            for node in nodes:
+                if node['nodeId'] == nodeId:
+                    self.xml.remove(node.xml)
+                    self.iterables.remove(node)
+                    return True
+        return False
+
+    def get_nodes(self):
+        """Return all nodes."""
+        nodes = set()
+        for node in self['substanzas']:
+            if isinstance(node, RequestNode):
+                nodes.add(node)
+        return nodes
+
+    def set_nodes(self, nodes):
+        """
+        Set or replace all nodes. The given nodes must be in a
+        list or set where each item is a tuple of the form:
+            (nodeId, sourceId, cacheType)
+
+        Arguments:
+            nodes -- A series of nodes in tuple format.
+        """
+        self.del_nodes()
+        for node in nodes:
+            if isinstance(node, RequestNode):
+                self.add_node(node['nodeId'], node['sourceId'], node['cacheType'])
+            else:
+                nodeId, sourceId, cacheType = node
+                self.add_node(nodeId, sourceId, cacheType)
+
+    def del_nodes(self):
+        """Remove all nodes."""
+        self._nodes = set()
+        nodes = [i for i in self.iterables if isinstance(i, RequestNode)]
+        for node in nodes:
+            self.xml.remove(node.xml)
+            self.iterables.remove(node)
+
+
+    def add_data(self, name, typename, value):
+        """
+        Add a new data element. 
+
+        Arguments:
+            name       -- The name of the data element
+            typename   -- The type of data element 
+                          (boolean, color, string, date, dateTime, 
+                           double, duration, int, long, time)
+            value      -- The value of the data element
+        """
+        if name not in self._datas:
+            dataObj = None;
+            if typename == "boolean":
+                dataObj = BooleanParameter(parent=self);
+            elif typename == "color":
+                dataObj = ColorParameter(parent=self);
+            elif typename == "string":
+                dataObj = StringParameter(parent=self);
+            elif typename == "date":
+                dataObj = DateParameter(parent=self);
+            elif typename == "dateTime":
+                dataObj = DateTimeParameter(parent=self);
+            elif typename == "double":
+                dataObj = DoubleParameter(parent=self);
+            elif typename == "duration":
+                dataObj = DurationParameter(parent=self);
+            elif typename == "int":
+                dataObj = IntParameter(parent=self);
+            elif typename == "long":
+                dataObj = LongParameter(parent=self);
+            elif typename == "time":
+                dataObj = TimeParameter(parent=self);
+
+            dataObj['name'] = name;
+            dataObj['value'] = value;
+
+            self._datas.add(name)
+            self.iterables.append(dataObj)
+            return dataObj
+        return None
+
+    def del_data(self, name):
+        """
+        Remove a single data element.
+
+        Arguments:
+            data_name  -- The data element name to remove.
+        """
+        if name in self._datas:
+            datas = [i for i in self.iterables if isinstance(i, BaseParameter)]
+            for data in datas:
+                if data['name'] == name:
+                    self.xml.remove(data.xml)
+                    self.iterables.remove(data)
+                    return True
+        return False
+
+    def get_datas(self):
+        """ Return all data elements. """
+        datas = set()
+        for data in self['substanzas']:
+            if isinstance(data, BaseParameter):
+                datas.add(data)
+        return datas
+
+    def set_datas(self, datas):
+        """
+        Set or replace all data elements. The given elements must be in a
+        list or set where each item is a data element (numeric, string, boolean, dateTime, timeSpan or enum)
+
+        Arguments:
+            datas -- A series of data elements.
+        """
+        self.del_datas()
+        for data in datas:
+            self.add_data(name=data['name'], typename=data._get_typename(), value=data['value'])
+
+    def del_datas(self):
+        """Remove all data elements."""
+        self._datas = set()
+        datas = [i for i in self.iterables if isinstance(i, BaseParameter)]
+        for data in datas:
+            self.xml.remove(data.xml)
+            self.iterables.remove(data)
+
+
+class RequestNode(ElementBase):
+    """ Node element in a request """
+    namespace = 'urn:xmpp:iot:control'
+    name = 'node'
+    plugin_attrib = name
+    interfaces = set(['nodeId','sourceId','cacheType'])
+
+
+class ControlSetResponse(ElementBase):
+    namespace = 'urn:xmpp:iot:control'
+    name = 'setResponse'
+    plugin_attrib = name
+    interfaces = set(['responseCode'])
+
+    def __init__(self, xml=None, parent=None):
+        ElementBase.__init__(self, xml, parent);
+        self._nodes = set()
+        self._datas = set()
+
+    def setup(self, xml=None):
+        """
+        Populate the stanza object using an optional XML object.
+
+        Overrides ElementBase.setup
+
+        Caches item information.
+
+        Arguments:
+            xml -- Use an existing XML object for the stanza's values.
+        """
+        ElementBase.setup(self, xml)
+        self._nodes = set([node['nodeId'] for node in self['nodes']])
+        self._datas = set([data['name'] for data in self['datas']])
+
+    def add_node(self, nodeId, sourceId=None, cacheType=None):
+        """
+        Add a new node element. Each item is required to have a
+        nodeId, but may also specify a sourceId value and cacheType.
+
+        Arguments:
+            nodeId    -- The ID for the node.
+            sourceId  -- [optional] identifying the data source controlling the device
+            cacheType -- [optional] narrowing down the search to a specific kind of node        
+        """
+        if nodeId not in self._nodes:
+            self._nodes.add(nodeId)
+            node = RequestNode(parent=self)
+            node['nodeId'] = nodeId
+            node['sourceId'] = sourceId
+            node['cacheType'] = cacheType
+            self.iterables.append(node)
+            return node
+        return None
+
+    def del_node(self, nodeId):
+        """
+        Remove a single node.
+
+        Arguments:
+            nodeId  -- Node ID of the item to remove.
+        """
+        if nodeId in self._nodes:
+            nodes = [i for i in self.iterables if isinstance(i, RequestNode)]
+            for node in nodes:
+                if node['nodeId'] == nodeId:
+                    self.xml.remove(node.xml)
+                    self.iterables.remove(node)
+                    return True
+        return False
+
+    def get_nodes(self):
+        """Return all nodes."""
+        nodes = set()
+        for node in self['substanzas']:
+            if isinstance(node, RequestNode):
+                nodes.add(node)
+        return nodes
+
+    def set_nodes(self, nodes):
+        """
+        Set or replace all nodes. The given nodes must be in a
+        list or set where each item is a tuple of the form:
+            (nodeId, sourceId, cacheType)
+
+        Arguments:
+            nodes -- A series of nodes in tuple format.
+        """
+        self.del_nodes()
+        for node in nodes:
+            if isinstance(node, RequestNode):
+                self.add_node(node['nodeId'], node['sourceId'], node['cacheType'])
+            else:
+                nodeId, sourceId, cacheType = node
+                self.add_node(nodeId, sourceId, cacheType)
+
+    def del_nodes(self):
+        """Remove all nodes."""
+        self._nodes = set()
+        nodes = [i for i in self.iterables if isinstance(i, RequestNode)]
+        for node in nodes:
+            self.xml.remove(node.xml)
+            self.iterables.remove(node)
+
+
+    def add_data(self, name):
+        """
+        Add a new ResponseParameter element. 
+
+        Arguments:
+            name   -- Name of the parameter
+        """
+        if name not in self._datas:
+            self._datas.add(name)
+            data = ResponseParameter(parent=self)
+            data['name'] = name;
+            self.iterables.append(data)
+            return data
+        return None
+
+    def del_data(self, name):
+        """
+        Remove a single ResponseParameter element.
+
+        Arguments:
+            name  -- The data element name to remove.
+        """
+        if name in self._datas:
+            datas = [i for i in self.iterables if isinstance(i, ResponseParameter)]
+            for data in datas:
+                if data['name'] == name:
+                    self.xml.remove(data.xml)
+                    self.iterables.remove(data)
+                    return True
+        return False
+
+    def get_datas(self):
+        """ Return all ResponseParameter elements. """
+        datas = set()
+        for data in self['substanzas']:
+            if isinstance(data, ResponseParameter):
+                datas.add(data)
+        return datas
+
+    def set_datas(self, datas):
+        """
+        Set or replace all data elements. The given elements must be in a
+        list or set of ResponseParameter elements
+
+        Arguments:
+            datas -- A series of data element names.
+        """
+        self.del_datas()
+        for data in datas:
+            self.add_data(name=data['name'])
+
+    def del_datas(self):
+        """Remove all ResponseParameter elements."""
+        self._datas = set()
+        datas = [i for i in self.iterables if isinstance(i, ResponseParameter)]
+        for data in datas:
+            self.xml.remove(data.xml)
+            self.iterables.remove(data)
+
+
+class Error(ElementBase):
+    namespace = 'urn:xmpp:iot:control'
+    name = 'error'
+    plugin_attrib = name
+    interfaces = set(['var','text'])
+
+    def get_text(self):
+        """Return then contents inside the XML tag."""
+        return self.xml.text
+
+    def set_text(self, value):
+        """Set then contents inside the XML tag.
+
+        Arguments:
+            value -- string
+        """
+
+        self.xml.text = value;
+        return self
+
+    def del_text(self):
+        """Remove the contents inside the XML tag."""
+        self.xml.text = ""
+        return self    
+
+class ResponseParameter(ElementBase):
+    """ 
+    Parameter element in ControlSetResponse. 
+    """    
+    namespace = 'urn:xmpp:iot:control'
+    name = 'parameter'
+    plugin_attrib = name
+    interfaces = set(['name']);
+
+
+class BaseParameter(ElementBase):
+    """ 
+    Parameter element in SetCommand. This is a base class,
+    all instances of parameters added to SetCommand must be of types:
+        BooleanParameter
+        ColorParameter
+        StringParameter
+        DateParameter
+        DateTimeParameter
+        DoubleParameter
+        DurationParameter
+        IntParameter
+        LongParameter
+        TimeParameter
+    """    
+    namespace = 'urn:xmpp:iot:control'
+    name = 'baseParameter'
+    plugin_attrib = name
+    interfaces = set(['name','value']);
+
+    def _get_typename(self):
+        return self.name;
+
+class BooleanParameter(BaseParameter):
+    """ 
+    Field data of type boolean. 
+    Note that the value is expressed as a string. 
+    """
+    name = 'boolean'
+    plugin_attrib = name
+
+class ColorParameter(BaseParameter):
+    """ 
+    Field data of type color. 
+    Note that the value is expressed as a string. 
+    """
+    name = 'color'
+    plugin_attrib = name
+
+class StringParameter(BaseParameter):
+    """ 
+    Field data of type string. 
+    """
+    name = 'string'
+    plugin_attrib = name
+
+class DateParameter(BaseParameter):
+    """ 
+    Field data of type date. 
+    Note that the value is expressed as a string. 
+    """
+    name = 'date'
+    plugin_attrib = name
+
+class DateTimeParameter(BaseParameter):
+    """ 
+    Field data of type dateTime. 
+    Note that the value is expressed as a string. 
+    """
+    name = 'dateTime'
+    plugin_attrib = name
+
+class DoubleParameter(BaseParameter):
+    """ 
+    Field data of type double. 
+    Note that the value is expressed as a string. 
+    """
+    name = 'double'
+    plugin_attrib = name
+
+class DurationParameter(BaseParameter):
+    """ 
+    Field data of type duration. 
+    Note that the value is expressed as a string. 
+    """
+    name = 'duration'
+    plugin_attrib = name
+
+class IntParameter(BaseParameter):
+    """ 
+    Field data of type int. 
+    Note that the value is expressed as a string. 
+    """
+    name = 'int'
+    plugin_attrib = name
+
+class LongParameter(BaseParameter):
+    """ 
+    Field data of type long (64-bit int). 
+    Note that the value is expressed as a string. 
+    """
+    name = 'long'
+    plugin_attrib = name
+
+class TimeParameter(BaseParameter):
+    """ 
+    Field data of type time. 
+    Note that the value is expressed as a string. 
+    """
+    name = 'time'
+    plugin_attrib = name
+
+register_stanza_plugin(Iq, ControlSet)
+register_stanza_plugin(Message, ControlSet)
+
+register_stanza_plugin(ControlSet, RequestNode, iterable=True)
+
+register_stanza_plugin(ControlSet, BooleanParameter, iterable=True)
+register_stanza_plugin(ControlSet, ColorParameter, iterable=True)
+register_stanza_plugin(ControlSet, StringParameter, iterable=True)
+register_stanza_plugin(ControlSet, DateParameter, iterable=True)
+register_stanza_plugin(ControlSet, DateTimeParameter, iterable=True)
+register_stanza_plugin(ControlSet, DoubleParameter, iterable=True)
+register_stanza_plugin(ControlSet, DurationParameter, iterable=True)
+register_stanza_plugin(ControlSet, IntParameter, iterable=True)
+register_stanza_plugin(ControlSet, LongParameter, iterable=True)
+register_stanza_plugin(ControlSet, TimeParameter, iterable=True)
+
+register_stanza_plugin(Iq, ControlSetResponse)
+register_stanza_plugin(ControlSetResponse, Error)
+register_stanza_plugin(ControlSetResponse, RequestNode, iterable=True)
+register_stanza_plugin(ControlSetResponse, ResponseParameter, iterable=True)
+
diff --git a/tests/test_stanza_xep_0323.py b/tests/test_stanza_xep_0323.py
new file mode 100644
index 00000000..67e0daf0
--- /dev/null
+++ b/tests/test_stanza_xep_0323.py
@@ -0,0 +1,393 @@
+# -*- coding: utf-8 -*-
+
+from sleekxmpp.test import *
+import sleekxmpp.plugins.xep_0323 as xep_0323
+
+namespace='sn'
+
+class TestSensorDataStanzas(SleekTest):
+    
+
+    def setUp(self):
+        pass
+        #register_stanza_plugin(Iq, xep_0323.stanza.Request)
+        #register_stanza_plugin(Iq, xep_0323.stanza.Accepted)
+        #register_stanza_plugin(Message, xep_0323.stanza.Failure)
+        #register_stanza_plugin(xep_0323.stanza.Failure, xep_0323.stanza.Error)
+        #register_stanza_plugin(Iq, xep_0323.stanza.Rejected)
+        #register_stanza_plugin(Message, xep_0323.stanza.Fields)
+        #register_stanza_plugin(Message, xep_0323.stanza.Request)
+        #register_stanza_plugin(Message, xep_0323.stanza.Accepted)
+        #register_stanza_plugin(Message, xep_0323.stanza.Failure)
+        # register_stanza_plugin(Message, xep_0323.stanza.Result)
+        # register_stanza_plugin(Message, xep_0323.stanza.Gone)
+        # register_stanza_plugin(Message, xep_0323.stanza.Inactive)
+        # register_stanza_plugin(Message, xep_0323.stanza.Paused)
+
+    def testRequest(self):
+        """
+        test of request stanza
+        """
+        iq = self.Iq()
+        iq['type'] = 'get'
+        iq['from'] = 'master@clayster.com/amr'
+        iq['to'] = 'device@clayster.com'
+        iq['id'] = '1'
+        iq['req']['seqnr'] = '1'
+        iq['req']['momentary'] = 'true'
+
+        self.check(iq,"""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true'/>
+            </iq>
+        """
+            )
+
+    def testRequestNodes(self):
+        """
+        test of request nodes stanza
+        """
+        iq = self.Iq()
+        iq['type'] = 'get'
+        iq['from'] = 'master@clayster.com/amr'
+        iq['to'] = 'device@clayster.com'
+        iq['id'] = '1'
+        iq['req']['seqnr'] = '1'
+        iq['req']['momentary'] = 'true'
+
+
+        iq['req'].add_node("Device02", "Source02", "CacheType");
+        iq['req'].add_node("Device44");
+
+        self.check(iq,"""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true'>
+                    <node nodeId='Device02' sourceId='Source02' cacheType='CacheType'/>
+                    <node nodeId='Device44'/>
+                </req>
+            </iq>
+        """
+            )
+
+        iq['req'].del_node("Device02");
+
+        self.check(iq,"""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true'>
+                    <node nodeId='Device44'/>
+                </req>
+            </iq>
+        """
+            )
+
+        iq['req'].del_nodes();
+
+        self.check(iq,"""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true'>
+                </req>
+            </iq>
+        """
+            )
+
+    def testRequestField(self):
+        """
+        test of request field stanza
+        """
+        iq = self.Iq()
+        iq['type'] = 'get'
+        iq['from'] = 'master@clayster.com/amr'
+        iq['to'] = 'device@clayster.com'
+        iq['id'] = '1'
+        iq['req']['seqnr'] = '1'
+        iq['req']['momentary'] = 'true'
+
+
+        iq['req'].add_field("Top temperature");
+        iq['req'].add_field("Bottom temperature");
+
+        self.check(iq,"""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true'>
+                    <field name='Top temperature'/>
+                    <field name='Bottom temperature'/>
+                </req>
+            </iq>
+        """
+            )
+
+        iq['req'].del_field("Top temperature")
+
+        self.check(iq,"""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true'>
+                    <field name='Bottom temperature'/>
+                </req>
+            </iq>
+        """
+            )
+
+        iq['req'].del_fields()
+
+        self.check(iq,"""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true'>
+                </req>
+            </iq>
+        """
+            )
+
+
+    def testAccepted(self):
+        """
+        test of request stanza
+        """
+        iq = self.Iq()
+        iq['type'] = 'result'
+        iq['from'] = 'device@clayster.com'
+        iq['to'] = 'master@clayster.com/amr'
+        iq['id'] = '2'
+        iq['accepted']['seqnr'] = '2'
+
+        self.check(iq,"""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='2'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='2'/>
+            </iq>
+        """
+            )
+
+    def testRejected(self):
+        """
+        test of request stanza
+        """
+        iq = self.Iq()
+        iq['type'] = 'error'
+        iq['from'] = 'device@clayster.com'
+        iq['to'] = 'master@clayster.com/amr'
+        iq['id'] = '4'
+        iq['rejected']['seqnr'] = '4'
+        iq['rejected']['error'] = 'Access denied.'
+
+        self.check(iq,"""
+            <iq type='error' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='4'>
+                <rejected xmlns='urn:xmpp:iot:sensordata' seqnr='4'>
+                    <error>Access denied.</error>
+                </rejected>
+            </iq>
+        """
+            )
+
+    def testFailure(self):
+        """
+        test of failure stanza
+        """
+        msg = self.Message()
+        msg['from'] = 'device@clayster.com'
+        msg['to'] = 'master@clayster.com/amr'
+        msg['failure']['seqnr'] = '3'
+        msg['failure']['done'] = 'true'
+        msg['failure']['error']['nodeId'] = 'Device01'
+        msg['failure']['error']['timestamp'] = '2013-03-07T17:13:30'
+        msg['failure']['error']['text'] = 'Timeout.'
+
+        self.check(msg,"""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <failure xmlns='urn:xmpp:iot:sensordata' seqnr='3' done='true'>
+                    <error nodeId='Device01' timestamp='2013-03-07T17:13:30'>
+                        Timeout.</error>
+                </failure>
+            </message>
+        """
+            )
+
+    def testFields(self):
+        """
+        test of fields stanza
+        """
+        msg = self.Message()
+        msg['from'] = 'device@clayster.com'
+        msg['to'] = 'master@clayster.com/amr'
+        msg['fields']['seqnr'] = '1'
+
+        node = msg['fields'].add_node("Device02");
+        ts = node.add_timestamp("2013-03-07T16:24:30");
+
+        data = ts.add_data(typename="numeric", name="Temperature", value="-12.42", unit='K');
+        data['momentary'] = 'true';
+        data['automaticReadout'] = 'true';
+
+        self.check(msg,"""
+            <message from='device@clayster.com'
+                    to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId='Device02'>
+                        <timestamp value='2013-03-07T16:24:30'>
+                            <numeric name='Temperature' momentary='true' automaticReadout='true' value='-12.42' unit='K'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>
+                       """
+            )
+
+        node = msg['fields'].add_node("EmptyDevice");
+        node = msg['fields'].add_node("Device04");
+        ts = node.add_timestamp("EmptyTimestamp");
+
+
+        self.check(msg,"""
+            <message from='device@clayster.com'
+                    to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId='Device02'>
+                        <timestamp value='2013-03-07T16:24:30'>
+                            <numeric name='Temperature' momentary='true' automaticReadout='true' value='-12.42' unit='K'/> 
+                        </timestamp>
+                    </node>
+                    <node nodeId='EmptyDevice'/>
+                    <node nodeId='Device04'>
+                        <timestamp value='EmptyTimestamp'/>
+                    </node>
+                </fields>
+            </message>
+                       """
+            )
+
+        node = msg['fields'].add_node("Device77");
+        ts = node.add_timestamp("2013-05-03T12:00:01");
+        data = ts.add_data(typename="numeric", name="Temperature", value="-12.42", unit='K');
+        data['historicalDay'] = 'true';
+        data = ts.add_data(typename="numeric", name="Speed", value="312.42", unit='km/h');
+        data['historicalWeek'] = 'false';
+        data = ts.add_data(typename="string", name="Temperature name", value="Bottom oil");
+        data['historicalMonth'] = 'true';
+        data = ts.add_data(typename="string", name="Speed name", value="Top speed");
+        data['historicalQuarter'] = 'false';
+        data = ts.add_data(typename="dateTime", name="T1", value="1979-01-01T00:00:00");
+        data['historicalYear'] = 'true';
+        data = ts.add_data(typename="dateTime", name="T2", value="2000-01-01T01:02:03");
+        data['historicalOther'] = 'false';
+        data = ts.add_data(typename="timeSpan", name="TS1", value="P5Y");
+        data['missing'] = 'true';
+        data = ts.add_data(typename="timeSpan", name="TS2", value="PT2M1S");
+        data['manualEstimate'] = 'false';
+        data = ts.add_data(typename="enum", name="top color", value="red", dataType="string");
+        data['invoiced'] = 'true';
+        data = ts.add_data(typename="enum", name="bottom color", value="black", dataType="string");
+        data['powerFailure'] = 'false';
+        data = ts.add_data(typename="boolean", name="Temperature real", value="false");
+        data['historicalDay'] = 'true';
+        data = ts.add_data(typename="boolean", name="Speed real", value="true");
+        data['historicalWeek'] = 'false';
+
+        self.check(msg,"""
+            <message from='device@clayster.com'
+                    to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId='Device02'>
+                        <timestamp value='2013-03-07T16:24:30'>
+                            <numeric name='Temperature' momentary='true' automaticReadout='true' value='-12.42' unit='K'/> 
+                        </timestamp>
+                    </node>
+                    <node nodeId='EmptyDevice'/>
+                    <node nodeId='Device04'>
+                        <timestamp value='EmptyTimestamp'/>
+                    </node>
+                    <node nodeId='Device77'>
+                        <timestamp value='2013-05-03T12:00:01'>
+                            <numeric name='Temperature' historicalDay='true' value='-12.42' unit='K'/> 
+                            <numeric name='Speed' historicalWeek='false' value='312.42' unit='km/h'/> 
+                            <string name='Temperature name' historicalMonth='true' value='Bottom oil'/> 
+                            <string name='Speed name' historicalQuarter='false' value='Top speed'/> 
+                            <dateTime name='T1' historicalYear='true' value='1979-01-01T00:00:00'/> 
+                            <dateTime name='T2' historicalOther='false' value='2000-01-01T01:02:03'/> 
+                            <timeSpan name='TS1' missing='true' value='P5Y'/> 
+                            <timeSpan name='TS2' manualEstimate='false' value='PT2M1S'/> 
+                            <enum name='top color' invoiced='true' value='red' dataType='string'/> 
+                            <enum name='bottom color' powerFailure='false' value='black' dataType='string'/> 
+                            <boolean name='Temperature real' historicalDay='true' value='false'/> 
+                            <boolean name='Speed real' historicalWeek='false' value='true'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>
+                       """
+            )
+
+        
+    def testTimestamp(self):
+        msg = self.Message();
+
+        msg['from'] = 'device@clayster.com'
+        msg['to'] = 'master@clayster.com/amr'
+        msg['fields']['seqnr'] = '1'
+
+        node = msg['fields'].add_node("Device02");
+        node = msg['fields'].add_node("Device03");
+
+        ts = node.add_timestamp("2013-03-07T16:24:30");
+        ts = node.add_timestamp("2013-03-07T16:24:31");
+
+
+
+        self.check(msg,"""
+            <message from='device@clayster.com'
+                    to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId='Device02'/>
+                    <node nodeId='Device03'>
+                        <timestamp value='2013-03-07T16:24:30'/>
+                        <timestamp value='2013-03-07T16:24:31'/>
+                    </node>
+                </fields>
+            </message>
+                       """
+            )
+
+
+    def testStringIdsMatcher(self):
+        """
+        test of StringIds follow spec
+        """
+        emptyStringIdXML='<message xmlns="jabber:client"><fields xmlns="urn:xmpp:iot:sensordata" /></message>'
+
+        msg = self.Message()
+        msg['fields']['stringIds'] = "Nisse"
+        self.check(msg,emptyStringIdXML)
+        msg['fields']['stringIds'] = "Nisse___nje#"
+        self.check(msg,emptyStringIdXML)
+        msg['fields']['stringIds'] = "1"
+        self.check(msg,emptyStringIdXML)
+        
+
+
+    
+suite = unittest.TestLoader().loadTestsFromTestCase(TestSensorDataStanzas)
diff --git a/tests/test_stanza_xep_0325.py b/tests/test_stanza_xep_0325.py
new file mode 100644
index 00000000..b15b764c
--- /dev/null
+++ b/tests/test_stanza_xep_0325.py
@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+from sleekxmpp.test import *
+import sleekxmpp.plugins.xep_0325 as xep_0325
+
+namespace='sn'
+
+class TestControlStanzas(SleekTest):
+    
+
+    def setUp(self):
+        pass
+
+    def testSetRequest(self):
+        """
+        test of set request stanza
+        """
+        iq = self.Iq()
+        iq['type'] = 'set'
+        iq['from'] = 'master@clayster.com/amr'
+        iq['to'] = 'device@clayster.com'
+        iq['id'] = '1'
+        iq['set'].add_node("Device02", "Source02", "MyCacheType");
+        iq['set'].add_node("Device15");
+        iq['set'].add_data("Tjohej", "boolean", "true")
+
+        self.check(iq,"""
+            <iq type='set'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <node nodeId='Device02' sourceId='Source02' cacheType='MyCacheType'/>
+                    <node nodeId='Device15'/>
+                    <boolean name='Tjohej' value='true'/>
+                </set>
+            </iq>
+        """
+            )
+
+        iq['set'].del_node("Device02");
+
+        self.check(iq,"""
+            <iq type='set'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <node nodeId='Device15'/>
+                    <boolean name='Tjohej' value='true'/>
+                </set>
+            </iq>
+        """
+            )
+
+        iq['set'].del_nodes();
+
+        self.check(iq,"""
+            <iq type='set'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <boolean name='Tjohej' value='true'/>
+                </set>
+            </iq>
+        """
+            )
+
+
+    def testDirectSet(self):
+        """
+        test of direct set stanza
+        """
+        msg = self.Message()
+        msg['from'] = 'master@clayster.com/amr'
+        msg['to'] = 'device@clayster.com'
+        msg['set'].add_node("Device02");
+        msg['set'].add_node("Device15");
+        msg['set'].add_data("Tjohej", "boolean", "true")
+
+        self.check(msg,"""
+            <message 
+                from='master@clayster.com/amr'
+                to='device@clayster.com'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <node nodeId='Device02'/>
+                    <node nodeId='Device15'/>
+                    <boolean name='Tjohej' value='true'/>
+                </set>
+            </message>
+        """
+            )
+
+
+    def testSetResponse(self):
+        """
+        test of set response stanza
+        """
+        iq = self.Iq()
+        iq['type'] = 'result'
+        iq['from'] = 'master@clayster.com/amr'
+        iq['to'] = 'device@clayster.com'
+        iq['id'] = '8'
+        iq['setResponse']['responseCode'] = "OK";
+
+        self.check(iq,"""
+            <iq type='result'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='8'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode='OK' />
+            </iq>
+        """
+            )
+
+        iq = self.Iq()
+        iq['type'] = 'error'
+        iq['from'] = 'master@clayster.com/amr'
+        iq['to'] = 'device@clayster.com'
+        iq['id'] = '9'
+        iq['setResponse']['responseCode'] = "OtherError";
+        iq['setResponse']['error']['var'] = "Output";
+        iq['setResponse']['error']['text'] = "Test of other error.!";
+
+
+        self.check(iq,"""
+            <iq type='error'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='9'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode='OtherError'>
+                    <error var='Output'>Test of other error.!</error>
+                </setResponse>
+            </iq>
+        """
+            )
+
+        iq = self.Iq()
+        iq['type'] = 'error'
+        iq['from'] = 'master@clayster.com/amr'
+        iq['to'] = 'device@clayster.com'
+        iq['id'] = '9'
+        iq['setResponse']['responseCode'] = "NotFound";
+        iq['setResponse'].add_node("Device17", "Source09");
+        iq['setResponse'].add_node("Device18", "Source09");
+        iq['setResponse'].add_data("Tjohopp");
+
+
+        self.check(iq,"""
+            <iq type='error'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='9'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode='NotFound'>
+                    <node nodeId='Device17' sourceId='Source09'/>
+                    <node nodeId='Device18' sourceId='Source09'/>
+                    <parameter name='Tjohopp' />
+                </setResponse>
+            </iq>
+        """
+            )
+
+    def testSetRequestDatas(self):
+        """
+        test of set request data stanzas
+        """
+        iq = self.Iq()
+        iq['type'] = 'set'
+        iq['from'] = 'master@clayster.com/amr'
+        iq['to'] = 'device@clayster.com'
+        iq['id'] = '1'
+        iq['set'].add_node("Device02", "Source02", "MyCacheType");
+        iq['set'].add_node("Device15");
+
+        iq['set'].add_data("Tjohej", "boolean", "true");
+        iq['set'].add_data("Tjohej2", "boolean", "false");
+
+        iq['set'].add_data("TjohejC", "color", "FF00FF");
+        iq['set'].add_data("TjohejC2", "color", "00FF00");
+
+        iq['set'].add_data("TjohejS", "string", "String1");
+        iq['set'].add_data("TjohejS2", "string", "String2");
+
+        iq['set'].add_data("TjohejDate", "date", "2012-01-01");
+        iq['set'].add_data("TjohejDate2", "date", "1900-12-03");
+
+        iq['set'].add_data("TjohejDateT4", "dateTime", "1900-12-03 12:30");
+        iq['set'].add_data("TjohejDateT2", "dateTime", "1900-12-03 11:22");
+
+        iq['set'].add_data("TjohejDouble2", "double", "200.22");
+        iq['set'].add_data("TjohejDouble3", "double", "-12232131.3333");
+
+        iq['set'].add_data("TjohejDur", "duration", "P5Y");
+        iq['set'].add_data("TjohejDur2", "duration", "PT2M1S");
+
+        iq['set'].add_data("TjohejInt", "int", "1");
+        iq['set'].add_data("TjohejInt2", "int", "-42");
+
+        iq['set'].add_data("TjohejLong", "long", "123456789098");
+        iq['set'].add_data("TjohejLong2", "long", "-90983243827489374");
+
+        iq['set'].add_data("TjohejTime", "time", "23:59");
+        iq['set'].add_data("TjohejTime2", "time", "12:00");
+
+        self.check(iq,"""
+            <iq type='set'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <node nodeId='Device02' sourceId='Source02' cacheType='MyCacheType'/>
+                    <node nodeId='Device15'/>
+                    <boolean name='Tjohej' value='true'/>
+                    <boolean name='Tjohej2' value='false'/>
+                    <color name='TjohejC' value='FF00FF'/>
+                    <color name='TjohejC2' value='00FF00'/>
+                    <string name='TjohejS' value='String1'/>
+                    <string name='TjohejS2' value='String2'/>
+                    <date name='TjohejDate' value='2012-01-01'/>
+                    <date name='TjohejDate2' value='1900-12-03'/>
+                    <dateTime name='TjohejDateT4' value='1900-12-03 12:30'/>
+                    <dateTime name='TjohejDateT2' value='1900-12-03 11:22'/>
+                    <double name='TjohejDouble2' value='200.22'/>
+                    <double name='TjohejDouble3' value='-12232131.3333'/>
+                    <duration name='TjohejDur' value='P5Y'/>
+                    <duration name='TjohejDur2' value='PT2M1S'/>
+                    <int name='TjohejInt' value='1'/>
+                    <int name='TjohejInt2' value='-42'/>
+                    <long name='TjohejLong' value='123456789098'/>
+                    <long name='TjohejLong2' value='-90983243827489374'/>
+                    <time name='TjohejTime' value='23:59'/>
+                    <time name='TjohejTime2' value='12:00'/>
+                </set>
+            </iq>
+        """
+            )
+    
+suite = unittest.TestLoader().loadTestsFromTestCase(TestControlStanzas)
diff --git a/tests/test_stream_xep_0323.py b/tests/test_stream_xep_0323.py
new file mode 100644
index 00000000..b10f0b0d
--- /dev/null
+++ b/tests/test_stream_xep_0323.py
@@ -0,0 +1,1250 @@
+# -*- coding: utf-8 -*-
+
+import sys
+import datetime
+import time
+import threading
+
+from sleekxmpp.test import *
+from sleekxmpp.xmlstream import ElementBase
+from sleekxmpp.plugins.xep_0323.device import Device
+
+
+class TestStreamSensorData(SleekTest):
+
+    """
+    Test using the XEP-0323 plugin.
+    """
+    def setUp(self):
+        pass
+
+    def _time_now(self):
+        return datetime.datetime.now().replace(microsecond=0).isoformat();
+
+    def tearDown(self):
+        self.stream_close()
+
+    def testRequestAccept(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device22");
+        myDevice._add_field(name="Temperature", typename="numeric", unit="°C");
+        myDevice._set_momentary_timestamp("2013-03-07T16:24:30")
+        myDevice._add_field_momentary_data("Temperature", "23.4", flags={"automaticReadout": "true"});
+
+        self.xmpp['xep_0323'].register_node(nodeId="Device22", device=myDevice, commTimeout=0.5);
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true'/>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='1'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='1'/>
+            </iq>
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1' done='true'>
+                    <node nodeId='Device22'>
+                        <timestamp value='2013-03-07T16:24:30'>
+                            <numeric name='Temperature' momentary='true' automaticReadout='true' value='23.4' unit='°C'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+    def testRequestRejectAuth(self):
+
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        self.xmpp['xep_0323']._set_authenticated("darth@deathstar.com");
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='4'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='5' momentary='true'/>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='error' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='4'>
+                <rejected xmlns='urn:xmpp:iot:sensordata' seqnr='5'>
+                    <error>Access denied</error>
+                </rejected>
+            </iq>
+            """)
+
+    def testRequestNode(self):
+
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device44");
+        self.xmpp['xep_0323'].register_node('Device44', myDevice, commTimeout=0.5);
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='77'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='66' momentary='true'>
+                    <node nodeId='Device33'/>
+                </req>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='error' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='77'>
+                <rejected xmlns='urn:xmpp:iot:sensordata' seqnr='66'>
+                    <error>Invalid nodeId Device33</error>
+                </rejected>
+            </iq>
+            """)
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='8'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='7' momentary='true'>
+                    <node nodeId='Device44'/>
+                </req>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='8'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='7'/>
+            </iq>
+            """)
+
+
+    def testRequestField(self):
+
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device44");
+        myDevice._add_field(name='Voltage', typename="numeric", unit="V");
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.4", timestamp="2000-01-01T00:01:02", flags={"invoiced": "true"});
+
+        self.xmpp['xep_0323'].register_node('Device44', myDevice, commTimeout=0.5);
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='7'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='6'>
+                    <field name='Current'/>
+                </req>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='error' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='7'>
+                <rejected xmlns='urn:xmpp:iot:sensordata' seqnr='6'>
+                    <error>Invalid field Current</error>
+                </rejected>
+            </iq>
+            """)
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='8'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='7'>
+                    <field name='Voltage'/>
+                </req>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='8'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='7'/>
+            </iq>
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='7'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-01-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.4' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='7' done='true'>
+                </fields>
+            </message>            
+            """)
+
+    def testRequestMultiTimestampSingleField(self):
+
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device44");
+        myDevice._add_field(name='Voltage', typename="numeric", unit="V");
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.4", timestamp="2000-01-01T00:01:02", flags={"invoiced": "true"});
+        myDevice._add_field(name='Current', typename="numeric", unit="A");
+        myDevice._add_field(name='Height', typename="string");
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.6", timestamp="2000-01-01T01:01:02");
+        myDevice._add_field_timestamp_data(name="Height", value="115 m", timestamp="2000-01-01T01:01:02", flags={"invoiced": "true"});
+
+        self.xmpp['xep_0323'].register_node('Device44', myDevice, commTimeout=0.5);
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='8'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='7'>
+                    <field name='Voltage'/>
+                </req>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='8'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='7'/>
+            </iq>
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='7'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-01-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.4' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='7'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-01-01T01:01:02'>
+                            <numeric name='Voltage' value='230.6' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='7' done='true'>
+                </fields>
+            </message>            
+            """)
+
+    def testRequestMultiTimestampAllFields(self):
+
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device44");
+        myDevice._add_field(name='Voltage', typename="numeric", unit="V");
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.4", timestamp="2000-01-01T00:01:02", flags={"invoiced": "true"});
+        myDevice._add_field(name='Current', typename="numeric", unit="A");
+        myDevice._add_field(name='Height', typename="string");
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.6", timestamp="2000-01-01T01:01:02");
+        myDevice._add_field_timestamp_data(name="Height", value="115 m", timestamp="2000-01-01T01:01:02", flags={"invoiced": "true"});
+
+        self.xmpp['xep_0323'].register_node('Device44', myDevice, commTimeout=0.5);
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='8'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='7'/>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='8'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='7'/>
+            </iq>
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='7'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-01-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.4' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='7'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-01-01T01:01:02'>
+                            <numeric name='Voltage' value='230.6' unit='V'/> 
+                            <string name='Height' invoiced='true' value='115 m'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='7' done='true'>
+                </fields>
+            </message>            
+            """)
+
+    def testRequestAPI(self):
+
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        self.xmpp['xep_0323'].request_data(from_jid="tester@localhost", to_jid="you@google.com", callback=None);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1'/>
+            </iq>
+            """)
+
+        self.xmpp['xep_0323'].request_data(from_jid="tester@localhost", to_jid="you@google.com", nodeIds=['Device33', 'Device22'], callback=None);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='2'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='2'>
+                    <node nodeId="Device33"/>
+                    <node nodeId="Device22"/>
+                </req>
+            </iq>
+            """)
+
+        self.xmpp['xep_0323'].request_data(from_jid="tester@localhost", to_jid="you@google.com", fields=['Temperature', 'Voltage'], callback=None);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='3'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='3'>
+                    <field name="Temperature"/>
+                    <field name="Voltage"/>
+                </req>
+            </iq>
+            """)
+
+    def testRequestRejectAPI(self):
+
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        results = []; 
+
+        def my_callback(from_jid, result, nodeId=None, timestamp=None, fields=None, error_msg=None):
+            if (result == "rejected") and (error_msg == "Invalid device Device22"):
+                results.append("rejected");
+
+        self.xmpp['xep_0323'].request_data(from_jid="tester@localhost", to_jid="you@google.com", nodeIds=['Device33', 'Device22'], callback=my_callback);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId="Device33"/>
+                    <node nodeId="Device22"/>
+                </req>
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='error' 
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <rejected xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <error>Invalid device Device22</error>
+                </rejected>
+            </iq>            
+            """)
+
+        time.sleep(.1)
+
+        self.failUnless(results == ["rejected"], 
+                "Rejected callback was not properly executed");
+
+    def testRequestAcceptedAPI(self):
+
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        results = []; 
+
+        def my_callback(from_jid, result, nodeId=None, timestamp=None, fields=None, error_msg=None):
+            results.append(result);
+
+        self.xmpp['xep_0323'].request_data(from_jid="tester@localhost", to_jid="you@google.com", nodeIds=['Device33', 'Device22'], callback=my_callback);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId="Device33"/>
+                    <node nodeId="Device22"/>
+                </req>
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='result' 
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='1'/>
+            </iq>            
+            """)
+
+        time.sleep(.1)
+
+        self.failUnless(results == ["accepted"], 
+                "Accepted callback was not properly executed");
+
+    def testRequestFieldsAPI(self):
+
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        results = []; 
+        callback_data = {}; 
+
+        def my_callback(from_jid, result, nodeId=None, timestamp=None, fields=None, error_msg=None):
+            results.append(result);
+            if result == "fields":
+                callback_data["nodeId"] = nodeId;
+                callback_data["timestamp"] = timestamp;
+                callback_data["error_msg"] = error_msg;
+                for f in fields:
+                    callback_data["field_" + f['name']] = f;
+
+        t1= threading.Thread(name="request_data",
+                         target=self.xmpp['xep_0323'].request_data,
+                         kwargs={"from_jid": "tester@localhost", 
+                                    "to_jid": "you@google.com", 
+                                    "nodeIds": ['Device33'], 
+                                    "callback": my_callback});
+        t1.start();
+        #self.xmpp['xep_0323'].request_data(from_jid="tester@localhost", to_jid="you@google.com", nodeIds=['Device33'], callback=my_callback);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId="Device33"/>
+                </req>
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='result' 
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='1'/>
+            </iq>            
+            """)
+
+        self.recv("""
+            <message from='you@google.com'
+                     to='tester@localhost'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId='Device33'>
+                        <timestamp value='2000-01-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.4' unit='V'/> 
+                            <boolean name='TestBool' value='true'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.recv("""
+            <message from='you@google.com'
+                     to='tester@localhost'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1' done='true'/>
+            </message>            
+            """)
+
+        t1.join();
+        time.sleep(.5)
+
+        self.failUnlessEqual(results, ["accepted","fields","done"]);
+        # self.assertIn("nodeId", callback_data);
+        self.assertTrue(callback_data.has_key("nodeId"));
+        self.failUnlessEqual(callback_data["nodeId"], "Device33");
+        # self.assertIn("timestamp", callback_data);
+        self.assertTrue(callback_data.has_key("timestamp"));
+        self.failUnlessEqual(callback_data["timestamp"], "2000-01-01T00:01:02");
+        #self.assertIn("field_Voltage", callback_data);
+        self.assertTrue(callback_data.has_key("field_Voltage"));
+        self.failUnlessEqual(callback_data["field_Voltage"], {"name": "Voltage", "value": "230.4", "typename": "numeric", "unit": "V", "flags": {"invoiced": "true"}});
+        #self.assertIn("field_TestBool", callback_data);
+        self.assertTrue(callback_data.has_key("field_TestBool"));
+        self.failUnlessEqual(callback_data["field_TestBool"], {"name": "TestBool", "value": "true", "typename": "boolean" });
+
+    def testServiceDiscoveryClient(self):
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0323']);
+
+        self.recv("""
+        <iq type='get'
+                from='master@clayster.com/amr'
+                to='tester@localhost'
+                id='disco1'>
+            <query xmlns='http://jabber.org/protocol/disco#info'/>
+        </iq>
+        """)
+
+        self.send("""
+        <iq type='result'
+            to='master@clayster.com/amr'
+            id='disco1'>
+            <query xmlns='http://jabber.org/protocol/disco#info'>
+                <identity category='client' type='bot'/>
+                <feature var='urn:xmpp:iot:sensordata'/>
+            </query>  
+        </iq>            
+        """)
+
+    def testServiceDiscoveryComponent(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323']);
+
+        self.recv("""
+        <iq type='get'
+                from='master@clayster.com/amr'
+                to='tester@localhost'
+                id='disco1'>
+            <query xmlns='http://jabber.org/protocol/disco#info'/>
+        </iq>
+        """)
+
+        self.send("""
+        <iq type='result'
+            from='tester@localhost'
+            to='master@clayster.com/amr'
+            id='disco1'>
+            <query xmlns='http://jabber.org/protocol/disco#info'>
+                <identity category='component' type='generic'/>
+                <feature var='urn:xmpp:iot:sensordata'/>
+            </query>  
+        </iq>            
+        """)
+
+    def testRequestTimeout(self):
+
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        results = [];
+        callback_data = {}; 
+
+        def my_callback(from_jid, result, nodeId=None, timestamp=None, error_msg=None):
+            results.append(result);
+            if result == "failure":
+                callback_data["nodeId"] = nodeId;
+                callback_data["timestamp"] = timestamp;
+                callback_data["error_msg"] = error_msg;
+
+        t1= threading.Thread(name="request_data",
+                         target=self.xmpp['xep_0323'].request_data,
+                         kwargs={"from_jid": "tester@localhost", 
+                                    "to_jid": "you@google.com", 
+                                    "nodeIds": ['Device33'], 
+                                    "callback": my_callback});
+        t1.start();
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId="Device33"/>
+                </req>
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='result' 
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='1'/>
+            </iq>            
+            """)
+
+        self.recv("""
+            <message from='you@google.com'
+                to='tester@localhost'>
+                <failure xmlns='urn:xmpp:iot:sensordata' seqnr='1' done='true'>
+                    <error nodeId='Device33' timestamp='2013-03-07T17:13:30'>Timeout.</error>
+                </failure>
+            </message>
+            """)
+
+        t1.join();
+        time.sleep(.5)
+
+        self.failUnlessEqual(results, ["accepted","failure"]);
+        # self.assertIn("nodeId", callback_data);
+        self.assertTrue(callback_data.has_key("nodeId"));
+        self.failUnlessEqual(callback_data["nodeId"], "Device33");
+        # self.assertIn("timestamp", callback_data);
+        self.assertTrue(callback_data.has_key("timestamp"));
+        self.failUnlessEqual(callback_data["timestamp"], "2013-03-07T17:13:30");
+        # self.assertIn("error_msg", callback_data);
+        self.assertTrue(callback_data.has_key("error_msg"));
+        self.failUnlessEqual(callback_data["error_msg"], "Timeout.");
+
+    def testDelayedRequest(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device22");
+        myDevice._add_field(name="Temperature", typename="numeric", unit="°C");
+        myDevice._set_momentary_timestamp("2013-03-07T16:24:30")
+        myDevice._add_field_momentary_data("Temperature", "23.4", flags={"automaticReadout": "true"});
+
+        self.xmpp['xep_0323'].register_node(nodeId="Device22", device=myDevice, commTimeout=0.5);
+
+        dtnow = datetime.datetime.now()
+        ts_2sec = datetime.timedelta(0,2)
+        dtnow_plus_2sec = dtnow + ts_2sec
+        when_flag = dtnow_plus_2sec.replace(microsecond=0).isoformat()
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true' when='""" + when_flag + """'/>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='1'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='1' queued='true' />
+            </iq>
+            """)
+
+        time.sleep(2)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <started xmlns='urn:xmpp:iot:sensordata' seqnr='1' />
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1' done='true'>
+                    <node nodeId='Device22'>
+                        <timestamp value='2013-03-07T16:24:30'>
+                            <numeric name='Temperature' momentary='true' automaticReadout='true' value='23.4' unit='°C'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+    def testDelayedRequestFail(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device22");
+        myDevice._add_field(name="Temperature", typename="numeric", unit="°C");
+        myDevice._set_momentary_timestamp("2013-03-07T16:24:30")
+        myDevice._add_field_momentary_data("Temperature", "23.4", flags={"automaticReadout": "true"});
+
+        self.xmpp['xep_0323'].register_node(nodeId="Device22", device=myDevice, commTimeout=0.5);
+
+        dtnow = datetime.datetime.now()
+        ts_2sec = datetime.timedelta(0,2)
+        dtnow_minus_2sec = dtnow - ts_2sec
+        when_flag = dtnow_minus_2sec.replace(microsecond=0).isoformat()
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true' when='""" + when_flag + """'/>
+            </iq>
+        """)
+
+        # Remove the returned datetime to allow predictable test
+        xml_stanza = self._filtered_stanza_prepare()
+        error_text = xml_stanza['rejected']['error'] #['text']
+        error_text = error_text[:error_text.find(':')]
+        xml_stanza['rejected']['error'] = error_text
+
+        self._filtered_stanza_check("""
+            <iq type='error' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='1'>
+                <rejected xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <error>Invalid datetime in 'when' flag, cannot set a time in the past. Current time</error>
+                </rejected>
+            </iq>
+            """, xml_stanza)
+
+
+    def _filtered_stanza_prepare(self, timeout=.5):
+        sent = self.xmpp.socket.next_sent(timeout)
+        if sent is None:
+            self.fail("No stanza was sent.")
+
+        xml = self.parse_xml(sent)
+        self.fix_namespaces(xml, 'jabber:client')
+        sent = self.xmpp._build_stanza(xml, 'jabber:client')
+        return sent
+
+    def _filtered_stanza_check(self, data, filtered, defaults=None, use_values=True, method='exact'):
+        self.check(filtered, data,
+                   method=method,
+                   defaults=defaults,
+                   use_values=use_values)
+
+    def testRequestFieldFrom(self):
+
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device44");
+        myDevice._add_field(name='Voltage', typename="numeric", unit="V");
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.1", timestamp="2000-01-01T00:01:02", flags={"invoiced": "true"});
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.2", timestamp="2000-02-01T00:01:02", flags={"invoiced": "true"});
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.3", timestamp="2000-03-01T00:01:02", flags={"invoiced": "true"});
+
+        self.xmpp['xep_0323'].register_node('Device44', myDevice, commTimeout=0.5);
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='6'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='6' from='2000-01-02T00:00:01'>
+                    <field name='Voltage'/>
+                </req>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='6'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='6'/>
+            </iq>
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='6'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-02-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.2' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='6'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-03-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.3' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='6' done='true'>
+                </fields>
+            </message>            
+            """)
+
+    def testRequestFieldTo(self):
+
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device44");
+        myDevice._add_field(name='Voltage', typename="numeric", unit="V");
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.1", timestamp="2000-01-01T00:01:02", flags={"invoiced": "true"});
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.2", timestamp="2000-02-01T00:01:02", flags={"invoiced": "true"});
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.3", timestamp="2000-03-01T00:01:02", flags={"invoiced": "true"});
+
+        self.xmpp['xep_0323'].register_node('Device44', myDevice, commTimeout=0.5);
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='6'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='6' to='2000-02-02T00:00:01'>
+                    <field name='Voltage'/>
+                </req>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='6'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='6'/>
+            </iq>
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='6'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-01-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.1' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='6'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-02-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.2' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='6' done='true'>
+                </fields>
+            </message>            
+            """)
+
+    def testRequestFieldFromTo(self):
+
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device44");
+        myDevice._add_field(name='Voltage', typename="numeric", unit="V");
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.1", timestamp="2000-01-01T00:01:02", flags={"invoiced": "true"});
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.2", timestamp="2000-02-01T00:01:02", flags={"invoiced": "true"});
+        myDevice._add_field_timestamp_data(name="Voltage", value="230.3", timestamp="2000-03-01T00:01:02", flags={"invoiced": "true"});
+
+        self.xmpp['xep_0323'].register_node('Device44', myDevice, commTimeout=0.5);
+
+        print("."),
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='6'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='6' from='2000-01-01T00:01:03' to='2000-02-02T00:00:01'>
+                    <field name='Voltage'/>
+                </req>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='6'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='6'/>
+            </iq>
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='6'>
+                    <node nodeId='Device44'>
+                        <timestamp value='2000-02-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.2' unit='V'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.send("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='6' done='true'>
+                </fields>
+            </message>            
+            """)
+
+    def testDelayedRequestClient(self):
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        results = []; 
+        callback_data = {}; 
+
+        def my_callback(from_jid, result, nodeId=None, timestamp=None, fields=None, error_msg=None):
+            results.append(result);
+            if result == "fields":
+                callback_data["nodeId"] = nodeId;
+                callback_data["timestamp"] = timestamp;
+                callback_data["error_msg"] = error_msg;
+                for f in fields:
+                    callback_data["field_" + f['name']] = f;
+
+        t1= threading.Thread(name="request_data",
+                         target=self.xmpp['xep_0323'].request_data,
+                         kwargs={"from_jid": "tester@localhost", 
+                                    "to_jid": "you@google.com", 
+                                    "nodeIds": ['Device33'], 
+                                    "callback": my_callback});
+        t1.start();
+        #self.xmpp['xep_0323'].request_data(from_jid="tester@localhost", to_jid="you@google.com", nodeIds=['Device33'], callback=my_callback);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId="Device33"/>
+                </req>
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='result' 
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='1'  queued='true'/>
+            </iq>            
+            """)
+
+        self.recv("""
+            <message from='device@clayster.com'
+                     to='master@clayster.com/amr'>
+                <started xmlns='urn:xmpp:iot:sensordata' seqnr='1' />
+            </message>            
+            """)        
+
+        self.recv("""
+            <message from='you@google.com'
+                     to='tester@localhost'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId='Device33'>
+                        <timestamp value='2000-01-01T00:01:02'>
+                            <numeric name='Voltage' invoiced='true' value='230.4' unit='V'/> 
+                            <boolean name='TestBool' value='true'/> 
+                        </timestamp>
+                    </node>
+                </fields>
+            </message>            
+            """)
+
+        self.recv("""
+            <message from='you@google.com'
+                     to='tester@localhost'>
+                <fields xmlns='urn:xmpp:iot:sensordata' seqnr='1' done='true'/>
+            </message>            
+            """)
+
+        t1.join();
+        time.sleep(.5)
+
+        self.failUnlessEqual(results, ["queued","started","fields","done"]);
+        # self.assertIn("nodeId", callback_data);
+        self.assertTrue(callback_data.has_key("nodeId"));
+        self.failUnlessEqual(callback_data["nodeId"], "Device33");
+        # self.assertIn("timestamp", callback_data);
+        self.assertTrue(callback_data.has_key("timestamp"));
+        self.failUnlessEqual(callback_data["timestamp"], "2000-01-01T00:01:02");
+        # self.assertIn("field_Voltage", callback_data);
+        self.assertTrue(callback_data.has_key("field_Voltage"));
+        self.failUnlessEqual(callback_data["field_Voltage"], {"name": "Voltage", "value": "230.4", "typename": "numeric", "unit": "V", "flags": {"invoiced": "true"}});
+        # self.assertIn("field_TestBool", callback_data);
+        self.assertTrue(callback_data.has_key("field_TestBool"));
+        self.failUnlessEqual(callback_data["field_TestBool"], {"name": "TestBool", "value": "true", "typename": "boolean" });
+
+
+    def testRequestFieldsCancelAPI(self):
+
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        results = []; 
+
+        def my_callback(from_jid, result, nodeId=None, timestamp=None, fields=None, error_msg=None):
+            results.append(result);
+
+        session = self.xmpp['xep_0323'].request_data(from_jid="tester@localhost", to_jid="you@google.com", nodeIds=['Device33'], callback=my_callback);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <node nodeId="Device33"/>
+                </req>
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='result' 
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='1'/>
+            </iq>            
+            """)
+
+        self.xmpp['xep_0323'].cancel_request(session=session);
+
+        self.send("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <cancel xmlns='urn:xmpp:iot:sensordata' seqnr='1' />
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='result'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <cancelled xmlns='urn:xmpp:iot:sensordata' seqnr='1' />
+            </iq>
+            """)
+
+        time.sleep(.5)
+
+        self.failUnlessEqual(results, ["accepted","cancelled"]);
+
+    def testDelayedRequestCancel(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0323'])
+
+        myDevice = Device("Device22");
+        myDevice._add_field(name="Temperature", typename="numeric", unit="°C");
+        myDevice._set_momentary_timestamp("2013-03-07T16:24:30")
+        myDevice._add_field_momentary_data("Temperature", "23.4", flags={"automaticReadout": "true"});
+
+        self.xmpp['xep_0323'].register_node(nodeId="Device22", device=myDevice, commTimeout=0.5);
+
+        dtnow = datetime.datetime.now()
+        ts_2sec = datetime.timedelta(0,2)
+        dtnow_plus_2sec = dtnow + ts_2sec
+        when_flag = dtnow_plus_2sec.replace(microsecond=0).isoformat()
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <req xmlns='urn:xmpp:iot:sensordata' seqnr='1' momentary='true' when='""" + when_flag + """'/>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result' 
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='1'>
+                <accepted xmlns='urn:xmpp:iot:sensordata' seqnr='1' queued='true' />
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='get'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <cancel xmlns='urn:xmpp:iot:sensordata' seqnr='1' />
+            </iq>
+            """)
+
+        self.send("""
+            <iq type='result'
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='1'>
+                <cancelled xmlns='urn:xmpp:iot:sensordata' seqnr='1' />
+            </iq>
+            """)
+
+        # Test cancel of non-existing request
+        self.recv("""
+            <iq type='get'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <cancel xmlns='urn:xmpp:iot:sensordata' seqnr='1' />
+            </iq>
+            """)
+
+        self.send("""
+            <iq type='error'
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <rejected xmlns='urn:xmpp:iot:sensordata' seqnr='1'>
+                    <error>Cancel request received, no matching request is active.</error>
+                </rejected>
+            </iq>
+            """)
+
+        time.sleep(2)
+
+        # Ensure we don't get anything after cancellation
+        self.send(None)
+
+
+
+suite = unittest.TestLoader().loadTestsFromTestCase(TestStreamSensorData)
+
diff --git a/tests/test_stream_xep_0325.py b/tests/test_stream_xep_0325.py
new file mode 100644
index 00000000..4b3250fc
--- /dev/null
+++ b/tests/test_stream_xep_0325.py
@@ -0,0 +1,365 @@
+# -*- coding: utf-8 -*-
+"""
+    SleekXMPP: The Sleek XMPP Library
+    Implementation of xeps for Internet of Things
+    http://wiki.xmpp.org/web/Tech_pages/IoT_systems
+    Copyright (C) 2013 Sustainable Innovation, Joachim.lindborg@sust.se, bjorn.westrom@consoden.se
+    This file is part of SleekXMPP.
+
+    See the file LICENSE for copying permission.
+"""
+
+import sys
+import datetime
+import time
+import threading
+
+from sleekxmpp.test import *
+from sleekxmpp.xmlstream import ElementBase
+from sleekxmpp.plugins.xep_0325.device import Device
+
+
+class TestStreamControl(SleekTest):
+
+    """
+    Test using the XEP-0325 plugin.
+    """
+    def setUp(self):
+        pass
+
+    def _time_now(self):
+        return datetime.datetime.now().replace(microsecond=0).isoformat();
+
+    def tearDown(self):
+        self.stream_close()
+
+    def testRequestSetOk(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0325'])
+
+        myDevice = Device("Device22");
+        myDevice._add_control_field(name="Temperature", typename="int", value="15");
+
+        self.xmpp['xep_0325'].register_node(nodeId="Device22", device=myDevice, commTimeout=0.5);
+
+        self.recv("""
+            <iq type='set'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <int name="Temperature" value="17"/>
+                </set>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result'
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='1'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode="OK" />
+            </iq>            
+            """)
+
+        self.assertEqual(myDevice._get_field_value("Temperature"), "17");
+
+    def testRequestSetMulti(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0325'])
+
+        myDevice = Device("Device22");
+        myDevice._add_control_field(name="Temperature", typename="int", value="15");
+        myDevice._add_control_field(name="Startup", typename="date", value="2013-01-03");
+
+        myDevice2 = Device("Device23");
+        myDevice2._add_control_field(name="Temperature", typename="int", value="19");
+        myDevice2._add_control_field(name="Startup", typename="date", value="2013-01-09");
+
+        self.xmpp['xep_0325'].register_node(nodeId="Device22", device=myDevice, commTimeout=0.5);
+        self.xmpp['xep_0325'].register_node(nodeId="Device23", device=myDevice2, commTimeout=0.5);
+
+        self.recv("""
+            <iq type='set'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='1'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <node nodeId='Device22' />
+                    <int name="Temperature" value="17"/>
+                </set>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result'
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='1'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode="OK" />
+            </iq>            
+            """)
+
+        self.assertEqual(myDevice._get_field_value("Temperature"), "17");
+        self.assertEqual(myDevice2._get_field_value("Temperature"), "19");
+
+        self.recv("""
+            <iq type='set'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='2'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <node nodeId='Device23' />
+                    <node nodeId='Device22' />
+                    <date name="Startup" value="2013-02-01"/>
+                    <int name="Temperature" value="20"/>
+                </set>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='result'
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='2'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode="OK" />
+            </iq>            
+            """)
+
+        self.assertEqual(myDevice._get_field_value("Temperature"), "20");
+        self.assertEqual(myDevice2._get_field_value("Temperature"), "20");
+        self.assertEqual(myDevice._get_field_value("Startup"), "2013-02-01");
+        self.assertEqual(myDevice2._get_field_value("Startup"), "2013-02-01");
+
+    def testRequestSetFail(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0325'])
+
+        myDevice = Device("Device23");
+        myDevice._add_control_field(name="Temperature", typename="int", value="15");
+
+        self.xmpp['xep_0325'].register_node(nodeId="Device23", device=myDevice, commTimeout=0.5);
+
+        self.recv("""
+            <iq type='set'
+                from='master@clayster.com/amr'
+                to='device@clayster.com'
+                id='9'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <int name="Voltage" value="17"/>
+                </set>
+            </iq>
+        """)
+
+        self.send("""
+            <iq type='error'
+                from='device@clayster.com'
+                to='master@clayster.com/amr'
+                id='9'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode='NotFound'>
+                    <parameter name='Voltage' />
+                    <error var='Output'>Invalid field Voltage</error>
+                </setResponse>
+            </iq>            
+            """)
+
+        self.assertEqual(myDevice._get_field_value("Temperature"), "15");
+        self.assertFalse(myDevice.has_control_field("Voltage", "int"));
+
+    def testDirectSetOk(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0325'])
+
+        myDevice = Device("Device22");
+        myDevice._add_control_field(name="Temperature", typename="int", value="15");
+
+        self.xmpp['xep_0325'].register_node(nodeId="Device22", device=myDevice, commTimeout=0.5);
+
+        self.recv("""
+            <message 
+                from='master@clayster.com/amr'
+                to='device@clayster.com'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <int name="Temperature" value="17"/>
+                </set>
+            </message>
+        """)
+
+        time.sleep(.5)
+
+        self.assertEqual(myDevice._get_field_value("Temperature"), "17");
+
+    def testDirectSetFail(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0325'])
+
+        myDevice = Device("Device22");
+        myDevice._add_control_field(name="Temperature", typename="int", value="15");
+
+        self.xmpp['xep_0325'].register_node(nodeId="Device22", device=myDevice, commTimeout=0.5);
+
+        self.recv("""
+            <message 
+                from='master@clayster.com/amr'
+                to='device@clayster.com'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <int name="Voltage" value="17"/>
+                </set>
+            </message>
+        """)
+
+        time.sleep(.5)
+
+        self.assertEqual(myDevice._get_field_value("Temperature"), "15");
+        self.assertFalse(myDevice.has_control_field("Voltage", "int"));
+
+
+    def testRequestSetOkAPI(self):
+
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0325'])
+
+        results = []; 
+
+        def my_callback(from_jid, result, nodeIds=None, fields=None, error_msg=None):
+            results.append(result);
+
+        fields = []
+        fields.append(("Temperature", "double", "20.5"))
+        fields.append(("TemperatureAlarmSetting", "string", "High"))
+
+        self.xmpp['xep_0325'].set_request(from_jid="tester@localhost", to_jid="you@google.com", fields=fields, nodeIds=['Device33', 'Device22'], callback=my_callback);
+
+        self.send("""
+            <iq type='set'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <node nodeId='Device33' />
+                    <node nodeId='Device22' />
+                    <double name="Temperature" value="20.5" />
+                    <string name="TemperatureAlarmSetting" value="High" />
+                </set>
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='result'
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode="OK" />
+            </iq>               
+            """)
+
+        time.sleep(.5)
+
+        self.assertEqual(results, ["OK"]);
+
+    def testRequestSetErrorAPI(self):
+
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0325'])
+
+        results = []; 
+
+        def my_callback(from_jid, result, nodeIds=None, fields=None, error_msg=None):
+            results.append(result);
+
+        fields = []
+        fields.append(("Temperature", "double", "20.5"))
+        fields.append(("TemperatureAlarmSetting", "string", "High"))
+
+        self.xmpp['xep_0325'].set_request(from_jid="tester@localhost", to_jid="you@google.com", fields=fields, nodeIds=['Device33', 'Device22'], callback=my_callback);
+
+        self.send("""
+            <iq type='set'
+                from='tester@localhost'
+                to='you@google.com'
+                id='1'>
+                <set xmlns='urn:xmpp:iot:control'>
+                    <node nodeId='Device33' />
+                    <node nodeId='Device22' />
+                    <double name="Temperature" value="20.5" />
+                    <string name="TemperatureAlarmSetting" value="High" />
+                </set>
+            </iq>
+            """)
+
+        self.recv("""
+            <iq type='error'
+                from='you@google.com'
+                to='tester@localhost'
+                id='1'>
+                <setResponse xmlns='urn:xmpp:iot:control' responseCode="OtherError" >
+                    <error var='Temperature'>Sensor error</error>
+                </setResponse>
+            </iq>               
+            """)
+
+        time.sleep(.5)
+
+        self.assertEqual(results, ["OtherError"]);
+
+    def testServiceDiscoveryClient(self):
+        self.stream_start(mode='client',
+                          plugins=['xep_0030',
+                                   'xep_0325']);
+
+        self.recv("""
+        <iq type='get'
+                from='master@clayster.com/amr'
+                to='tester@localhost'
+                id='disco1'>
+            <query xmlns='http://jabber.org/protocol/disco#info'/>
+        </iq>
+        """)
+
+        self.send("""
+        <iq type='result'
+            to='master@clayster.com/amr'
+            id='disco1'>
+            <query xmlns='http://jabber.org/protocol/disco#info'>
+                <identity category='client' type='bot'/>
+                <feature var='urn:xmpp:iot:control'/>
+            </query>  
+        </iq>            
+        """)
+
+    def testServiceDiscoveryComponent(self):
+        self.stream_start(mode='component',
+                          plugins=['xep_0030',
+                                   'xep_0325']);
+
+        self.recv("""
+        <iq type='get'
+                from='master@clayster.com/amr'
+                to='tester@localhost'
+                id='disco1'>
+            <query xmlns='http://jabber.org/protocol/disco#info'/>
+        </iq>
+        """)
+
+        self.send("""
+        <iq type='result'
+            from='tester@localhost'
+            to='master@clayster.com/amr'
+            id='disco1'>
+            <query xmlns='http://jabber.org/protocol/disco#info'>
+                <identity category='component' type='generic'/>
+                <feature var='urn:xmpp:iot:control'/>
+            </query>  
+        </iq>            
+        """)
+
+
+suite = unittest.TestLoader().loadTestsFromTestCase(TestStreamControl)
+