SleekXMPP/sleekxmpp/plugins/xep_0009.py

"""
XEP-0009 XMPP Remote Procedure Calls
"""
from __future__ import with_statement
from . import base
import logging
from xml.etree import cElementTree as ET
import copy
import time
import base64

def py2xml(*args):
	params = ET.Element("params")
	for x in args:
		param = ET.Element("param")
		param.append(_py2xml(x))
		params.append(param) #<params><param>...
	return params

def _py2xml(*args):
	for x in args:
		val = ET.Element("value")
		if type(x) is int:
			i4 = ET.Element("i4")
			i4.text = str(x)
			val.append(i4)
		if type(x) is bool:
			boolean = ET.Element("boolean")
			boolean.text = str(int(x))
			val.append(boolean)
		elif type(x) is str:
			string = ET.Element("string")
			string.text = x
			val.append(string)
		elif type(x) is float:
			double = ET.Element("double")
			double.text = str(x)
			val.append(double)
		elif type(x) is rpcbase64:
			b64 = ET.Element("Base64")
			b64.text = x.encoded()
			val.append(b64)
		elif type(x) is rpctime:
			iso = ET.Element("dateTime.iso8601")
			iso.text = str(x)
			val.append(iso)
		elif type(x) is list:
			array = ET.Element("array")
			data = ET.Element("data")
			for y in x:
				data.append(_py2xml(y))
			array.append(data)
			val.append(array)
		elif type(x) is dict:
			struct = ET.Element("struct")
			for y in x.keys():
				member = ET.Element("member")
				name = ET.Element("name")
				name.text = y
				member.append(name)
				member.append(_py2xml(x[y]))
				struct.append(member)
			val.append(struct)
		return val

def xml2py(params):
	vals = []
	for param in params.findall('param'):
		vals.append(_xml2py(param.find('value')))
	return vals

def _xml2py(value):
	if value.find('i4') is not None:
		return int(value.find('i4').text)
	if value.find('int') is not None:
		return int(value.find('int').text)
	if value.find('boolean') is not None:
		return bool(value.find('boolean').text)
	if value.find('string') is not None:
		return value.find('string').text
	if value.find('double') is not None:
		return float(value.find('double').text)
	if value.find('Base64') is not None:
		return rpcbase64(value.find('Base64').text)
	if value.find('dateTime.iso8601') is not None:
		return rpctime(value.find('dateTime.iso8601'))
	if value.find('struct') is not None:
		struct = {}
		for member in value.find('struct').findall('member'):
			struct[member.find('name').text] = _xml2py(member.find('value'))
		return struct
	if value.find('array') is not None:
		array = []
		for val in value.find('array').find('data').findall('value'):
			array.append(_xml2py(val))
		return array
	raise ValueError()

class rpcbase64(object):
	def __init__(self, data):
		#base 64 encoded string
		self.data = data

	def decode(self):
		return base64.decodestring(data)

	def __str__(self):
		return self.decode()

	def encoded(self):
		return self.data

class rpctime(object):
	def __init__(self,data=None):
		#assume string data is in iso format YYYYMMDDTHH:MM:SS
		if type(data) is str:
			self.timestamp = time.strptime(data,"%Y%m%dT%H:%M:%S")
		elif type(data) is time.struct_time:
			self.timestamp = data
		elif data is None:
			self.timestamp = time.gmtime()
		else:
			raise ValueError()

	def iso8601(self):
		#return a iso8601 string
		return time.strftime("%Y%m%dT%H:%M:%S",self.timestamp)

	def __str__(self):
		return self.iso8601()

