def __init__(self, contact_jid,):
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='get', attrs=attrs, to=contact_jid)
items = Node('items', attrs={'node': NS_DEVICE_LIST, 'max_items': 1})
pubsub = PubsubNode(items)
self.addChild(node=pubsub)
def _make_command(command, attrs, dataform):
command_node = Node('command', attrs=attrs)
if dataform is not None:
command_node.addChild(node=dataform)
iq = Iq('set', to=command.jid)
iq.addChild(node=command_node)
return iq
def _make_node_configuration(node, form, jid):
query = Iq('set', to=jid)
pubsub = query.addChild('pubsub', namespace=Namespace.PUBSUB_OWNER)
configure = pubsub.addChild('configure', {'node': node})
form.setAttr('type', 'submit')
configure.addChild(node=form)
return query
def __init__(self, contact_jid, device_id):
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='get', attrs=attrs, to=contact_jid)
items = Node('items', attrs={'node': NS_BUNDLES + str(device_id)})
pubsub = PubsubNode(items)
self.addChild(node=pubsub)
def __init__(self, contact_jid,):
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='get', attrs=attrs, to=contact_jid)
items = Node('items', attrs={'node': NS_DEVICE_LIST})
pubsub = PubsubNode(items)
self.addChild(node=pubsub)
def __init__(self, contact_jid, device_id):
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='get', attrs=attrs, to=contact_jid)
items = Node('items', attrs={'node': NS_BUNDLES + str(device_id)})
pubsub = PubsubNode(items)
self.addChild(node=pubsub)
def __init__(self, state_bundle, device_id):
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='set', attrs=attrs)
bundle_node = self.make_bundle_node(state_bundle)
publish = PublishNode(NS_BUNDLES + str(device_id), bundle_node)
pubsub = PubsubNode(publish)
self.addChild(node=pubsub)
def __init__(self, state_bundle, device_id):
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='set', attrs=attrs)
bundle_node = self.make_bundle_node(state_bundle)
publish = PublishNode(NS_BUNDLES + str(device_id), bundle_node)
pubsub = PubsubNode(publish)
self.addChild(node=pubsub)
def _make_request(version, roster_ver_support):
iq = Iq('get', Namespace.ROSTER)
if version is None:
version = ''
if roster_ver_support:
iq.setTagAttr('query', 'ver', version)
return iq
def make_set_role_request(room_jid, nick, role, reason):
iq = Iq(typ='set', to=room_jid, queryNS=Namespace.MUC_ADMIN)
item = iq.setQuery().setTag('item')
item.setAttr('nick', nick)
item.setAttr('role', role)
if reason:
item.addChild(name='reason', payload=reason)
return iq
def _make_pubsub_request(node, id_=None, max_items=None, jid=None):
query = Iq('get', to=jid)
pubsub = query.addChild('pubsub', namespace=Namespace.PUBSUB)
items = pubsub.addChild('items', {'node': node})
if max_items is not None:
items.setAttr('max_items', max_items)
if id_ is not None:
items.addChild('item', {'id': id_})
return query
def _make_retract_request(node, id_, jid, notify):
query = Iq('set', to=jid)
pubsub = query.addChild('pubsub', namespace=Namespace.PUBSUB)
attrs = {'node': node}
if notify:
attrs['notify'] = 'true'
retract = pubsub.addChild('retract', attrs=attrs)
retract.addChild('item', {'id': id_})
return query
def _make_block_request(jids, report):
iq = Iq('set', Namespace.BLOCKING)
query = iq.setQuery(name='block')
for jid in jids:
item = query.addChild(name='item', attrs={'jid': jid})
if report in ('spam', 'abuse'):
action = item.addChild(name='report',
namespace=Namespace.REPORTING)
action.setTag(report)
return iq
def _make_search_query(jid, dataform, items_per_page=50, after=None):
search = Node('search', attrs={'xmlns': Namespace.MUCLUMBUS})
search.addChild(node=dataform)
rsm = search.addChild('set', namespace=Namespace.RSM)
rsm.addChild('max').setData(items_per_page)
if after is not None:
rsm.addChild('after').setData(after)
query = Iq(to=jid, typ='get')
query.addChild(node=search)
return query
def make_destroy_request(room_jid, reason, jid):
iq = Iq(typ='set', queryNS=Namespace.MUC_OWNER, to=room_jid)
destroy = iq.setQuery().setTag('destroy')
if reason:
destroy.setTagData('reason', reason)
if jid:
destroy.setAttr('jid', jid)
return iq
def _make_publish_request(node, item, id_, options, jid):
query = Iq('set', to=jid)
pubsub = query.addChild('pubsub', namespace=Namespace.PUBSUB)
publish = pubsub.addChild('publish', {'node': node})
attrs = {}
if id_ is not None:
attrs = {'id': id_}
publish.addChild('item', attrs, [item])
if options:
publish = pubsub.addChild('publish-options')
publish.addChild(node=_make_publish_options(options))
return query
def _make_register_form(jid, form):
iq = Iq('set', Namespace.REGISTER, to=jid)
if form.is_fake_form():
query = iq.getTag('query')
for field in form.iter_fields():
if field.var == 'fakeform':
continue
query.addChild(field.var, payload=[field.value])
return iq
iq.setQueryPayload(form)
return iq
def _make_set_pref_request(default, always, never):
iq = Iq(typ='set')
prefs = iq.addChild(name='prefs',
namespace=Namespace.MAM_2,
attrs={'default': default})
always_node = prefs.addChild(name='always')
never_node = prefs.addChild(name='never')
for jid in always:
always_node.addChild(name='jid').setData(jid)
for jid in never:
never_node.addChild(name='jid').setData(jid)
return iq
def __init__(self, device_list):
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='set', attrs=attrs)
list_node = Node('list')
for device in device_list:
list_node.addChild('device').setAttr('id', device)
publish = PublishNode(NS_DEVICE_LIST, list_node)
pubsub = PubsubNode(publish)
self.addChild(node=pubsub)
def _make_set(jid, name, groups=None):
if groups is None:
groups = []
infos = {'jid': jid}
if name:
infos['name'] = name
iq = Iq('set', Namespace.ROSTER)
query = iq.setQuery()
item = query.addChild('item', attrs=infos)
for group in groups:
item.addChild('group').setData(group)
return iq
def __init__(self, device_list):
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='set', attrs=attrs)
list_node = Node('list')
for device in device_list:
list_node.addChild('device').setAttr('id', device)
publish = PublishNode(NS_DEVICE_LIST, list_node)
pubsub = PubsubNode(publish)
self.addChild(node=pubsub)
def __init__(self, device_list):
assert isinstance(device_list, list)
assert len(device_list) > 0
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='set', attrs=attrs)
list_node = Node('list', attrs={'xmlns': NS_OMEMO})
for device in device_list:
list_node.addChild('device').setAttr('id', device)
publish = PublishNode(NS_DEVICE_LIST, list_node)
pubsub = PubsubNode(publish)
self.addChild(node=pubsub)
def __init__(self, device_list):
assert isinstance(device_list, list)
assert len(device_list) > 0
id_ = gajim.get_an_id()
attrs = {'id': id_}
Iq.__init__(self, typ='set', attrs=attrs)
list_node = Node('list', attrs={'xmlns': NS_DEVICE_LIST})
for device in device_list:
list_node.addChild('device').setAttr('id', device)
publish = PublishNode(NS_DEVICE_LIST, list_node)
pubsub = PubsubNode(publish)
self.addChild(node=pubsub)
def _make_delete(jid):
return Iq('set',
Namespace.ROSTER,
payload=[Node('item', {
'jid': jid,
'subscription': 'remove'
})])
def test_non_unique_form_type_value(self):
node = """
<iq from='[email protected]/230193' id='disco1' to='[email protected]/chamber' type='result'>
<query xmlns='http://jabber.org/protocol/disco#info' node='http://psi-im.org#q07IKJEyjvHSyhy//CH0CxmKi8w='>
<identity xml:lang='en' category='client' name='Psi 0.11' type='pc'/>
<identity xml:lang='el' category='client' name='Ψ 0.11' type='pc'/>
<feature var='http://jabber.org/protocol/caps'/>
<feature var='http://jabber.org/protocol/disco#info'/>
<feature var='http://jabber.org/protocol/disco#items'/>
<feature var='http://jabber.org/protocol/muc'/>
<x xmlns='jabber:x:data' type='result'>
<field var='FORM_TYPE' type='hidden'>
<value>urn:xmpp:dataforms:softwareinfo</value>
</field>
<field var='ip_version'>
<value>ipv4</value>
<value>ipv6</value>
</field>
</x>
<x xmlns='jabber:x:data' type='result'>
<field var='FORM_TYPE' type='hidden'>
<value>urn:xmpp:dataforms:softwareinfo</value>
</field>
<field var='ip_version'>
<value>ipv4</value>
<value>ipv6</value>
</field>
</x>
</query>
</iq>"""
info = parse_disco_info(Iq(node=node))
with self.assertRaises(DiscoInfoMalformed):
hash_ = compute_caps_hash(info)
def make_cancel_config_request(room_jid):
cancel = Node(tag='x', attrs={'xmlns': Namespace.DATA, 'type': 'cancel'})
iq = Iq(typ='set',
queryNS=Namespace.MUC_OWNER,
payload=cancel,
to=room_jid)
return iq
def test_error_parsing(self):
stanza = '''
<iq from='upload.montague.tld'
id='step_03'
to='[email protected]/garden'
type='error'>
<error type='modify'>
<not-acceptable xmlns='urn:ietf:params:xml:ns:xmpp-stanzas' />
<text xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'>File too large. The maximum file size is 20000 bytes</text>
<text xml:lang='de' xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'>File zu groß. Erlaubt sind 20000 bytes</text>
<file-too-large xmlns='urn:xmpp:http:upload:0'>
<max-file-size>20000</max-file-size>
</file-too-large>
</error>
</iq>'''
error = error_factory(Iq(node=stanza))
self.assertEqual(error.condition, 'not-acceptable')
self.assertEqual(error.app_condition, 'file-too-large')
self.assertEqual(
error.get_text(),
'File too large. The maximum file size is 20000 bytes')
self.assertEqual(error.get_text('de'),
'File zu groß. Erlaubt sind 20000 bytes')
self.assertEqual(error.type, 'modify')
self.assertEqual(error.id, 'step_03')
self.assertEqual(error.jid, JID.from_string('upload.montague.tld'))
def store_bookmarks(self, bookmarks):
_task = yield
self._log.info('Store Bookmarks')
storage_node = build_storage_node(bookmarks)
response = yield Iq('set', Namespace.PRIVATE, payload=storage_node)
yield process_response(response)
def request_software_version(self, jid):
_task = yield
response = yield Iq(typ='get', to=jid, queryNS=Namespace.VERSION)
if response.isError():
raise StanzaError(response)
yield _parse_info(response)
def make_set_affiliation_request(room_jid, users_dict):
iq = Iq(typ='set', to=room_jid, queryNS=Namespace.MUC_ADMIN)
item = iq.setQuery()
for jid in users_dict:
affiliation = users_dict[jid].get('affiliation')
reason = users_dict[jid].get('reason')
nick = users_dict[jid].get('nick')
item_tag = item.addChild('item', {
'jid': jid,
'affiliation': affiliation
})
if reason is not None:
item_tag.setTagData('reason', reason)
if nick is not None:
item_tag.setAttr('nick', nick)
return iq
def request_register_form(self, jid=None):
_task = yield
if jid is None:
jid = self._client.domain
response = yield Iq('get', Namespace.REGISTER, to=jid)
if response.isError():
raise StanzaError(response)
yield _parse_register_data(response)
def test_ignore_invalid_forms(self):
node = """
<iq from='[email protected]/230193' id='disco1' to='[email protected]/chamber' type='result'>
<query xmlns='http://jabber.org/protocol/disco#info' node='http://psi-im.org#q07IKJEyjvHSyhy//CH0CxmKi8w='>
<identity xml:lang='en' category='client' name='Psi 0.11' type='pc'/>
<identity xml:lang='el' category='client' name='Ψ 0.11' type='pc'/>
<feature var='http://jabber.org/protocol/caps'/>
<feature var='http://jabber.org/protocol/disco#info'/>
<feature var='http://jabber.org/protocol/disco#items'/>
<feature var='http://jabber.org/protocol/muc'/>
<x xmlns='jabber:x:data' type='result'>
<field var='FORM_TYPE' type='hidden'>
<value>urn:xmpp:dataforms:softwareinfo</value>
</field>
<field var='ip_version'>
<value>ipv4</value>
<value>ipv6</value>
</field>
<field var='os'>
<value>Mac</value>
</field>
<field var='os_version'>
<value>10.5.1</value>
</field>
<field var='software'>
<value>Psi</value>
</field>
<field var='software_version'>
<value>0.11</value>
</field>
</x>
<x xmlns='jabber:x:data' type='result'>
<field var='FORM_TYPE'>
<value>urn:xmpp:dataforms:softwareinfo</value>
</field>
<field var='ip_version'>
<value>ipv4</value>
<value>ipv6</value>
</field>
</x>
<x xmlns='jabber:x:data' type='result'>
<field var='ip_version'>
<value>ipv4</value>
<value>ipv6</value>
</field>
</x>
</query>
</iq>"""
info = parse_disco_info(Iq(node=node))
hash_ = compute_caps_hash(info)
self.assertEqual(hash_, 'q07IKJEyjvHSyhy//CH0CxmKi8w=')
def test_non_unique_identity(self):
node = """
<iq from='[email protected]/230193' id='disco1' to='[email protected]/chamber' type='result'>
<query xmlns='http://jabber.org/protocol/disco#info' node='http://psi-im.org#q07IKJEyjvHSyhy//CH0CxmKi8w='>
<identity xml:lang='en' category='client' name='Psi 0.11' type='pc'/>
<identity xml:lang='en' category='client' name='Psi 0.11' type='pc'/>
<feature var='http://jabber.org/protocol/caps'/>
<feature var='http://jabber.org/protocol/muc'/>
<feature var='http://jabber.org/protocol/disco#info'/>
<feature var='http://jabber.org/protocol/disco#items'/>
<feature var='http://jabber.org/protocol/muc'/>
</query>
</iq>"""
info = parse_disco_info(Iq(node=node))
with self.assertRaises(DiscoInfoMalformed):
hash_ = compute_caps_hash(info)
def _make_request(jid, queryid, start, end, with_, after, max_):
iq = Iq(typ='set', to=jid, queryNS=Namespace.MAM_2)
if queryid is not None:
iq.getQuery().setAttr('queryid', queryid)
payload = [
_make_query_form(start, end, with_),
_make_rsm_query(max_, after)
]
iq.setQueryPayload(payload)
return iq
def _make_node_configuration_request(node, jid):
query = Iq('get', to=jid)
pubsub = query.addChild('pubsub', namespace=Namespace.PUBSUB_OWNER)
pubsub.addChild('configure', {'node': node})
return query
