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):
"""
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):
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(
Callback('IBB Open', StanzaPath('iq@type=set/ibb_open'),
self._handle_open_request))
self.xmpp.register_handler(
Callback('IBB Close', StanzaPath('iq@type=set/ibb_close'),
self._handle_close))
self.xmpp.register_handler(
Callback('IBB Data', StanzaPath('iq@type=set/ibb_data'),
self._handle_data))
self.xmpp.register_handler(
Callback('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.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):
""" 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.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):
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 run(self, payload, instream=False):
"""
Execute the callback function with the matched stanza's
XML contents, instead of the stanza itself.
Overrides BaseHandler.run
Arguments:
payload -- The matched stanza object.
instream -- Force the handler to execute during
stream processing. Used only by prerun.
Defaults to False.
"""
Callback.run(self, payload.xml, instream)
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 run(self, payload, instream=False):
"""
Execute the callback function with the matched stanza's
XML contents, instead of the stanza itself.
Overrides BaseHandler.run
Arguments:
payload -- The matched stanza object.
instream -- Force the handler to execute during
stream processing. Used only by prerun.
Defaults to False.
"""
Callback.run(self, payload.xml, instream)
def testIqErrorException(self):
"""Test using error exceptions with Iq stanzas."""
def handle_iq(iq):
raise XMPPError(condition='feature-not-implemented',
text="We don't do things that way here.",
etype='cancel',
clear=False)
self.stream_start()
self.xmpp.register_handler(
Callback('Test Iq',
MatchXPath('{%s}iq/{test}query' % self.xmpp.default_ns),
handle_iq))
self.recv("""
<iq type="get" id="0">
<query xmlns="test" />
</iq>
""")
self.send("""
<iq type="error" id="0">
<query xmlns="test" />
<error type="cancel" code="501">
<feature-not-implemented
xmlns="urn:ietf:params:xml:ns:xmpp-stanzas" />
<text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas">
We don't do things that way here.
</text>
</error>
</iq>
""",
use_values=False)
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 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 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):
"""Start the XEP-0224 plugin."""
register_stanza_plugin(Message, stanza.Attention)
self.xmpp.register_handler(
Callback('Attention', StanzaPath('message/attention'),
self._handle_attention))
def __init__(self, jid, secret, host=None, port=None, plugin_config=None, plugin_whitelist=None, use_jc_ns=False):
if not plugin_whitelist:
plugin_whitelist = []
if not plugin_config:
plugin_config = {}
if use_jc_ns:
default_ns = 'jabber:client'
else:
default_ns = 'jabber:component:accept'
BaseXMPP.__init__(self, jid, default_ns)
self.auto_authorize = None
self.stream_header = '<stream:stream %s %s to="%s">' % (
'xmlns="jabber:component:accept"',
'xmlns:stream="%s"' % self.stream_ns,
jid)
self.stream_footer = "</stream:stream>"
self.server_host = host
self.server_port = port
self.secret = secret
self.plugin_config = plugin_config
self.plugin_whitelist = plugin_whitelist
self.is_component = True
self.sessionstarted = False
self.register_handler(
Callback('Handshake',
MatchXPath('{jabber:component:accept}handshake'),
self._handle_handshake))
self.add_event_handler('presence_probe',
self._handle_probe)
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) -> None:
stanza.register_plugins()
self.xmpp.register_handler(
Callback(
"MIX message received",
MatchXPath('{%s}message[@type="groupchat"]/{%s}mix' %
(self.xmpp.default_ns, self.namespace)),
self._handle_mix_message,
))
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)
def plugin_init(self) -> None:
stanza.register_plugins()
self.xmpp.register_handler(
Callback(
'MIX Presence received',
MatchXPath('{%s}presence/{%s}mix' %
(self.xmpp.default_ns, stanza.NS)),
self._handle_mix_presence,
))