class JabberRPCEntry(object):
	def __init__(self,call):
		self.call = call
		self.result = None
		self.error = None
		self.allow = {} #{'<jid>':['<resource1>',...],...}
		self.deny = {}

	def check_acl(self, jid, resource):
		#Check for deny
		if jid in self.deny.keys():
			if self.deny[jid] == None or resource in self.deny[jid]:
				return False
		#Check for allow
		if allow == None:
			return True
		if jid in self.allow.keys():
			if self.allow[jid] == None or resource in self.allow[jid]:
				return True
		return False

	def acl_allow(self, jid, resource):
		if jid == None:
			self.allow = None
		elif resource == None:
			self.allow[jid] = None
		elif jid in self.allow.keys():
			self.allow[jid].append(resource)
		else:
			self.allow[jid] = [resource]
		
	def acl_deny(self, jid, resource):
		if jid == None:
			self.deny = None
		elif resource == None:
			self.deny[jid] = None
		elif jid in self.deny.keys():
			self.deny[jid].append(resource)
		else:
			self.deny[jid] = [resource]

	def call_method(self, args):
		ret = self.call(*args)

class xep_0009(base.base_plugin):

	def plugin_init(self):
		self.xep = '0009'
		self.description = 'Jabber-RPC'
		self.xmpp.add_handler("<iq type='set'><query xmlns='jabber:iq:rpc' /></iq>", self._callMethod)
		self.xmpp.add_handler("<iq type='result'><query xmlns='jabber:iq:rpc' /></iq>", self._callResult)
		self.xmpp.add_handler("<iq type='error'><query xmlns='jabber:iq:rpc' /></iq>", self._callError)
		self.entries = {}
		self.activeCalls = []

	def post_init(self):
		base.base_plugin.post_init(self)
		self.xmpp.plugin['xep_0030'].add_feature('jabber:iq:rpc')
		self.xmpp.plugin['xep_0030'].add_identity('automatition','rpc')

	def register_call(self, method, name=None):
		#@returns an string that can be used in acl commands.
		with self.lock:
			if name is None:
				self.entries[method.__name__] = JabberRPCEntry(method)
				return method.__name__
			else:
				self.entries[name] = JabberRPCEntry(method)
				return name

	def acl_allow(self, entry, jid=None, resource=None):
		#allow the method entry to be called by the given jid and resource.
		#if jid is None it will allow any jid/resource.
		#if resource is None it will allow any resource belonging to the jid.
		with self.lock:
			if self.entries[entry]:
				self.entries[entry].acl_allow(jid,resource)
			else:
				raise ValueError()
	
	def acl_deny(self, entry, jid=None, resource=None):
		#Note: by default all requests are denied unless allowed with acl_allow.
		#If you deny an entry it will not be allowed regardless of acl_allow
		with self.lock:
			if self.entries[entry]:
				self.entries[entry].acl_deny(jid,resource)
			else:
				raise ValueError()
	
	def unregister_call(self, entry):
		#removes the registered call
		with self.lock:
			if self.entries[entry]:
				del self.entries[entry]
			else:
				raise ValueError()

	def makeIqMethodCall(self,pto,pmethod,params):
		query = ET.Element("{jabber:iq:rpc}query")
		methodCall = ET.Element('methodCall')
		methodName = ET.Element('methodName')
		methodName.text = pmethod
		methodCall.append(methodName)
		methodCall.append(params)
		query.append(methodCall)
		iq = self.xmpp.makeIqSet(query)
		iq.set('to',pto)
		return iq
 
	def makeIqMethodResponse(self,pto,pid,params):
		query = ET.Element("{jabber:iq:rpc}query")
		methodResponse = ET.Element('methodResponse')
		methodResponse.append(params)
		query.append(methodResponse)
		iq = self.xmpp.makeIqResult(pid)
		iq.set('to',pto)
		iq.append(query)
		return iq

	def makeIqMethodError(self,pto,pid,pmethod,params,condition):
		iq = self.self.makeMethodCallQuery(pto,pmethod,params)
        iq.setValues({'id':pid,'type':'error'})
		iq.append(self.xmpp['xep_0086'].makeError(condition))
		return iq
	
		

	def call_remote(self, pto, pmethod, *args):
		#calls a remote method. Returns the id of the Iq.
		pass

	def _callMethod(self,xml):
		pass

	def _callResult(self,xml):
		pass

	def _callError(self,xml):
		pass