""" 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 makeMethodCallQuery(self,pmethod,params): query = self.xmpp.makeIqQuery(iq,"jabber:iq:rpc") methodCall = ET.Element('methodCall') methodName = ET.Element('methodName') methodName.text = pmethod methodCall.append(methodName) methodCall.append(params) query.append(methodCall) return query def makeIqMethodCall(self,pto,pmethod,params): iq = self.xmpp.makeIqSet() iq.set('to',pto) iq.append(self.makeMethodCallQuery(pmethod,params)) return iq def makeIqMethodResponse(self,pto,pid,params): iq = self.xmpp.makeIqResult(pid) iq.set('to',pto) query = self.xmpp.makeIqQuery(iq,"jabber:iq:rpc") methodResponse = ET.Element('methodResponse') methodResponse.append(params) query.append(methodResponse) return iq def makeIqMethodError(self,pto,id,pmethod,params,condition): iq = self.xmpp.makeIqError(id) iq.set('to',pto) iq.append(self.makeMethodCallQuery(pmethod,params)) 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