def plugin_init(self):
self.description = "XEP-0138: Stream Compression"
self.xmpp.register_feature(
"compression", self._handle_compression, restart=False, order=self.config.get("order", 0)
)
register_stanza_plugin(StreamFeatures, CompressionStanza)
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.use_cache = self.config.get('use_cache', True)
self.wrap_results = self.config.get('wrap_results', False)
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):
self._cids = {}
self.xmpp['xep_0030'].add_feature('urn:xmpp:bob')
register_stanza_plugin(Iq, 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):
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-0050 plugin."""
self.xep = '0050'
self.description = 'Ad-Hoc Commands'
self.stanza = stanza
self.threaded = self.config.get('threaded', True)
self.commands = {}
self.sessions = self.config.get('session_db', {})
self.xmpp.register_handler(
Callback("Ad-Hoc Execute",
StanzaPath('iq@type=set/command'),
self._handle_command))
register_stanza_plugin(Iq, stanza.Command)
self.xmpp.add_event_handler('command_execute',
self._handle_command_start,
threaded=self.threaded)
self.xmpp.add_event_handler('command_next',
self._handle_command_next,
threaded=self.threaded)
self.xmpp.add_event_handler('command_cancel',
self._handle_command_cancel,
threaded=self.threaded)
self.xmpp.add_event_handler('command_complete',
self._handle_command_complete,
threaded=self.threaded)
def plugin_init(self):
self.xmpp.register_feature('preapproval',
self._handle_preapproval,
restart=False,
order=9001)
register_stanza_plugin(StreamFeatures, stanza.PreApproval)
def post_init(self):
base_plugin.post_init(self)
if 'xep_0004' in self.xmpp.plugin:
register_stanza_plugin(Register, self.xmpp['xep_0004'].stanza.Form)
if 'xep_0066' in self.xmpp.plugin:
register_stanza_plugin(Register, self.xmpp['xep_0066'].stanza.OOB)
def plugin_init(self):
"""Start the XEP-0050 plugin."""
self.threaded = self.config.get('threaded', True)
self.commands = {}
self.sessions = self.config.get('session_db', {})
self.xmpp.register_handler(
Callback("Ad-Hoc Execute",
StanzaPath('iq@type=set/command'),
self._handle_command))
register_stanza_plugin(Iq, Command)
register_stanza_plugin(Command, Form)
self.xmpp.add_event_handler('command_execute',
self._handle_command_start,
threaded=self.threaded)
self.xmpp.add_event_handler('command_next',
self._handle_command_next,
threaded=self.threaded)
self.xmpp.add_event_handler('command_cancel',
self._handle_command_cancel,
threaded=self.threaded)
self.xmpp.add_event_handler('command_complete',
self._handle_command_complete,
threaded=self.threaded)
self.xmpp['xep_0030'].add_feature(Command.namespace)
self.xmpp['xep_0030'].set_items(node=Command.namespace, items=tuple())
def __init__(self, hostname, jid, password, room, nick, roompass, loop, jibri_start_callback, jibri_stop_callback, jibri_health_callback, recording_lock, signal_queue):
sleekxmpp.ClientXMPP.__init__(self, jid, password)
self.hostname = hostname
self.room = room
self.nick = nick
self.roompass = roompass
self.jid = jid
self.jibri_start_callback = jibri_start_callback
self.jibri_stop_callback = jibri_stop_callback
self.jibri_health_callback = jibri_health_callback
self.recording_lock = recording_lock
self.queue = signal_queue
self.loop = loop
self.controllerJid = ''
self.asyncio_init_flag = False
self.add_event_handler("session_start", self.start)
self.add_event_handler("muc::%s::got_online"%self.room,
self.muc_online)
self.register_handler(
Callback('Jibri IQ callback',
StanzaPath('iq@type=set/jibri'),
self.on_jibri_iq))
register_stanza_plugin(Iq, JibriElement)
register_stanza_plugin(Iq, JibriStatusElement)
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):
self.xep = '0086'
self.description = 'Error Condition Mappings'
self.stanza = stanza
register_stanza_plugin(Error, LegacyError,
overrides=self.config.get('override', True))
def plugin_init(self):
"""
Start the XEP-0199 plugin.
"""
self.description = 'XMPP Ping'
self.xep = '0199'
self.stanza = stanza
self.keepalive = self.config.get('keepalive', False)
self.frequency = float(self.config.get('frequency', 300))
self.timeout = self.config.get('timeout', 30)
register_stanza_plugin(Iq, Ping)
self.xmpp.register_handler(
Callback('Ping',
StanzaPath('iq@type=get/ping'),
self._handle_ping))
if self.keepalive:
self.xmpp.add_event_handler('session_start',
self._handle_keepalive,
threaded=True)
self.xmpp.add_event_handler('session_end',
self._handle_session_end)
def testPublishSingle(self):
"""Test publishing a single item."""
payload = AtomEntry()
payload['title'] = 'Test'
register_stanza_plugin(self.xmpp['xep_0060'].stanza.Item, AtomEntry)
self.xmpp['xep_0060'].publish(
'pubsub.example.com',
'somenode',
id='id42',
payload=payload,
block=False)
self.send("""
<iq type="set" id="1" to="pubsub.example.com">
<pubsub xmlns="http://jabber.org/protocol/pubsub">
<publish node="somenode">
<item id="id42">
<entry xmlns="http://www.w3.org/2005/Atom">
<title>Test</title>
</entry>
</item>
</publish>
</pubsub>
</iq>
""")
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,
threaded=True)
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-0030 plugin.
"""
self.xep = '0030'
self.description = 'Service Discovery'
self.stanza = sleekxmpp.plugins.xep_0030.stanza
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._disco_ops = ['get_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']
self.default_handlers = {}
self._handlers = {}
for op in self._disco_ops:
self._add_disco_op(op, getattr(self.static, op))
def plugin_init(self):
"""Start the XEP-0128 plugin."""
self._disco_ops = ['set_extended_info',
'add_extended_info',
'del_extended_info']
register_stanza_plugin(DiscoInfo, Form, iterable=True)
def plugin_init(self):
self.xmpp.register_feature('rosterver',
self._handle_rosterver,
restart=False,
order=9000)
register_stanza_plugin(StreamFeatures, stanza.RosterVer)
def plugin_init(self):
"""Start the XEP-0050 plugin."""
self.sessions = self.session_db
if self.sessions is None:
self.sessions = {}
self.commands = {}
self.xmpp.register_handler(
Callback("Ad-Hoc Execute",
StanzaPath('iq@type=set/command'),
self._handle_command))
register_stanza_plugin(Iq, Command)
register_stanza_plugin(Command, Form)
self.xmpp.add_event_handler('command_execute',
self._handle_command_start,
threaded=self.threaded)
self.xmpp.add_event_handler('command_next',
self._handle_command_next,
threaded=self.threaded)
self.xmpp.add_event_handler('command_cancel',
self._handle_command_cancel,
threaded=self.threaded)
self.xmpp.add_event_handler('command_complete',
self._handle_command_complete,
threaded=self.threaded)
def plugin_init(self):
self.xmpp.namespace_map['http://www.google.com/talk/protocol/auth'] = 'ga'
register_stanza_plugin(self.xmpp['feature_mechanisms'].stanza.Auth,
stanza.GoogleAuth)
self.xmpp.add_filter('out', self._auth)
def plugin_init(self):
self.xep = '0050'
self.description = 'Ad-Hoc Commands'
self.threaded = self.config.get('threaded', True)
self.addCommand = self.add_command
self.getNewSession = self.new_session
self.xmpp.register_handler(
Callback("Ad-Hoc Execute",
StanzaPath('iq@type=set/command'),
self._handle_command))
register_stanza_plugin(Iq, Command)
self.xmpp.add_event_handler('command_execute',
self._handle_command_start,
threaded=self.threaded)
self.xmpp.add_event_handler('command_next',
self._handle_command_next,
threaded=self.threaded)
self.xmpp.add_event_handler('command_cancel',
self._handle_command_cancel,
threaded=self.threaded)
self.xmpp.add_event_handler('command_complete',
self._handle_command_complete,
threaded=self.threaded)
self.commands = {}
self.sessions = {}
def plugin_init(self):
self.name = 'SASL Mechanisms'
self.rfc = '6120'
self.description = "SASL Stream Feature"
self.stanza = stanza
self.use_mech = self.config.get('use_mech', None)
def tls_active():
return 'starttls' in self.xmpp.features
def basic_callback(mech, values):
if 'username' in values:
values['username'] = self.xmpp.boundjid.user
if 'password' in values:
values['password'] = self.xmpp.password
mech.fulfill(values)
sasl_callback = self.config.get('sasl_callback', None)
if sasl_callback is None:
sasl_callback = basic_callback
self.mech = None
self.sasl = suelta.SASL(self.xmpp.boundjid.domain, 'xmpp',
username=self.xmpp.boundjid.user,
sec_query=suelta.sec_query_allow,
request_values=sasl_callback,
tls_active=tls_active,
mech=self.use_mech)
register_stanza_plugin(StreamFeatures, stanza.Mechanisms)
self.xmpp.register_stanza(stanza.Success)
self.xmpp.register_stanza(stanza.Failure)
self.xmpp.register_stanza(stanza.Auth)
self.xmpp.register_stanza(stanza.Challenge)
self.xmpp.register_stanza(stanza.Response)
self.xmpp.register_handler(
Callback('SASL Success',
MatchXPath(stanza.Success.tag_name()),
self._handle_success,
instream=True,
once=True))
self.xmpp.register_handler(
Callback('SASL Failure',
MatchXPath(stanza.Failure.tag_name()),
self._handle_fail,
instream=True,
once=True))
self.xmpp.register_handler(
Callback('SASL Challenge',
MatchXPath(stanza.Challenge.tag_name()),
self._handle_challenge))
self.xmpp.register_feature('mechanisms',
self._handle_sasl_auth,
restart=True,
order=self.config.get('order', 100))
def plugin_init(self):
self.xmpp.register_feature('session',
self._handle_start_session,
restart=False,
order=10001)
register_stanza_plugin(Iq, stanza.Session)
register_stanza_plugin(StreamFeatures, stanza.Session)
def plugin_init(self):
self.xmpp['xep_0163'].register_pep('avatar_metadata', MetaData)
pubsub_stanza = self.xmpp['xep_0060'].stanza
register_stanza_plugin(pubsub_stanza.Item, Data)
register_stanza_plugin(pubsub_stanza.EventItem, Data)
self.xmpp['xep_0060'].map_node_event(Data.namespace, 'avatar_data')
def plugin_init(self):
"""Start the XEP-0203 plugin."""
self.xep = '0203'
self.description = 'Delayed Delivery'
self.stanza = stanza
register_stanza_plugin(Message, stanza.Delay)
register_stanza_plugin(Presence, stanza.Delay)
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):
self.xmpp.register_feature('auth',
self._handle_auth,
restart=False,
order=self.config.get('order', 15))
register_stanza_plugin(Iq, stanza.IqAuth)
register_stanza_plugin(StreamFeatures, stanza.AuthFeature)
def plugin_init(self):
"""
Configure the plugin to handle the private storage of data.
:return:
"""
self._configuration = dict()
register_stanza_plugin(ConfigurationStanza, EntryStanza, iterable=True)
self.xmpp.add_event_handler("session_start", self._start)
def plugin_init(self):
self.xmpp.register_feature('bind',
self._handle_bind_resource,
restart=False,
order=10000)
register_stanza_plugin(Iq, stanza.Bind)
register_stanza_plugin(StreamFeatures, stanza.Bind)
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 plugin_init(self):
self.xmpp.register_handler(
Callback('Direct MUC Invitations',
StanzaPath('message/groupchat_invite'),
self._handle_invite))
register_stanza_plugin(Message, Invite)
self.xmpp['xep_0030'].add_feature(Invite.namespace)
def __init__(self,CFxHandle,paramDict,ModuleName):
ControllerModule.__init__(self,CFxHandle,paramDict,ModuleName)
self.xmpp_peers = defaultdict(int)
# need to maintain uid<->jid mapping to route xmpp messages.
self.uid_jid = {}
self.jid_uid = defaultdict(lambda:['',False])
self.xmpp_username = self.CMConfig.get("username")
self.xmpp_passwd = self.CMConfig.get("password")
self.xmpp_host = self.CMConfig.get("xmpp_host")
self.uid = ""
# time of last recvd xmpp advt.
self.last_sent_advt = 0
# keeps track of if xmpp advt recvd in interval
self.xmpp_advt_recvd = True
# Initial ADVT Delay
self.INITIAL_ADVT_DELAY =5
# interval between sending advertisements
self.advt_delay = self.INITIAL_ADVT_DELAY
# Maximum delay between advertisements is 10 minutes
self.MAX_ADVT_DELAY = 600
# initialize the base Xmpp client class
sleekxmpp.ClientXMPP.__init__(self,self.xmpp_username,self.xmpp_passwd,sasl_mech='PLAIN')
self['feature_mechanisms'].unencrypted_plain = True
# register a new plugin stanza and handler for it,
# whenever a matching message will be received on
# the xmpp stream , registered handler will be called.
register_stanza_plugin(Message, Ipop_Msg)
self.registerHandler(
Callback('Ipop',
StanzaPath('message/Ipop'),
self.MsgListener))
# Register event handler for session start
self.add_event_handler("session_start",self.start)
# calculate UID, for the meantime
# address mapping
self.uid_ip4_table = {}
self.ip4_uid_table = {}
# populate uid_ip4_table and ip4_uid_table with all UID and IPv4
# mappings within the /16 subnet
parts = self.CMConfig["ip4"].split(".")
ip_prefix = parts[0] + "." + parts[1] + "."
for i in range(0, 255):
for j in range(0, 255):
ip4 = ip_prefix + str(i) + "." + str(j)
uid = fxlib.gen_uid(ip4)
self.uid_ip4_table[uid] = ip4
self.ip4_uid_table[ip4] = uid
self.uid = self.ip4_uid_table[self.CMConfig["ip4"]]
# Start xmpp handling thread
self.xmpp_handler()
def plugin_init(self):
self.description = "upload files via http"
self.xep = "0999"
self.xmpp['xep_0030'].add_feature("urn:xmpp:http:upload")
self.xmpp['xep_0030'].add_identity(category='store',
itype='file',
name='HTTP File Upload')
self.xmpp.register_handler(
Callback(
'Upload request',
MatchXPath('{%s}iq/{urn:xmpp:http:upload}request' %
self.xmpp.default_ns), self._handleUpload))
register_stanza_plugin(Iq, UploadRequest)
register_stanza_plugin(Iq, UploadSlot)
def plugin_init(self):
"""Start the XEP-0203 plugin."""
if not self.local_time:
def default_local_time(jid):
return xep_0082.datetime(offset=self.tz_offset)
self.local_time = default_local_time
self.xmpp.registerHandler(
Callback('Entity Time',
StanzaPath('iq/entity_time'),
self._handle_time_request))
register_stanza_plugin(Iq, stanza.EntityTime)
def __init__(self, user, pwd, server, controller=None, device_name=None):
self.server_name = server
self.controller = controller
self.device_name = device_name
self.pending_queries = {}
self.xmpp_id = user
self.xmpp_host = server
self.xmpp_port = 5222
sleekxmpp.ClientXMPP.__init__(self, user, pwd)
register_stanza_plugin(Message, remoteSignal)
self.register_handler(
Callback('remote', StanzaPath('message/remote'), self.MSGListener))
self.add_event_handler("session_start", self.start)
self.xmpp_handler()
def plugin_init(self):
self.streams = {}
self.pending_streams = {}
self.pending_close_streams = {}
self._stream_lock = threading.Lock()
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))
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):
self.xmpp.register_handler(
Callback('STARTTLS Proceed',
MatchXPath(stanza.Proceed.tag_name()),
self._handle_starttls_proceed,
instream=True))
self.xmpp.register_feature('starttls',
self._handle_starttls,
restart=True,
order=self.config.get('order', 0))
self.xmpp.register_stanza(stanza.Proceed)
self.xmpp.register_stanza(stanza.Failure)
register_stanza_plugin(StreamFeatures, stanza.STARTTLS)
def __init__(self, sjid, password, room, nick, ratingsbot):
sleekxmpp.ClientXMPP.__init__(self, sjid, password)
self.sjid = sjid
self.room = room
self.nick = nick
self.ratingsBotWarned = False
self.ratingsBot = ratingsbot
# Game collection
self.gameList = GameList()
# Store mapping of nicks and XmppIDs, attached via presence stanza
self.nicks = {}
self.presences = {} # Obselete when XEP-0060 is implemented.
self.lastLeft = ""
register_stanza_plugin(Iq, PlayerXmppPlugin)
register_stanza_plugin(Iq, GameListXmppPlugin)
register_stanza_plugin(Iq, BoardListXmppPlugin)
register_stanza_plugin(Iq, GameReportXmppPlugin)
register_stanza_plugin(Iq, ProfileXmppPlugin)
self.register_handler(Callback('Iq Player',
StanzaPath('iq/player'),
self.iqhandler,
instream=True))
self.register_handler(Callback('Iq Gamelist',
StanzaPath('iq/gamelist'),
self.iqhandler,
instream=True))
self.register_handler(Callback('Iq Boardlist',
StanzaPath('iq/boardlist'),
self.iqhandler,
instream=True))
self.register_handler(Callback('Iq GameReport',
StanzaPath('iq/gamereport'),
self.iqhandler,
instream=True))
self.register_handler(Callback('Iq Profile',
StanzaPath('iq/profile'),
self.iqhandler,
instream=True))
self.add_event_handler("session_start", self.start)
self.add_event_handler("muc::%s::got_online" % self.room, self.muc_online)
self.add_event_handler("muc::%s::got_offline" % self.room, self.muc_offline)
self.add_event_handler("groupchat_message", self.muc_message)
self.add_event_handler("changed_status", self.presence_change)
def plugin_init(self):
self.rooms = {}
self.ourNicks = {}
self.xep = '0045'
# load MUC support in presence stanzas
register_stanza_plugin(Presence, MUCPresence)
self.xmpp.register_handler(Callback('MUCPresence', MatchXMLMask("<presence xmlns='%s' />" % self.xmpp.default_ns), self.handle_groupchat_presence))
self.xmpp.register_handler(Callback('MUCError', MatchXMLMask("<message xmlns='%s' type='error'><error/></message>" % self.xmpp.default_ns), self.handle_groupchat_error_message))
self.xmpp.register_handler(Callback('MUCMessage', MatchXMLMask("<message xmlns='%s' type='groupchat'><body/></message>" % self.xmpp.default_ns), self.handle_groupchat_message))
self.xmpp.register_handler(Callback('MUCSubject', MatchXMLMask("<message xmlns='%s' type='groupchat'><subject/></message>" % self.xmpp.default_ns), self.handle_groupchat_subject))
self.xmpp.register_handler(Callback('MUCConfig', MatchXMLMask("<message xmlns='%s' type='groupchat'><x xmlns='http://jabber.org/protocol/muc#user'><status/></x></message>" % self.xmpp.default_ns), self.handle_config_change))
self.xmpp.register_handler(Callback('MUCInvite', MatchXPath("{%s}message/{%s}x/{%s}invite" % (
self.xmpp.default_ns,
'http://jabber.org/protocol/muc#user',
'http://jabber.org/protocol/muc#user')), self.handle_groupchat_invite))
def __init__(self, social_info):
print("initializing xmpp agent")
self.user_id = social_info["username"]
self.social_password = social_info["password"]
self.xmpp_host = social_info["server"]
self.controller = social_info["gateway"]
self.device_names = social_info["devices"]
self.pending_queries = {}
self.xmpp_port = 5222
sleekxmpp.ClientXMPP.__init__(self, self.user_id, self.social_password)
register_stanza_plugin(Message, DNS_Msg)
self.register_handler(
Callback('DNS', StanzaPath('message/DNS'), self.MSGListener))
self.add_event_handler("session_start", self.start)
self.xmpp_handler()
def start(self, event):
try:
for xmpp_detail in list(self.ipop_xmpp_details.values()):
# Check whether Callback functions are configured for XMPP server messages
if xmpp_detail["callbackinit"] is False:
xmpp_detail["callbackinit"] = True
xmpp_detail["XMPPObj"].get_roster() # Obtains the friends list for the user
xmpp_detail["XMPPObj"].send_presence(pstatus="uid_is#"+xmpp_detail["uid"]) # Sends presence message when the XMPP user is online
# Event to capture all online peer nodes as seen by the XMPP server
xmpp_detail["XMPPObj"].add_event_handler("presence_available", self.handle_presence)
# Register IPOP message with the server
register_stanza_plugin(Message, IpopMsg)
xmpp_detail["XMPPObj"].registerHandler(Callback('Ipop', StanzaPath('message/Ipop'), self.xmppmessagelistener))
except Exception as err:
self.log("Exception in XMPPClient:{0} Event:{1}".format(err, event), severity="error")
def plugin_init(self):
register_stanza_plugin(Message, Forwarded)
# While these are marked as iterable, that is just for
# making it easier to extract the forwarded stanza. There
# still can be only a single forwarded stanza.
register_stanza_plugin(Forwarded, Message, iterable=True)
register_stanza_plugin(Forwarded, Presence, iterable=True)
register_stanza_plugin(Forwarded, Iq, iterable=True)
register_stanza_plugin(Forwarded, self.xmpp['xep_0203'].stanza.Delay)
self.xmpp.register_handler(
Callback('Forwarded Stanza', StanzaPath('message/forwarded'),
self._handle_forwarded))
def plugin_init(self):
"""
Start the XEP-0054 plugin.
"""
register_stanza_plugin(Iq, VCardTemp)
self.api.register(self._set_vcard, 'set_vcard', default=True)
self.api.register(self._get_vcard, 'get_vcard', default=True)
self.api.register(self._del_vcard, 'del_vcard', default=True)
self._vcard_cache = {}
self.xmpp.register_handler(
Callback('VCardTemp', StanzaPath('iq/vcard_temp'),
self._handle_get_vcard))
def _process_command_response(self, iq, session):
"""
Generate a command reply stanza based on the
provided session data.
Arguments:
iq -- The command request stanza.
session -- A dictionary of relevant session data.
"""
sessionid = session['id']
payload = session['payload']
if not isinstance(payload, list):
payload = [payload]
session['interfaces'] = [item.plugin_attrib for item in payload]
session['payload_classes'] = [item.__class__ for item in payload]
self.sessions[sessionid] = session
for item in payload:
register_stanza_plugin(Command, item.__class__, iterable=True)
iq.reply()
iq['command']['node'] = session['node']
iq['command']['sessionid'] = session['id']
if session['next'] is None:
iq['command']['actions'] = []
iq['command']['status'] = 'completed'
elif session['has_next']:
actions = ['next']
if session['allow_complete']:
actions.append('complete')
if session['allow_prev']:
actions.append('prev')
iq['command']['actions'] = actions
iq['command']['status'] = 'executing'
else:
iq['command']['actions'] = ['complete']
iq['command']['status'] = 'executing'
iq['command']['notes'] = session['notes']
for item in payload:
iq['command'].append(item)
iq.send()
def plugin_init(self):
"""
Start the XEP-0199 plugin.
"""
register_stanza_plugin(Iq, Ping)
self.xmpp.register_handler(
Callback('Ping', StanzaPath('iq@type=get/ping'),
self._handle_ping))
if self.keepalive:
self.xmpp.add_event_handler('session_start',
self.enable_keepalive,
threaded=True)
self.xmpp.add_event_handler('session_end', self.disable_keepalive)
def __init__(self, id, password):
ClientXMPP.__init__(self, id, password, sasl_mech='PLAIN')
self.auto_reconnect = True
self.connecton_draining = False
self.MSG = '<message><gcm xmlns="google:mobile:data">{0}</gcm></message>'
self.QUEUE = []
self.ACKS = {}
register_stanza_plugin(Message, GCMMessage)
self.register_handler(
Callback('GCM Message', StanzaPath('message/gcm'),
self.on_gcm_message))
self.add_event_handler('session_start', self.session_start)
self.add_event_handler('disconnected', self.on_disconnected)
def testPublishSingleOptions(self):
"""Test publishing a single item, with options."""
payload = AtomEntry()
payload['title'] = 'Test'
register_stanza_plugin(self.xmpp['xep_0060'].stanza.Item, AtomEntry)
options = self.xmpp['xep_0004'].make_form()
options.add_field(
var='FORM_TYPE',
ftype='hidden',
value='http://jabber.org/protocol/pubsub#publish-options')
options.add_field(var='pubsub#access_model',
ftype='text-single',
value='presence')
options['type'] = 'submit'
self.xmpp['xep_0060'].publish('pubsub.example.com',
'somenode',
id='ID42',
payload=payload,
options=options,
block=False)
self.send("""
<iq type="set" id="1" to="pubsub.example.com">
<pubsub xmlns="http://jabber.org/protocol/pubsub">
<publish node="somenode">
<item id="ID42">
<entry xmlns="http://www.w3.org/2005/Atom">
<title>Test</title>
</entry>
</item>
</publish>
<publish-options>
<x xmlns="jabber:x:data" type="submit">
<field var="FORM_TYPE">
<value>http://jabber.org/protocol/pubsub#publish-options</value>
</field>
<field var="pubsub#access_model">
<value>presence</value>
</field>
</x>
</publish-options>
</pubsub>
</iq>
""",
use_values=False)
def plugin_init(self):
"""Start the XEP-0128 plugin."""
self._disco_ops = [
'set_extended_info', 'add_extended_info', 'del_extended_info'
]
register_stanza_plugin(DiscoInfo, Form, iterable=True)
self.disco = self.xmpp['xep_0030']
self.static = StaticExtendedDisco(self.disco.static)
self.disco.set_extended_info = self.set_extended_info
self.disco.add_extended_info = self.add_extended_info
self.disco.del_extended_info = self.del_extended_info
for op in self._disco_ops:
self.api.register(getattr(self.static, op), op, default=True)
def _start_xmpp_listener():
"""Register plugins and create xmpp listener."""
register_stanza_plugin(Message, HTMLIM)
config = ConfigParser.RawConfigParser()
config.read(os.path.join(os.path.dirname(__file__), '..', 'notify.cfg'))
jid = config.get('xmpp', 'jid')
password = config.get('xmpp', 'password')
xmpp = XmppListener(jid, password, create_handlers())
xmpp.registerPlugin('xep_0030') # Service Discovery
xmpp.registerPlugin('xep_0004') # Data Forms
xmpp.registerPlugin('xep_0060') # PubSub
xmpp.registerPlugin('xep_0199') # XMPP Ping
if xmpp.connect(('talk.google.com', 5222)):
xmpp.process(threaded=False)
print("Done")
else:
print("Unable to connect.")
def start_event_handler(self, event):
self._log("Start event overlay_id {0}".format(self.overlay_id))
try:
# Get the friends list for the user
self.get_roster()
# Send sign-on presence
self.send_presence(pstatus="ident#" + self.node_id)
# Notification of peer signon
self.add_event_handler("presence_available",
self.presence_event_handler)
# Register IPOP message with the server
register_stanza_plugin(Message, IpopSignal)
self.registerHandler(
Callback("ipop", StanzaPath("message/ipop"), self.message_listener))
except Exception as err:
self._log("XmppTransport:Exception:{0} Event:{1}"
.format(err, event), severity="LOG_ERROR")
def plugin_init(self):
self._hashes = {}
register_stanza_plugin(Presence, VCardTempUpdate)
self.xmpp.add_filter('out', self._update_presence)
self.xmpp.add_event_handler('session_start', self._start)
self.xmpp.add_event_handler('presence_available', self._recv_presence)
self.xmpp.add_event_handler('presence_dnd', self._recv_presence)
self.xmpp.add_event_handler('presence_xa', self._recv_presence)
self.xmpp.add_event_handler('presence_chat', self._recv_presence)
self.xmpp.add_event_handler('presence_away', self._recv_presence)
self.api.register(self._set_hash, 'set_hash', default=True)
self.api.register(self._get_hash, 'get_hash', default=True)
def plugin_init(self):
"""
Start the XEP-0092 plugin.
"""
self.name = self.config.get('name', 'SleekXMPP')
self.version = self.config.get('version', sleekxmpp.__version__)
self.os = self.config.get('os', '')
self.getVersion = self.get_version
self.xmpp.register_handler(
Callback('Software Version',
StanzaPath('iq@type=get/software_version'),
self._handle_version))
register_stanza_plugin(Iq, Version)
self.xmpp.plugin['xep_0030'].add_feature('jabber:iq:version')
def __init__(self, jid, password, other, room, nick, roompass, url):
sleekxmpp.ClientXMPP.__init__(self, jid, password)
self.action_provider = other
self.room = room
self.nick = nick
self.roompass = roompass
self.url = url
# The session_start event will be triggered when
# the bot establishes its connection with the server
# and the XML streams are ready for use. We want to
# listen for this event so that we we can initialize
# our roster.
self.add_event_handler("session_start", self.start, threaded=True)
self.add_event_handler("message", self.message)
register_stanza_plugin(Iq, JibriElement)
def __init__(self, id, password):
ClientXMPP.__init__(self, id, password, sasl_mech='PLAIN')
self.auto_reconnect = True
self.connecton_draining = False
# TODO: usage of this method should be avoided, please use
# the function compose_raw_message instead.
self.MSG = '<message><gcm xmlns="google:mobile:data">{0}</gcm></message>'
self.QUEUE = []
self.ACKS = {}
register_stanza_plugin(Message, GCMMessage)
self.register_handler(
Callback('GCM Message', StanzaPath('message/gcm'),
self.on_gcm_message))
self.add_event_handler('session_start', self.session_start)
self.add_event_handler('disconnected', self.on_disconnected)
def plugin_init(self):
register_stanza_plugin(Iq, LastActivity)
self._last_activities = {}
self.xmpp.register_handler(
Callback('Last Activity', StanzaPath('iq@type=get/last_activity'),
self._handle_get_last_activity))
self.api.register(self._default_get_last_activity,
'get_last_activity',
default=True)
self.api.register(self._default_set_last_activity,
'set_last_activity',
default=True)
self.api.register(self._default_del_last_activity,
'del_last_activity',
default=True)
def register_pep(self, name, stanza):
"""
Setup and configure events and stanza registration for
the given PEP stanza:
- Add disco feature for the PEP content.
- Register disco interest in the PEP content.
- Map events from the PEP content's namespace to the given name.
:param str name: The event name prefix to use for PEP events.
:param stanza: The stanza class for the PEP content.
"""
pubsub_stanza = self.xmpp['xep_0060'].stanza
register_stanza_plugin(pubsub_stanza.EventItem, stanza)
self.add_interest(stanza.namespace)
self.xmpp['xep_0030'].add_feature(stanza.namespace)
self.xmpp['xep_0060'].map_node_event(stanza.namespace, name)
def plugin_init(self):
self.xep = "0012"
self.xmpp.registerHandler(
Callback(
'Last Activity',
MatchXPath('{%s}iq/{%s}query' %
(self.xmpp.default_ns, LastActivity.namespace)),
self.handle_last_activity_query))
register_stanza_plugin(Iq, LastActivity)
self.xmpp.add_event_handler('last_activity_request',
self.handle_last_activity)
if self.xmpp.is_component:
# We are a component, so we track the uptime
self.xmpp.add_event_handler("session_start", self._reset_uptime)
self._start_datetime = datetime.now()
self.xmpp.plugin['xep_0030'].add_feature('jabber:iq:last')
def __init__(self, jid, password, room, nick, roompass, iq_callback):
sleekxmpp.ClientXMPP.__init__(self, jid, password)
self.room = room
self.nick = nick
self.roompass = roompass
self.jid = jid
self.iq_callback = iq_callback
self.add_event_handler("session_start", self.start)
self.add_event_handler("muc::%s::got_online" % self.room,
self.muc_online)
self.register_handler(
Callback('Jibri IQ callback', StanzaPath('iq@type=set/jibri'),
self.on_jibri_iq))
register_stanza_plugin(Iq, JibriElement)
register_stanza_plugin(Iq, JibriStatusElement)
def start_event_handler(self, event):
"""Registers custom event handlers at the start of XMPP session"""
self._sig.sig_log("XMPP Signalling started for overlay: {0}".format(self._overlay_id))
# pylint: disable=broad-except
try:
# Notification of peer signon
self.add_event_handler("presence_available",
self.presence_event_handler)
# Register IPOP message with the server
register_stanza_plugin(Message, IpopSignal)
self.registerHandler(
Callback("ipop", StanzaPath("message/ipop"), self.message_listener))
# Get the friends list for the user
self.get_roster()
# Send sign-on presence
self.send_presence(pstatus="ident#" + self._node_id)
except Exception as err:
self._sig.sig_log("XmppTransport: Exception:{0} Event:{1}"
.format(err, event), "LOG_ERROR")
def plugin_init(self):
if self.sasl_callback is None:
self.sasl_callback = self._default_credentials
if self.security_callback is None:
self.security_callback = self._default_security
creds = self.sasl_callback(set(['username']), set())
if not self.use_mech and not creds['username']:
self.use_mech = 'ANONYMOUS'
self.mech = None
self.mech_list = set()
self.attempted_mechs = set()
register_stanza_plugin(StreamFeatures, stanza.Mechanisms)
self.xmpp.register_stanza(stanza.Success)
self.xmpp.register_stanza(stanza.Failure)
self.xmpp.register_stanza(stanza.Auth)
self.xmpp.register_stanza(stanza.Challenge)
self.xmpp.register_stanza(stanza.Response)
self.xmpp.register_stanza(stanza.Abort)
self.xmpp.register_handler(
Callback('SASL Success',
MatchXPath(stanza.Success.tag_name()),
self._handle_success,
instream=True))
self.xmpp.register_handler(
Callback('SASL Failure',
MatchXPath(stanza.Failure.tag_name()),
self._handle_fail,
instream=True))
self.xmpp.register_handler(
Callback('SASL Challenge',
MatchXPath(stanza.Challenge.tag_name()),
self._handle_challenge))
self.xmpp.register_feature('mechanisms',
self._handle_sasl_auth,
restart=True,
order=self.order)
