def plugin_init(self):
register_stanza_plugin(Message, Propose)
register_stanza_plugin(Message, Retract)
register_stanza_plugin(Message, Accept)
register_stanza_plugin(Message, Proceed)
register_stanza_plugin(Message, Reject)
self.xmpp.register_handler(
Callback('Indicating Intent to Start a Session',
StanzaPath('message/jingle_propose'),
self._handle_propose))
self.xmpp.register_handler(
Callback('Disavowing Intent to Start a Session',
StanzaPath('message/jingle_retract'),
self._handle_retract))
self.xmpp.register_handler(
Callback('Accepting Intent to Start a Session',
StanzaPath('message/jingle_accept'),
self._handle_accept))
self.xmpp.register_handler(
Callback('Proceed',
StanzaPath('message/jingle_proceed'),
self._handle_accept))
self.xmpp.register_handler(
Callback('Rejecting Intent to Start a Session',
StanzaPath('message/jingle_reject'),
self._handle_reject))
def plugin_init(self):
self._streams = {}
self._preauthed_sids = {}
register_stanza_plugin(Iq, Open)
register_stanza_plugin(Iq, Close)
register_stanza_plugin(Iq, Data)
register_stanza_plugin(Message, Data)
self.xmpp.register_handler(
CoroutineCallback('IBB Open', StanzaPath('iq@type=set/ibb_open'),
self._handle_open_request))
self.xmpp.register_handler(
CoroutineCallback('IBB Close', StanzaPath('iq@type=set/ibb_close'),
self._handle_close))
self.xmpp.register_handler(
CoroutineCallback('IBB Data', StanzaPath('iq@type=set/ibb_data'),
self._handle_data))
self.xmpp.register_handler(
CoroutineCallback('IBB Message Data',
StanzaPath('message/ibb_data'),
self._handle_data))
self.api.register(self._authorized, 'authorized', default=True)
self.api.register(self._authorized_sid, 'authorized_sid', default=True)
self.api.register(self._preauthorize_sid,
'preauthorize_sid',
default=True)
self.api.register(self._get_stream, 'get_stream', default=True)
self.api.register(self._set_stream, 'set_stream', default=True)
self.api.register(self._del_stream, 'del_stream', default=True)
def plugin_init(self):
self.node_event_map = {}
self.xmpp.register_handler(
Callback('Pubsub Event: Items',
StanzaPath('message/pubsub_event/items'),
self._handle_event_items))
self.xmpp.register_handler(
Callback('Pubsub Event: Purge',
StanzaPath('message/pubsub_event/purge'),
self._handle_event_purge))
self.xmpp.register_handler(
Callback('Pubsub Event: Delete',
StanzaPath('message/pubsub_event/delete'),
self._handle_event_delete))
self.xmpp.register_handler(
Callback('Pubsub Event: Configuration',
StanzaPath('message/pubsub_event/configuration'),
self._handle_event_configuration))
self.xmpp.register_handler(
Callback('Pubsub Event: Subscription',
StanzaPath('message/pubsub_event/subscription'),
self._handle_event_subscription))
self.xmpp['xep_0131'].supported_headers.add('SubID')
def plugin_init(self):
"""
Start the XEP-0030 plugin.
"""
self.xmpp.register_handler(
Callback('Disco Info', StanzaPath('iq/disco_info'),
self._handle_disco_info))
self.xmpp.register_handler(
Callback('Disco Items', StanzaPath('iq/disco_items'),
self._handle_disco_items))
register_stanza_plugin(Iq, DiscoInfo)
register_stanza_plugin(Iq, DiscoItems)
self.static = StaticDisco(self.xmpp, self)
self._disco_ops = [
'get_info', 'set_info', 'set_identities', 'set_features',
'get_items', 'set_items', 'del_items', 'add_identity',
'del_identity', 'add_feature', 'del_feature', 'add_item',
'del_item', 'del_identities', 'del_features', 'cache_info',
'get_cached_info', 'supports', 'has_identity'
]
for op in self._disco_ops:
self.api.register(getattr(self.static, op), op, default=True)
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
## For testning only
self.test_authenticated_from = ""
def plugin_init(self):
self._cids = {}
register_stanza_plugin(Iq, BitsOfBinary)
register_stanza_plugin(Message, BitsOfBinary)
register_stanza_plugin(Presence, BitsOfBinary)
self.xmpp.register_handler(
Callback('Bits of Binary - Iq',
StanzaPath('iq/bob'),
self._handle_bob_iq))
self.xmpp.register_handler(
Callback('Bits of Binary - Message',
StanzaPath('message/bob'),
self._handle_bob))
self.xmpp.register_handler(
Callback('Bits of Binary - Presence',
StanzaPath('presence/bob'),
self._handle_bob))
self.api.register(self._get_bob, 'get_bob', default=True)
self.api.register(self._set_bob, 'set_bob', default=True)
self.api.register(self._del_bob, 'del_bob', default=True)
def plugin_init(self):
self.gpg = GPG(gnupghome=self.gpg_home,
gpgbinary=self.gpg_binary,
use_agent=self.use_agent,
keyring=self.keyring)
self.xmpp.add_filter('out', self._sign_presence)
self._keyids = {}
self.api.register(self._set_keyid, 'set_keyid', default=True)
self.api.register(self._get_keyid, 'get_keyid', default=True)
self.api.register(self._del_keyid, 'del_keyid', default=True)
self.api.register(self._get_keyids, 'get_keyids', default=True)
register_stanza_plugin(Presence, Signed)
register_stanza_plugin(Message, Encrypted)
self.xmpp.add_event_handler('unverified_signed_presence',
self._handle_unverified_signed_presence)
self.xmpp.register_handler(
Callback('Signed Presence', StanzaPath('presence/signed'),
self._handle_signed_presence))
self.xmpp.register_handler(
Callback('Encrypted Message', StanzaPath('message/encrypted'),
self._handle_encrypted_message))
def plugin_init(self):
register_stanza_plugin(Iq, Confirm)
register_stanza_plugin(Message, Confirm)
self.xmpp.register_handler(
Callback('Confirm', StanzaPath('iq@type=get/confirm'),
self._handle_iq_confirm))
self.xmpp.register_handler(
Callback('Confirm', StanzaPath('message/confirm'),
self._handle_message_confirm))
def plugin_init(self):
stanza.register_plugins()
self.xmpp.register_handler(Callback(
'RAI Received',
StanzaPath("presence/rai"),
self._handle_rai,
))
self.xmpp.register_handler(Callback(
'RAI Activity Received',
StanzaPath("presence/rai/activity"),
self._handle_rai_activity,
))
def plugin_init(self):
register_stanza_plugin(Iq, BlockList)
register_stanza_plugin(Iq, Block)
register_stanza_plugin(Iq, Unblock)
self.xmpp.register_handler(
Callback('Blocked Contact', StanzaPath('iq@type=set/block'),
self._handle_blocked))
self.xmpp.register_handler(
Callback('Unblocked Contact', StanzaPath('iq@type=set/unblock'),
self._handle_unblocked))
def plugin_init(self):
self.xmpp.register_handler(
Callback('HTTP Request', StanzaPath('iq/http-req'),
self._handle_request))
self.xmpp.register_handler(
Callback('HTTP Response', StanzaPath('iq/http-resp'),
self._handle_response))
register_stanza_plugin(Iq, HTTPRequest, iterable=True)
register_stanza_plugin(Iq, HTTPResponse, iterable=True)
register_stanza_plugin(HTTPRequest, Headers, iterable=True)
register_stanza_plugin(HTTPRequest, HTTPData, iterable=True)
register_stanza_plugin(HTTPResponse, Headers, iterable=True)
register_stanza_plugin(HTTPResponse, HTTPData, iterable=True)
def plugin_init(self):
register_stanza_plugin(Message, Request)
register_stanza_plugin(Message, Received)
self.xmpp.add_filter('out', self._filter_add_receipt_request)
self.xmpp.register_handler(
Callback('Message Receipt', StanzaPath('message/receipt'),
self._handle_receipt_received))
self.xmpp.register_handler(
Callback('Message Receipt Request',
StanzaPath('message/request_receipt'),
self._handle_receipt_request))
def plugin_init(self):
register_stanza_plugin(StreamFeatures, RegisterFeature)
register_stanza_plugin(Iq, Register)
if self.xmpp.is_component:
self.xmpp["xep_0030"].add_feature("jabber:iq:register")
self.xmpp.register_handler(
CoroutineCallback(
"registration",
StanzaPath("/iq/register"),
self._handle_registration,
)
)
self._user_store = {}
self.api.register(self._user_get, "user_get")
self.api.register(self._user_remove, "user_remove")
self.api.register(self._make_registration_form, "make_registration_form")
self.api.register(self._user_validate, "user_validate")
else:
self.xmpp.register_feature(
"register",
self._handle_register_feature,
restart=False,
order=self.order,
)
register_stanza_plugin(Register, self.xmpp['xep_0004'].stanza.Form)
register_stanza_plugin(Register, self.xmpp['xep_0066'].stanza.OOB)
self.xmpp.add_event_handler('connected', self._force_registration)
def retrieve(self,
jid=None,
start=None,
end=None,
with_jid=None,
ifrom=None,
timeout=None,
callback=None,
iterator=False):
iq = self.xmpp.Iq()
query_id = iq['id']
iq['to'] = jid
iq['from'] = ifrom
iq['type'] = 'get'
iq['mam']['queryid'] = query_id
iq['mam']['start'] = start
iq['mam']['end'] = end
iq['mam']['with'] = with_jid
collector = Collector(
'MAM_Results_%s' % query_id,
StanzaPath('message/mam_result@queryid=%s' % query_id))
self.xmpp.register_handler(collector)
if iterator:
return self.xmpp['xep_0059'].iterate(iq, 'mam', 'results')
def wrapped_cb(iq):
results = collector.stop()
if iq['type'] == 'result':
iq['mam']['results'] = results
callback(iq)
return iq.send(timeout=timeout, callback=wrapped_cb)
def view(self, nodes, ifrom=None, timeout=None, callback=None,
timeout_callback=None):
if not isinstance(nodes, (list, set)):
nodes = [nodes]
iq = self.xmpp.Iq()
iq['type'] = 'get'
iq['from'] = ifrom
offline = iq['offline']
for node in nodes:
item = stanza.Item()
item['node'] = node
item['action'] = 'view'
offline.append(item)
collector = Collector(
'Offline_Results_%s' % iq['id'],
StanzaPath('message/offline'))
self.xmpp.register_handler(collector)
def wrapped_cb(iq):
results = collector.stop()
if iq['type'] == 'result':
iq['offline']['results'] = results
callback(iq)
iq.send(timeout=timeout, callback=wrapped_cb,
timeout_callback=timeout_callback)
def plugin_init(self):
register_stanza_plugin(Message, Markable)
register_stanza_plugin(Message, Received)
register_stanza_plugin(Message, Displayed)
register_stanza_plugin(Message, Acknowledged)
self.xmpp.register_handler(
Callback('Received Chat Marker', StanzaPath('message/received'),
self._handle_received))
self.xmpp.register_handler(
Callback('Displayed Chat Marker', StanzaPath('message/displayed'),
self._handle_displayed))
self.xmpp.register_handler(
Callback('Acknowledged Chat Marker',
StanzaPath('message/acknowledged'),
self._handle_acknowledged))
def retrieve(self,
jid=None,
start=None,
end=None,
with_jid=None,
ifrom=None,
timeout=None,
callback=None,
iterator=False,
rsm=None):
iq = self.xmpp.Iq()
query_id = iq['id']
iq['to'] = jid
iq['from'] = ifrom
iq['type'] = 'set'
iq['mam']['queryid'] = query_id
iq['mam']['start'] = start
iq['mam']['end'] = end
iq['mam']['with'] = with_jid
if rsm:
for key, value in rsm.items():
iq['mam']['rsm'][key] = str(value)
cb_data = {}
def pre_cb(query):
query['mam']['queryid'] = query['id']
collector = Collector(
'MAM_Results_%s' % query_id,
StanzaPath('message/mam_result@queryid=%s' % query['id']))
self.xmpp.register_handler(collector)
cb_data['collector'] = collector
def post_cb(result):
results = cb_data['collector'].stop()
if result['type'] == 'result':
result['mam']['results'] = results
if iterator:
return self.xmpp['xep_0059'].iterate(iq,
'mam',
'results',
recv_interface='mam_fin',
pre_cb=pre_cb,
post_cb=post_cb)
collector = Collector(
'MAM_Results_%s' % query_id,
StanzaPath('message/mam_result@queryid=%s' % query_id))
self.xmpp.register_handler(collector)
def wrapped_cb(iq):
results = collector.stop()
if iq['type'] == 'result':
iq['mam']['results'] = results
if callback:
callback(iq)
return iq.send(timeout=timeout, callback=wrapped_cb)
def plugin_init(self):
self.xmpp.register_handler(
Callback('Direct MUC Invitations',
StanzaPath('message/groupchat_invite'),
self._handle_invite))
register_stanza_plugin(Message, Invite)
def plugin_init(self):
register_stanza_plugin(Iq, stanza.UserSettings)
self.xmpp.register_handler(
Callback('Google Settings',
StanzaPath('iq@type=set/google_settings'),
self._handle_settings_change))
def plugin_init(self):
"""Start the XEP-0224 plugin."""
register_stanza_plugin(Message, stanza.Attention)
self.xmpp.register_handler(
Callback('Attention', StanzaPath('message/attention'),
self._handle_attention))
def pre_cb(query):
query['mam']['queryid'] = query['id']
collector = Collector(
'MAM_Results_%s' % query_id,
StanzaPath('message/mam_result@queryid=%s' % query['id']))
self.xmpp.register_handler(collector)
cb_data['collector'] = collector
def rawxml(self, args):
"""
/rawxml <xml stanza>
"""
if not args:
return
stanza = args
try:
stanza = StanzaBase(self.core.xmpp, xml=ET.fromstring(stanza))
if stanza.xml.tag == 'iq' and stanza.xml.attrib.get('type') in (
'get', 'set'):
iq_id = stanza.xml.attrib.get('id')
if not iq_id:
iq_id = self.core.xmpp.new_id()
stanza['id'] = iq_id
def iqfunc(iq):
"handler for an iq reply"
self.core.information('%s' % iq, 'Iq')
self.core.xmpp.remove_handler('Iq %s' % iq_id)
self.core.xmpp.register_handler(
Callback('Iq %s' % iq_id, StanzaPath('iq@id=%s' % iq_id),
iqfunc))
stanza.send()
except:
self.core.information('Could not send custom stanza', 'Error')
log.debug('/rawxml: Could not send custom stanza (%s)',
repr(stanza),
exc_info=True)
def plugin_init(self):
register_stanza_plugin(Message, stanza.NoSave)
register_stanza_plugin(Iq, stanza.NoSaveQuery)
self.xmpp.register_handler(
Callback('Google Nosave', StanzaPath('iq@type=set/google_nosave'),
self._handle_nosave_change))
def plugin_init(self) -> None:
stanza.register_plugins()
self.xmpp.register_handler(
Callback(
"Message Retracted",
StanzaPath("message/apply_to/retract"),
self._handle_retract_message,
))
def plugin_init(self) -> None:
stanza.register_plugins()
self.xmpp.register_handler(Callback(
'Action received',
StanzaPath('message/action'),
self._handle_action,
))
self.xmpp.register_handler(Callback(
'Response received',
StanzaPath('message/response'),
self._handle_response,
))
self.xmpp.register_handler(Callback(
'ActionSelected received',
StanzaPath('message/action_selected'),
self._handle_action_selected,
))
def plugin_init(self):
self.xmpp.register_handler(
Callback('Data Form', StanzaPath('message/form'),
self.handle_form))
register_stanza_plugin(FormField, FieldOption, iterable=True)
register_stanza_plugin(Form, FormField, iterable=True)
register_stanza_plugin(Message, Form)
def plugin_init(self) -> None:
stanza.register_plugins()
self.xmpp.register_handler(
Callback(
'Moderated Message',
StanzaPath('message/apply_to/moderated/retract'),
self._handle_moderated,
))
def plugin_init(self):
self.xmpp.register_handler(
Callback('Message Correction', StanzaPath('message/replace'),
self._handle_correction))
register_stanza_plugin(Message, Replace)
self.xmpp.use_message_ids = True
def plugin_init(self):
self.xmpp.register_handler(
Callback('Carbon Received', StanzaPath('message/carbon_received'),
self._handle_carbon_received))
self.xmpp.register_handler(
Callback('Carbon Sent', StanzaPath('message/carbon_sent'),
self._handle_carbon_sent))
register_stanza_plugin(Message, stanza.ReceivedCarbon)
register_stanza_plugin(Message, stanza.SentCarbon)
register_stanza_plugin(Message, stanza.PrivateCarbon)
register_stanza_plugin(Iq, stanza.CarbonEnable)
register_stanza_plugin(Iq, stanza.CarbonDisable)
register_stanza_plugin(stanza.ReceivedCarbon,
self.xmpp['xep_0297'].stanza.Forwarded)
register_stanza_plugin(stanza.SentCarbon,
self.xmpp['xep_0297'].stanza.Forwarded)
def plugin_init(self):
self._idle_stamps = {}
register_stanza_plugin(Presence, stanza.Idle)
self.api.register(self._set_idle, 'set_idle', default=True)
self.api.register(self._get_idle, 'get_idle', default=True)
self.xmpp.register_handler(
Callback('Idle Presence', StanzaPath('presence/idle'),
self._idle_presence))
self.xmpp.add_filter('out', self._stamp_idle_presence)
