def call_msg_handlers(self, t, s, b, subject, stanza): if t == 'error': return if subject: j = JID(s) if not j.userhost() in self.g.keys(): self.log.log( 'ignored subject from %s, stanza was %s' % (escape(s), escape(stanza.toXml())), 3) else: self.log.log( 'got subject from %s, stanza was %s, let\'s call topichandlers' % (escape(s), escape(stanza.toXml())), 1) if j.resource: for i in self.topichandlers: self.call(i, s, subject) else: for i in self.topichandlers: self.call(i, s, b) else: delayed = [ i for i in stanza.children if (i.__class__ == domish.Element) and ( (i.name == 'delay') or ( (i.name == 'x') and (i.uri == 'jabber:x:delay'))) ] if delayed: dl = True else: dl = False for i in self.msghandlers: if (t == 'groupchat') or not i[1]: self.call(i[0], s, b, dl)
def test_subscribe(self): """ Test sending subscription request. """ d = self.protocol.subscribe(JID('pubsub.example.org'), 'test', JID('*****@*****.**')) iq = self.stub.output[-1] self.assertEquals('pubsub.example.org', iq.getAttribute('to')) self.assertEquals('set', iq.getAttribute('type')) self.assertEquals('pubsub', iq.pubsub.name) self.assertEquals(NS_PUBSUB, iq.pubsub.uri) children = list( domish.generateElementsQNamed(iq.pubsub.children, 'subscribe', NS_PUBSUB)) self.assertEquals(1, len(children)) child = children[0] self.assertEquals('test', child['node']) self.assertEquals('*****@*****.**', child['jid']) response = toResponse(iq, 'result') pubsub = response.addElement((NS_PUBSUB, 'pubsub')) subscription = pubsub.addElement('subscription') subscription['node'] = 'test' subscription['jid'] = '*****@*****.**' subscription['subscription'] = 'subscribed' self.stub.send(response) return d
def test_infoNotDeferred(self): """ C{info} should gather disco info from sibling handlers. """ discoItems = [ disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'), disco.DiscoFeature('jabber:iq:version') ] class DiscoResponder(XMPPHandler): implements(disco.IDisco) def getDiscoInfo(self, requestor, target, nodeIdentifier): if not nodeIdentifier: return discoItems else: return [] def cb(result): self.assertEquals(discoItems, result) self.service.parent = [self.service, DiscoResponder()] d = self.service.info(JID('*****@*****.**'), JID('example.com'), '') d.addCallback(cb) return d
def _set_status(self, u, status, cb): # If we've got them on the preferred service, unsubscribe them # from this one. if not self.preferred and (u.service_jid and u.service_jid != self.jid): log.msg("Unsubscribing %s from non-preferred service %s" % (u.jid, self.jid)) self.unsubscribe(JID(u.jid)) self.unsubscribed(JID(u.jid)) return modified = False j = self.jid if (not u.service_jid) or (self.preferred and u.service_jid != j): u.service_jid = j modified = True if u.status != status: u.status = status modified = True global service_mapping service_mapping[u.jid] = u.service_jid log.msg("Service mapping for %s is %s" % (u.jid, u.service_jid)) if modified: if cb: cb() return u.save()
def items(requestor, service, nodeIdentifier, maxItems, items): self.assertEqual(JID('*****@*****.**'), requestor) self.assertEqual(JID('pubsub.example.org'), service) self.assertEqual('test', nodeIdentifier) self.assertIdentical(None, maxItems) self.assertEqual([], items) return defer.succeed([pubsub.Item('current')])
def test_setSubscriptions(self): d = self.protocol.setSubscriptions( JID(u'pubsub.example.com'), u'foo_node', [(JID(u'*****@*****.**'), u'subscribed'), (JID(u'*****@*****.**'), u'none')]) iq = self.stub.output[-1] self.assertEqual(u'pubsub.example.com', iq.getAttribute(u'to')) self.assertEqual(u'set', iq.getAttribute(u'type')) self.failIf(iq.pubsub is None) self.assertEqual(protocols.NS_PUBSUB_OWNER, iq.pubsub.uri) self.failIf(iq.pubsub.subscriptions is None) self.assertEqual(u'foo_node', iq.pubsub.subscriptions.getAttribute(u'node')) subscriptions = iq.pubsub.subscriptions.children self.assertEqual(2, len(subscriptions)) self.assertEqual(u'*****@*****.**', subscriptions[0]['jid']) self.assertEqual(u'subscribed', subscriptions[0]['subscription']) self.assertEqual(u'*****@*****.**', subscriptions[1]['jid']) self.assertEqual(u'none', subscriptions[1]['subscription']) response = toResponse(iq, u'result') response['to'] = \ self.protocol.xmlstream.factory.authenticator.jid.full() self.stub.send(response) def cb(result): self.assertEqual(True, result) d.addCallback(cb) return d
def test_modifyAffiliations(self): d = self.protocol.modifyAffiliations( JID(u'pubsub.example.com'), u'foo_node', [(JID(u'*****@*****.**'), 'none')]) iq = self.stub.output[-1] self.assertEqual(u'pubsub.example.com', iq.getAttribute(u'to')) self.assertEqual(u'set', iq.getAttribute(u'type')) self.failIf(iq.pubsub is None) self.assertEqual(protocols.NS_PUBSUB_OWNER, iq.pubsub.uri) self.failIf(iq.pubsub.affiliations is None) self.assertEqual('foo_node', iq.pubsub.affiliations['node']) affiliation = iq.pubsub.affiliations.affiliation self.assertEqual('*****@*****.**', affiliation['jid']) self.assertEqual('none', affiliation['affiliation']) response = toResponse(iq, u'result') response['to'] = \ self.protocol.xmlstream.factory.authenticator.jid.full() self.stub.send(response) def cb(result): self.assertEqual(result, True) d.addCallback(cb) return d
def makeService(self, options): """ Make services to handle push event notifications. """ # check confguration file is specified and exists if not options["config"]: raise ValueError( 'Configuration file not specified (try to check --help option)' ) cfgFileName = options["config"] if not os.path.isfile(cfgFileName): raise ValueError('Configuration file not found:', cfgFileName) # read configuration file cfg = ConfigParser() cfg.read(cfgFileName) # create Twisted application application = service.Application("gitlab-webhook-xmpp") serviceCollection = service.IServiceCollection(application) # create XMPP client client = XMPPClient(JID(cfg.get('xmpp', 'jid')), cfg.get('xmpp', 'password')) # client.logTraffic = True client.setServiceParent(application) # join to all MUC rooms nickname = cfg.get('xmpp', 'nickname') if cfg.has_option( 'xmpp', 'nickname') else DEFAULT_NICKNAME notifications = cfg.items('notifications') for room, repositoryMasks in notifications: mucHandler = MUCHandler(JID(room), nickname, repositoryMasks.split(',')) mucHandler.setHandlerParent(client) self.mucHandlers.append(mucHandler) templateLoader = None if cfg.has_option('message', 'template'): templateFullName = cfg.get('message', 'template') templatePath, self.templateName = os.path.split(templateFullName) templateLoader = FileSystemLoader(templatePath) else: self.templateName = DEFAULT_TEMPLATE_NAME templateLoader = PackageLoader('xmpp_webhook', 'templates') self.templateEnvironment = Environment(loader=templateLoader, extensions=['jinja2.ext.i18n']) self.templateEnvironment.install_null_translations( ) # use i18n to pluralize only # create web hook handler rootHttpResource = Resource() rootHttpResource.putChild('', WebHookHandler(self)) site = server.Site(rootHttpResource) httpPort = cfg.getint('http', 'port') if cfg.has_option( 'http', 'port') else DEFAULT_HTTP_PORT httpServer = internet.TCPServer(httpPort, site) httpServer.setServiceParent(serviceCollection) return serviceCollection
def test_probeSender(self): """ It should be possible to pass a sender address. """ self.protocol.probe(JID('*****@*****.**'), sender=JID('*****@*****.**')) element = self.output[-1] self.assertEquals("*****@*****.**", element.getAttribute('from'))
def test_getVersion(self): to = 'to' self.CV.getVersion(jid=to) result = self.CV.dispatcher.data[0] self.assertEqual(result.type_, 'get') self.assertEqual(result.to, JID(to)) self.assertEqual(result.from_, JID('jid')) self.assertTrue(isinstance(result, Iq))
def test_getInfo(self): result = self.disco.getInfo(self.to) self.assertTrue(isinstance(result, Deferred)) result = self.disco.dispatcher.data[0] self.assertEqual(result.type_, 'get') self.assertEqual(result.to, JID(self.to)) self.assertEqual(result.from_, JID('myjid')) self.assertTrue(isinstance(result, Iq))
def items(requestor, target, nodeIdentifier): self.assertEqual(JID('*****@*****.**'), requestor) self.assertEqual(JID('example.com'), target) self.assertEqual('', nodeIdentifier) return defer.succeed([ disco.DiscoItem(JID('example.com'), 'test', 'Test node'), ])
def test_jidWhenInitialized(self): """ Make sure that upon login, the JID is updated from the authenticator. """ xs = self.client.factory.buildProtocol(None) self.client.factory.authenticator.jid = JID('[email protected]/test') xs.dispatch(xs, xmlstream.STREAM_AUTHD_EVENT) self.assertEquals(JID('[email protected]/test'), self.client.jid)
def test_init(self): """ Test initialization with a category, type and name. """ item = disco.DiscoItem(JID(u'example.org'), u'test', u'The node') self.assertEqual(JID(u'example.org'), item.entity) self.assertEqual(u'test', item.nodeIdentifier) self.assertEqual(u'The node', item.name)
def test_toElementRecipient(self): """ A request without recipient, has no 'to' attribute. """ self.request = generic.Request(recipient=JID('*****@*****.**')) self.assertEquals(JID('*****@*****.**'), self.request.recipient) element = self.request.toElement() self.assertEquals(u'*****@*****.**', element.getAttribute('to'))
def test_toElementSender(self): """ A request with sender, has a 'from' attribute. """ self.request = generic.Request(sender=JID('*****@*****.**')) self.assertEquals(JID('*****@*****.**'), self.request.sender) element = self.request.toElement() self.assertEquals(u'*****@*****.**', element.getAttribute('from'))
def test_bosh_authentication(self): jid = JID('admin@localhost') jid.resource = str(random.randint(0, 1000)) client = BOSHClient(jid, 'admin', 'http://localhost:5280/http-bind/') self.assertTrue(client.startSession()) rid = client.rid sid = client.sid self.assertTrue(rid is not None) self.assertTrue(sid is not None)
def __call__(self, user, prot, args): # For bare jids, we'll send what was requested, # but also look up the user and send it to any active resources self.ping(prot, user.jid, args) j = JID(args) if j.user and not j.resource: for rsrc in scheduling.resources(args): j.resource=rsrc self.ping(prot, user.jid, j.full())
def sendMessage(self, recipient: JID, sender: JID, text: str, messageType: str = "chat"): el = Element((None, "message")) el.attributes["to"] = recipient.full() el.attributes["from"] = sender.full() el.attributes["type"] = messageType body = el.addElement("body") body.addContent(escape(text)) self.send(el)
def test_fromElement(self): xml = """ <message type='chat' from='*****@*****.**' to='*****@*****.**'/> """ stanza = generic.Stanza.fromElement(generic.parseXml(xml)) self.assertEqual('chat', stanza.stanzaType) self.assertEqual(JID('*****@*****.**'), stanza.sender) self.assertEqual(JID('*****@*****.**'), stanza.recipient)
def get_user(self, msg, session): jid = JID(msg['from']) try: rv = models.User.by_jid(jid.userhost(), session) except: print "Getting user without the jid in the DB (%s)" % jid.full() rv = models.User.update_status(jid.userhost(), None, session) self.subscribe(jid) return rv
def getConfiguration(requestor, service, nodeIdentifier): self.assertEqual(JID('*****@*****.**'), requestor) self.assertEqual(JID('pubsub.example.org'), service) self.assertEqual('test', nodeIdentifier) return defer.succeed({ 'pubsub#deliver_payloads': '0', 'pubsub#persist_items': '1' })
def get_user(self, msg, session): jid = JID(msg['from']) try: user = models.User.by_jid(jid.userhost(), session) except: log.msg("Getting user without the jid in the DB (%s)" % jid.full()) user = models.User.update_status(jid.userhost(), None, session) self.subscribe(jid) return user;
def get_user(self, msg, session): jid = JID(msg["from"]) try: rv = models.User.by_jid(jid.userhost(), session) except: print "Getting user without the jid in the DB (%s)" % jid.full() rv = models.User.update_status(jid.userhost(), None, session) self.subscribe(jid) return rv
def setConfiguration(requestor, service, nodeIdentifier, options): self.assertEqual(JID('*****@*****.**'), requestor) self.assertEqual(JID('pubsub.example.org'), service) self.assertEqual('test', nodeIdentifier) self.assertEqual( { 'pubsub#deliver_payloads': False, 'pubsub#persist_items': True }, options) return defer.succeed(None)
def _onPresenceUnavailable(self, presence): entity = JID(presence["from"]) statuses = self._getStatuses(presence) realjid = None if presence.x and presence.x.defaultUri == 'http://jabber.org/protocol/muc#user' and presence.x.item.hasAttribute('jid'): realjid = JID(presence.x.item["jid"]) self.unavailableReceived(entity, statuses, realjid)
def _cb_subscribe_default_users (self, r, ) : _dl = list() for i in constant.LDAP_USERS : _jid = JID("%s@%s" % (i, self.parent.jid.host, ), ) if _jid.userhost() == self.parent.jid.userhost() or _jid.userhost() in r : continue _dl.append(defer.maybeDeferred(self.subscribe, _jid, ), ) return defer.DeferredList(_dl, )
def info(requestor, target, nodeIdentifier): self.assertEqual(JID('*****@*****.**'), requestor) self.assertEqual(JID('example.com'), target) self.assertEqual('', nodeIdentifier) return defer.succeed([ disco.DiscoIdentity('dummy', 'generic', 'Generic Dummy Entity'), disco.DiscoFeature('jabber:iq:version') ])
def __init__(self, context, request): super(MUCView, self).__init__(context, request) room = request.get('room', None) self.invitee = request.get('invitee', None) if room is not None: self.room_jid = JID(room) else: room = random.randint(0, 4294967295) registry = getUtility(IRegistry) self.room_jid = JID(registry['jarn.xmpp.conferenceJID']) self.room_jid.user = room
def call_msg_handlers(self, t, s, b, subject, stanza): if subject: j = JID(s) if not j.userhost() in self.g.keys(): self.log.log('ignored subject from %s, stanza was %s' % (escape(s), escape(stanza.toXml())), 3) else: self.log.log('got subject from %s, stanza was %s, let\'s call topichandlers' % (escape(s), escape(stanza.toXml())), 1) for i in self.topichandlers: self.call(i, s, subject) else: for i in self.msghandlers: if (t == 'groupchat') or not i[1]: self.call(i[0], s, b)
def test_jidDeprecationSet(self): """ Setting the jid attribute works as entity and warns deprecation. """ item = xmppim.RosterItem(JID('*****@*****.**')) self.assertWarns( DeprecationWarning, "wokkel.xmppim.RosterItem.jid was deprecated " "in Wokkel 0.7.1; " "please use RosterItem.entity instead.", xmppim.__file__, setattr, item, 'jid', JID('*****@*****.**')) self.assertEqual(JID('*****@*****.**'), item.entity)
def __getVersion(self, sender: JID, recipient: JID, identifier: str): iq = Element((None, "iq")) iq.attributes["type"] = "result" iq.attributes["from"] = recipient.full() iq.attributes["to"] = sender.full() if identifier: iq.attributes["id"] = identifier query = iq.addElement("query") query.attributes["xmlns"] = "jabber:iq:version" query.addElement("name", content="h2x transport") query.addElement("version", content=0) self.h2x.send(iq)
def get_forward_jids(self, stanza): entity_from = JID(stanza["from"]) entity_to = JID(stanza["to"]) if entity_from.userhost() == self.jid_proxy_to: new_jid_to = self.untranslate_jid(entity_to.full()) new_jid_from = self.jid_act_as else: new_jid_to = self.jid_proxy_to new_jid_from = self.translate_jid(entity_from.full()) return new_jid_to, new_jid_from
def setUp(self): self.stub = XmlStreamStub() self.protocol = muc.MUCClient() self.protocol.xmlstream = self.stub.xmlstream self.protocol.connectionInitialized() self.test_room = 'test' self.test_srv = 'conference.example.org' self.test_nick = 'Nick' self.room_jid = JID(self.test_room+'@'+self.test_srv+'/'+self.test_nick) self.user_jid = JID('[email protected]/Testing')
def doProbe(self, account): if isinstance(account, str): account = JID(account) d = Deferred() from twisted.internet import reactor reactor.callLater(self.RECIEVE_FOR_SECS, self.sendResults, account.userhost()) self.statusJobs[account.userhost()] = self.StatusJobState(d) self.probe(account) return d
def test_getDiscoItems(self): """ Items are not supported by this handler, so an empty list is expected. """ def cb(items): self.assertEquals(0, len(items)) d = defer.maybeDeferred(self.protocol.getDiscoItems, JID('[email protected]/home'), JID('pubsub.example.org'), '') d.addCallback(cb) return d
def testSetUp(self): client = getUtility(IAdminClient) if client._state == 'disconnected': zr = getUtility(IZopeReactor) zr.reactor.callFromThread(client.connect) wait_for_client_state(client, 'authenticated') _setupXMPPEnvironment( client, member_jids=[JID('test_user_1_@localhost')], member_passwords={JID('test_user_1_@localhost'): 'secret'}) wait_on_client_deferreds(client)
def failure(msg): _from = JID(msg['from']) bare_from = _from.userhost() user = (yield objs.User.find_one({'jid': bare_from})) # only active jid if not user: return if msg.error: if msg.error.getAttribute('code') == '500' and msg.error.__getattr__('resource-constraint'): print 'User %s automatically set off because his offline storage is full.' % (user['name'],) objs.User.mupdate({'name': user['name']}, {'$set': {'off': True}}) return print 'Unknown delivery failure'
def __init__(self, context, request): super(BrowserView, self).__init__(context, request) self.jid = request.get('jid') self.user_id = JID(self.jid).user self.bare_jid = JID(self.jid).userhost() self.pm = getToolByName(context, 'portal_membership') info = self.pm.getMemberInfo(self.user_id) if info: self._fullname = info.get('fullname') or self.user_id self._portrait_url = self.pm.getPersonalPortrait(self.user_id).absolute_url() else: self._fullname = '' self._portrait_url = ''
def setUp(self): self.stub = XmlStreamStub() self.protocol = muc.MUCClient() self.protocol.xmlstream = self.stub.xmlstream self.protocol.connectionInitialized() self.test_room = 'test' self.test_srv = 'conference.example.org' self.test_nick = 'Nick' self.room_jid = JID(self.test_room + '@' + self.test_srv + '/' + self.test_nick) self.user_jid = JID('[email protected]/Testing')
def __getDiscoInfo(self, sender: JID, identifier: str, node: str): iq = Element((None, "iq")) iq.attributes["type"] = "result" iq.attributes["from"] = self.h2x.config.JID iq.attributes["to"] = sender.full() if identifier: iq.attributes["id"] = identifier query = iq.addElement("query") query.attributes["xmlns"] = "http://jabber.org/protocol/disco#info" # Node not set -> send component identity if node == None: identity = query.addElement("identity") identity.attributes["name"] = "Google Hangouts transport" identity.attributes["category"] = "gateway" identity.attributes["type"] = "XMPP" query.addElement("feature").attributes["var"] = "jabber:iq:gateway" query.addElement("feature").attributes["var"] = "jabber:iq:register" query.addElement("feature").attributes["var"] = "jabber:iq:version" # Generic features for both node and component query.addElement("feature").attributes["var"] = "http://jabber.org/protocol/commands" query.addElement("feature").attributes["var"] = "http://jabber.org/protocol/disco#items" query.addElement("feature").attributes["var"] = "http://jabber.org/protocol/disco#info" self.h2x.send(iq)
def componentIq(self, element: Element, sender: JID, identifier: str, iqType: str): for query in element.elements(): xmlns = query.uri node = query.getAttribute("node") if xmlns == "http://jabber.org/protocol/disco#info" and iqType == "get": self.__getDiscoInfo(sender, identifier, node) return if xmlns == "http://jabber.org/protocol/disco#items" and iqType == "get": self.__getDiscoItems(sender, identifier, node) return if xmlns == "jabber:iq:register" and iqType == "get": self.__getRegister(sender, identifier) return if xmlns == "jabber:iq:register" and iqType == "set": self.__setRegister(element, sender, identifier) return if xmlns == "http://jabber.org/protocol/commands" and query.name == "command" and iqType == "set": self.__command(query, sender, identifier, node) return self.__sendIqError( recipient=sender.full(), sender=self.h2x.config.JID, identification=identifier, errorType="cancel", condition="feature-not-implemented", )
def JID2Hang(self, jid: JID): if not self.h2x.isHangUser(jid): raise Exception(jid.full() + " is not valid user JID for the transport") userIdParts = jid.user.split(".") userChatId = userIdParts[0] userGaiaId = userIdParts[1] return hangups.user.UserID(userChatId, userGaiaId)
def idiotic(msg): """Suck some cocks.""" # return str(request.body) message_from = JID(msg['from']) message_bare_from = message_from.userhost() message_user = (yield objs.User.find_one({'jids': message_bare_from})) if not message_user: message_user = (yield objs.User.find_one({'jid': message_bare_from})) # if message.body is None: # return '' if msg.bnw_s2s: bnw_s2s = msg.bnw_s2s print 'GOT AN s2s MESSAGE', bnw_s2s try: s2s_type = bnw_s2s['type'] except KeyError: s2s_type = None handler = handlers.s2s_handlers.get(s2s_type) if not handler: print 'NO HANDLER FOR THIS TYPE (%s)' % (s2s_type) else: _ = yield handler(msg, bnw_s2s) defer.returnValue(None) message_body = unicode(msg.body) if message_body is None: defer.returnValue('') message_body = message_body.strip() if type(message_body) != unicode: message_body = unicode(message_body, 'utf-8', 'replace') xmsg = XmppMessage( message_body, JID(msg['to']), message_from, message_user) if message_user: message_user.activity() try: iparser = 'redeye' if message_user: if 'interface' in message_user: iparser = message_user['interface'] result = yield handlers.parsers[iparser].handle(xmsg) except CommandParserException, exc: result = yield exc.args[0]
def onIq(self, element: Element): source = JID(element.getAttribute("from")) recipient = JID(element.getAttribute("to")) identification = element.getAttribute("id") iqType = element.getAttribute("type") print("IqReceived " + source.full() + " -> " + recipient.full() + ": " + iqType) # Process component iq if recipient.full() == self.h2x.config.JID: self.componentIq(element, source, identification, iqType) return # Process user iq if self.h2x.isHangUser(recipient): self.userIq(element, source, recipient, identification, iqType) return # TODO: Can we send something like wrong request? self.__sendIqError( recipient=source.full(), sender=recipient.full(), identification=identification, errorType="cancel", condition="service-unavailable", )
def unavailable(prot, presence): global chatrooms fromjid = JID(presence["from"]) tojid = JID(presence["to"]) log.msg("Unavailable from: %s to %s (my jid is %s)" % (fromjid, tojid, prot.jid)) room_name = tojid.user log.msg("Room name: %s, user nick: %s, host: %s" % (room_name, tojid.resource, tojid.host)) assert tojid.host == prot.jid prot.presenceBroadcast(room_name, tojid.resource, "unavailable") room = chatrooms[room_name] del room[fromjid.full()]
def __setRegister(self, data: Element, sender: JID, identifier: str): try: user = sender.userhost() token = data.firstChildElement().firstChildElement().firstChildElement().firstChildElement().__str__() except Exception as e: # Fail registration print("Register reponse processing failed: " + e.__str__()) # FIXME: Send negative response here !!! self.__sendIqResult(sender.full(), self.h2x.config.JID, identifier, "jabber:iq:register") return self.h2x.registerUser(user, token) # Send registration done self.__sendIqResult(sender.full(), self.h2x.config.JID, identifier, "jabber:iq:register") # Request subscription self.h2x.sendPresence(sender, "subscribe")
def iq(msg): """Process incoming IQ stanza.""" try: iq_from = JID(msg['from']) iq_bare_from = iq_from.userhost() iq_user = (yield objs.User.find_one({'jids': iq_bare_from})) if not iq_user: iq_user = (yield objs.User.find_one({'jid': iq_bare_from})) for handler in iq_handlers.handlers: if (yield handler(msg, iq_user)): defer.returnValue(True) defer.returnValue(False) except Exception: raise print ("Error while processing iq:\n\n" + traceback.format_exc() + "\n" + "Command which caused this exception: " + iq)
def call_msg_handlers(self, t, s, b, subject, stanza): if t == 'error': return if subject: j = JID(s) if not j.userhost() in self.g.keys(): self.log.log('ignored subject from %s, stanza was %s' % (escape(s), escape(stanza.toXml())), 3) else: self.log.log('got subject from %s, stanza was %s, let\'s call topichandlers' % (escape(s), escape(stanza.toXml())), 1) if j.resource: for i in self.topichandlers: self.call(i, s, subject) else: for i in self.topichandlers: self.call(i, s, b) else: delayed = [i for i in stanza.children if (i.__class__==domish.Element) and ((i.name=='delay') or ((i.name=='x') and (i.uri=='jabber:x:delay')))] if delayed: dl = True else: dl = False for i in self.msghandlers: if (t == 'groupchat') or not i[1]: self.call(i[0], s, b, dl)
def sendPresence(self, destination: JID, presenceType: str, status: str = None, show: str = None, priority: int = None, source: JID = None, nick: str = None): if not source: source = JID(self.config.JID) presence = Element((None, 'presence')) presence.attributes['to'] = destination.userhost() presence.attributes['from'] = source.userhost() presence.attributes['type'] = presenceType if status: presence.addElement('status').addContent(status) if show: presence.addElement('show').addContent(show) if priority: presence.addElement('priority').addContent(priority) if nick: nickElement = presence.addElement('nick', content=nick) nickElement.attributes["xmlns"] = "http://jabber.org/protocol/nick" print("PresenceSend: " + source.full() + " -> " + destination.full() + " : " + presenceType) self.send(presence)
def call_msg_handlers(self, t, s, b, subject, stanza): if t == "error": return if subject: j = JID(s) if not j.userhost() in self.g.keys(): self.log.log("ignored subject from %s, stanza was %s" % (escape(s), escape(stanza.toXml())), 3) else: self.log.log( "got subject from %s, stanza was %s, let's call topichandlers" % (escape(s), escape(stanza.toXml())), 1, ) for i in self.topichandlers: self.call(i, s, subject) else: for i in self.msghandlers: if (t == "groupchat") or not i[1]: self.call(i[0], s, b)
def __getVCard(self, sender: JID, recipient: JID, identifier): iq = Element((None, "iq")) iq.attributes["type"] = "result" iq.attributes["from"] = recipient.full() iq.attributes["to"] = sender.full() if identifier: iq.attributes["id"] = identifier vcard = iq.addElement("vCard") vcard.attributes["xmlns"] = "vcard-temp" userInfo = self.h2x.getClient(sender).getUser(recipient) # TODO: Get more user info vcard.addElement("FN", content=userInfo.full_name) vcard.addElement("NICKNAME", content=userInfo.full_name) emails = vcard.addElement("EMAIL") for email in userInfo.emails: emails.addElement("USERID", content=email) self.h2x.send(iq)
def onPresence(self, element: Element): sender = JID(element.getAttribute("from")) recipient = JID(element.getAttribute("to")) presenceType = element.getAttribute("type") if not presenceType: presenceType = "available" print("PresenceReceived: " + sender.full() + " -> " + recipient.full() + " : " + presenceType) # Create client instance on available from XMPP client if self.getClient(sender) is None: if presenceType == "available": try: self.addClient(ClientWrapper(self, sender)) except UserNotRegistered as e: print(e) self.sendPresenceError(recipient=sender, sender=recipient, errorType="auth", condition="registration-required") return else: print("Operation on client which has not yet send available presence !!! (responding as if we are not available)") self.sendPresence(sender, "unavailable") return # Service component presence if recipient == JID(self.config.JID): self.getClient(sender).processComponentPresence(sender, presenceType, recipient) # Subscription request elif presenceType == "subscribe": self.getClient(sender).processSubscription(recipient) # Presence to Hangouts user elif self.isHangUser(recipient): self.getClient(sender).processPresence(recipient, presenceType) # Unimplemented feature else: raise NotImplemented(element)
def install(self, _parentService): """interface requirement""" self.parentService = _parentService user = self.SERVICECONFIG.JABBER_USERNAME server = self.SERVICECONFIG.JABBER_SERVER resource = self.SERVICECONFIG.JABBER_RESOURCE self.jid = JID("%(user)s@%(server)s/%(resource)s" % locals()) self.broadcastTask = LoopingCall(self.broadcastPresence) self.sendQueue = [] self.authenticated = False #load all jabber responders, after configuration import droned.responders droned.responders.loadAll()
def present(prot, presence): global chatrooms fromjid = JID(presence["from"]) tojid = JID(presence["to"]) log.msg("Available from: %s to %s (my jid is %s)" % (fromjid, tojid, prot.jid)) room_name = tojid.user log.msg("Room name: %s, user nick: %s, host: %s" % (room_name, tojid.resource, tojid.host)) assert tojid.host == prot.jid if room_name not in chatrooms: chatrooms[room_name] = ChatRoom(room_name) chatrooms[room_name].add(ChatUser(tojid.resource, fromjid.full())) prot.presenceBroadcast(room_name, tojid.resource) # Send The current list to the new user for u in chatrooms[room_name].users: prot.sendOnePresence(room_name, u.nick, "participant", fromjid, None)
def process_stats(item): """ Process result of user-stats command Extract IP address and related info and returns it as dict """ x = xpath.queryForNodes("//x/field[@var='ipaddresses']",item) if not x: raise ValueError, "Wrong response from stats-request" frm = Form.fromElement(x[0]) values = frm.getValues() jid = JID(values['accountjid']) ipport = values['ipaddresses'] ip, port = ipport.split(':') userstats = dict() userstats['username'] = jid.userhost() userstats['fulljid'] = jid.full() #full jid which causes current change, i.e. which is connestion actualy used userstats['ip'] = ip return userstats
def __getRegister(self, sender: JID, identifier: str): iq = Element((None, "iq")) iq.attributes["type"] = "result" iq.attributes["from"] = self.h2x.config.JID iq.attributes["to"] = sender.full() if identifier: iq.attributes["id"] = identifier query = iq.addElement("query") query.attributes["xmlns"] = "jabber:iq:register" # Create registration form form = Form(query) form.addTitle("Hangouts registration form") form.addTextBox("token", "Replace link by token", hangups.auth.OAUTH2_LOGIN_URL, required=True) self.h2x.send(iq)