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)