def resetHistory(self, room=None, frm=None):
     if room != None:
         # room needs to be a returned room hash from the backend
         if self.checkAdmin(room, jid.internJID(frm).userhost()):
             self.parent._clean_up_history(True, room['name'])
     elif jid.internJID(frm).userhost() in self.sadmins:
         self.HISTORY = {}

    def _onDiscoItems(self, iq):
        requestor = jid.internJID(iq["from"])
        target = jid.internJID(iq["to"])
        nodeIdentifier = iq.query.getAttribute("node", '')

        def toResponse(results):
            items = []
            for i in results:
                items.extend(i[1])

            response = domish.Element((NS_ITEMS, 'query'))

            for item in items:
                response.addChild(item)

            return response

        dl = []
        for handler in self.parent:
            if IDisco.providedBy(handler):
                dl.append(handler.getDiscoItems(requestor, target,
                                                nodeIdentifier))

        d = defer.DeferredList(dl, fireOnOneErrback=1, consumeErrors=1)
        d.addCallbacks(toResponse, self._error)
        return d

 def cb(subs):
     actual = [a.toElement().toXml() for a in subs]
     expected = [
         ps.Subscription(
             nodeIdentifier='node1',
             subscriber=jid.internJID('[email protected]').userhostJID(),
             state='subscribed'),
         ps.Subscription(
             nodeIdentifier='node2',
             subscriber=jid.internJID('[email protected]').userhostJID(),
             state='subscribed'),
         ps.Subscription(
             nodeIdentifier='node5',
             subscriber=jid.internJID('[email protected]').userhostJID(),
             state='unconfigured'),
         ps.Subscription(
             nodeIdentifier='node6',
             subscriber=jid.internJID('[email protected]').userhostJID(),
             state='subscribed',
             subscriptionIdentifier='123-abc'),
         ps.Subscription(
             nodeIdentifier='node6',
             subscriber=jid.internJID('[email protected]').userhostJID(),
             state='subscribed',
             subscriptionIdentifier='004-yyy'),
         ]
     self.assertEquals(len(actual), 5)
     for ex in expected:
         self.assertIn(ex.toElement().toXml(), actual)
     sendMock.assert_called_once_with(xs)

    def _onDiscoInfo(self, iq):
        """
        Called for incoming disco info requests.

        @param iq: The request iq element.
        @type iq: L{Element<twisted.words.xish.domish.Element>}
        """
        requestor = jid.internJID(iq["from"])
        target = jid.internJID(iq["to"])
        nodeIdentifier = iq.query.getAttribute("node", '')

        def toResponse(info):
            if nodeIdentifier and not info:
                raise error.StanzaError('item-not-found')
            else:
                response = DiscoInfo()
                response.nodeIdentifier = nodeIdentifier

                for item in info:
                    response.append(item)

            return response.toElement()

        d = self.info(requestor, target, nodeIdentifier)
        d.addCallback(toResponse)
        return d

    def _onDiscoInfo(self, iq):
        requestor = jid.internJID(iq["from"])
        target = jid.internJID(iq["to"])
        nodeIdentifier = iq.query.getAttribute("node", '')

        def toResponse(results):
            info = []
            for i in results:
                info.extend(i[1])

            if nodeIdentifier and not info:
                raise error.StanzaError('item-not-found')
            else:
                response = domish.Element((NS_INFO, 'query'))

                for item in info:
                    response.addChild(item)

            return response

        dl = []
        for handler in self.parent:
            if IDisco.providedBy(handler):
                dl.append(handler.getDiscoInfo(requestor, target,
                                               nodeIdentifier))

        d = defer.DeferredList(dl, fireOnOneErrback=1, consumeErrors=1)
        d.addCallbacks(toResponse, self._error)
        return d

    def dispatch(self, xs, stanza):
        """
        Send a stanza to the router, checking some stuff first.
        """

        log.debug("stanza from %s: %s" % (xs.otherEntity.full(), stanza.toXml()))
        util.resetNamespace(stanza, xs.namespace)
        stanzaFrom = stanza.getAttribute('from')
        stanzaTo = stanza.getAttribute('to')

        if not stanza.bind and not stanzaFrom or not stanzaTo:
            xs.sendStreamError(error.StreamError('improper-addressing'))
        else:
            try:
                sender = jid.internJID(stanzaFrom)
                jid.internJID(stanzaTo)
            except jid.InvalidFormat:
                log.debug("dropping stanza with malformed JID")

            log.debug("sender = %s, otherEntity = %s" % (sender.full(), xs.otherEntity.full()))

            try:
                unused, host = util.jid_component(sender.host)
                if host in self.keyring.hostlist():
                    self.router.send(stanza)
                else:
                    raise Exception()
            except:
                xs.sendStreamError(error.StreamError('invalid-from'))

 def test_identity(self):
     """
     Test that two interned JIDs yield the same object.
     """
     j1 = jid.internJID("[email protected]")
     j2 = jid.internJID("[email protected]")
     self.assertIdentical(j1, j2)

	def incomingIq(self, el):
		itype = el.getAttribute("type")
		fro = el.getAttribute("from")
		froj = internJID(fro)
		to = el.getAttribute("to")
		toj = internJID(to)
		ID = el.getAttribute("id")

    def dispatch(self, xs, stanza):
        """
        Send a stanza to the router, checking some stuff first.
        """

        log.debug("stanza from %s: %s" % (xs.otherEntity.full(), stanza.toXml()))
        util.resetNamespace(stanza, xs.namespace)
        stanzaFrom = stanza.getAttribute('from')
        stanzaTo = stanza.getAttribute('to')

        if not stanzaFrom or not stanzaTo:
            xs.sendStreamError(error.StreamError('improper-addressing'))
        else:
            try:
                sender = jid.internJID(stanzaFrom)
                jid.internJID(stanzaTo)
            except jid.InvalidFormat:
                log.debug("dropping stanza with malformed JID")

            log.debug("sender = %s, otherEntity = %s" % (sender.full(), xs.otherEntity.full()))
            if sender.host != xs.otherEntity.host and sender.host != self.defaultDomain:
                xs.sendStreamError(error.StreamError('invalid-from'))
            else:
                # replace to with destination
                destination = stanza.getAttribute('destination')
                if destination:
                    stanza['to'] = destination
                    del stanza['destination']
                self.router.send(stanza)

    def createRoom(self, room, frm, nick, status = None, show = None, legacy = True, host=None):
        """
        Create and join the room
        """

        def created(rname):
            self.parent.HISTORY[room] = []
            return self.joinRoom(room, frm, nick,
                                 status = status,
                                 show   = show,
                                 legacy = legacy,
                                 host   = host,
                                 do_check = False)

        def create_room(doCreate, error_code=NotAllowed):
            if not doCreate:
                raise error_code

            d = self.parent.storage.createRoom(room, jid.internJID(frm).userhost(), legacy=legacy, host=host)
            d.addCallback(created)
            return d

        if self.create_rooms == 1 or jid.internJID(frm).userhost() in self.sadmins:
            if self.plugins and self.plugins.has_key('create-room'):
                d = self.plugins['create-room'].create(room, jid.internJID(frm).userhost(), legacy=legacy, host=host)
                d.addCallback(create_room, error_code = NotMember)
            else:
                d = create_room(True)

            return d
        else:
            raise NotAllowed

        def set_kick(r, user):
            if self.checkAdmin(r, admin):
                kuser = None
                if self.checkOwner(r, user):
                    raise NotAllowed
                user_check = jid.internJID(user).userhost().lower()
                for u in r['roster'].values():
                    if jid.internJID(u['jid']).userhost().lower() == user_check \
                           or u['nick'] == user:
                        kuser = u['jid']
                        knick = u['nick']
                        if self.checkSelf(user, admin):
                            raise NotAllowed

                        if self.checkAdmin(r, user):
                            raise NotAllowed
                        r['roster'][u['jid'].lower()]['role'] = 'none'
                        r['roster'][u['jid'].lower()]['affiliation'] = 'none'
                        break
                if not kuser:
                    raise RoomNotFound
                d = self.parent.storage.partRoom(room, kuser, knick, host=host)
                d.addCallback(ret_kick, room, r['roster'])
                d.addErrback(lambda x: self.error(NotAllowed, x))
                return d
            else:
                raise NotAllowed

 def _check_sadmin(self, room, user):
     juser = jid.internJID(user).userhost().lower()
     members = self.sadmins
     for m in members:
         if jid.internJID(m).userhost().lower() == juser:
             return True
     return False

 def valid(xs):
     reply('valid')
     if not self.xmlstream.thisEntity:
         self.xmlstream.thisEntity = jid.internJID(receivingServer)
     self.xmlstream.otherEntity = jid.internJID(originatingServer)
     self.xmlstream.dispatch(self.xmlstream,
                             xmlstream.STREAM_AUTHD_EVENT)

 def incomingRegisterIq(self, incoming):
     # Check what type the Iq is..
     itype = incoming.getAttribute("type")
     LogEvent(INFO)
     if itype == "get":
         if config.authRegister:
             # Check to see if they're registered
             source = internJID(incoming.getAttribute("from")).userhost()
             result = self.pytrans.xdb.getRegistration(source)
             if result:
                 self.sendRegistrationFields(incoming)
             else:
                 # Must first submit local credentials
                 self.sendLocalRegistrationFields(incoming)
         else:
             # Send real registration form
             self.sendRegistrationFields(incoming)
     elif itype == "set":
         if config.authRegister:
             # Check to see if they're registered by local credentials
             source = internJID(incoming.getAttribute("from")).userhost()
             result = self.pytrans.xdb.getRegistration(source)
             username = ""
             password = ""
             if result:
                 username, password = result
             if username == "local" and password == "local":
                 # Update real credentials
                 self.updateRegistration(incoming)
             else:
                 # Must first validate local credentials
                 self.validateLocalRegistration(incoming)
         else:
             # Update real credentials
             self.updateRegistration(incoming)

    def handle_action(self, action):
        self.log.debug('XMPP ACTION : {0!r}'.format(action))

        if action.action_type != 'message':
            return

        body = str(action.meta.get('body'))
        if not body:
            return

        if not action.destination_rooms:
            return

        for room in action.destination_rooms:
            if action.scope == 'public':
                room_jid = jid.internJID(room)
                message = muc.GroupChat(recipient=room_jid, body=body)
                self.client.send(message.toElement())

            if action.scope == 'private':
                if room is not None:
                    msg = xmppim.Message(recipient=jid.internJID(room),
                                         sender=self.bot_jid,
                                         body=body)
                    self.client.send(msg.toElement())

    def postOptions(self):
        if not self['jid']:
            raise usage.UsageError("Missing client JID")
        else:
            try:
                self['jid'] = jid.internJID(self['jid'])
            except jid.invalidFormat:
                raise usage.UsageError("Invalid client JID")

        if self['secret'] is None:
            raise usage.UsageError("Missing client secret")

        if not self['service']:
            raise usage.UsageError("Missing publish-subscribe service JID")
        else:
            try:
                self['service'] = jid.internJID(self['service'])
            except jid.invalidFormat:
                raise usage.UsageError("Invalid publish-subscribe service JID")

        try:
            self['twitter-oauth-consumer'] = OAuthConsumer(
                key=self['twitter-oauth-consumer-key'],
                secret=self['twitter-oauth-consumer-secret'])
            self['twitter-oauth-token'] = OAuthToken(
                key=self['twitter-oauth-token-key'],
                secret=self['twitter-oauth-token-secret'])
        except KeyError:
            self['twitter-oauth-consumer'] = None
            self['twitter-oauth-token'] = None
            if not self['twitter-user'] or not self['twitter-password']:
                raise usage.UsageError("Missing twitter credentials")

def createPurger(domain, service, node, username, password, debug=False):
    
    factory = client.DeferredClientFactory(jid.internJID(username), password)
    factory.streamManager.logTraffic = debug

    purger = Purger(jid.internJID(service), node)
    purger.setHandlerParent(factory.streamManager)

    yield client.clientCreator(factory)

    def onActivateStream(self, iq):

        try:
            fromJID = jid.internJID(iq["from"])
            
            # check the sender is authorized
            if self.allowed_domains and fromJID.host not in self.allowed_domains:
                raise UnauthorizedException
            
            activateJID = jid.internJID(unicode(iq.query.activate)).full()
            sid = hashSID(
                iq.query["sid"].encode("utf-8"), fromJID.full().encode("utf-8"), activateJID.encode("utf-8")
            )
            log.msg("Activation requested for: ", sid)

            # Get list of objects for this sid
            olist = self.pendingConns[sid]

            # Remove sid from pending
            del self.pendingConns[sid]

            # Ensure there are the correct # of participants
            if len(olist) != 2:
                log.msg("Activation for %s failed: insufficient participants", sid)
                raise UnauthorizedException
                   
            # Send iq result
            iq.swapAttributeValues("to", "from")
            iq["type"] = "result"
            iq.query.children = []
            self.send(iq)
            
            # Remove sid from pending and mark as active
            assert sid not in self.activeConns
            self.activeConns[sid] = None
        
            # Complete connection
            log.msg("Activating ", sid)
            olist[0].peersock = olist[1]
            olist[1].peersock = olist[0]
            olist[0].transport.registerProducer(olist[1], 0)
            olist[1].transport.registerProducer(olist[0], 0)
        except UnauthorizedException, e:
            # Send an error
            iq.swapAttributeValues("to", "from")
            iq["type"] = "error"
            iq.query.children = []
            e = iq.addElement("error")
            e["code"] = "405"
            e["type"] = "cancel"
            c = e.addElement("not-allowed")
            c["xmlns"] = "urn:ietf:params:xml:ns:xmpp-stanzas"
            self.send(iq)
                
            # Close all connected
            for c in olist:
                c.transport.loseConnection()

 def set_member(r, user):
     mjid = None
     if r == None:
         raise RoomNotFound
     
     if self.checkAdmin(r, admin):
         juser = jid.internJID(user)
         
         # TODO - clean this up
         roster = r['roster']
         set_role = False
         
         for m in roster.values():
             idx = m['jid'].lower()
             rjid = jid.internJID(m['jid'])
             if juser.resource:
                 mjids = rjid.full().lower()
             else:
                 mjids = rjid.userhost().lower()
                 
             if mjids == user.lower() or m['nick'].lower() == user.lower():
                 if self.checkSelf(m['jid'], admin):
                     raise NotAllowed
                 
                 # if self.checkAdmin(r, m['jid']):
                 #    raise NotAllowed
                 mjid = m['jid']
                 if roster[idx]['role'] == 'none' or \
                    roster[idx]['role'] == 'visitor' or \
                    roster[idx]['role'] == 'player':
                     roster[idx]['role'] = 'participant'
                     set_role = True
                 roster[idx]['affiliation'] = 'member'
                 break
         
         dlist = []
         if user:
             # This sets it in storage
             dm = self.parent.storage.setMember(room, user, host = host)
             
             dlist.append(dm)
             
         if mjid and set_role:
             # This sets it in the roster
             dr = self.parent.storage.setRole(room, mjid, 'participant', host=host)
             
             dlist.append(dr)
             
             
         d = defer.DeferredList(dlist)
         d.addErrback(lambda x: self.error(NotAllowed, x))
         d.addCallback(lambda _: roster)
         return d
         
     else:
         raise NotAllowed

def sendPresence(pytrans, to, fro, show=None, status=None, priority=None, ptype=None, avatarHash=None, nickname=None, payload=[], url=None):
    if ptype in ["subscribe", "subscribed", "unsubscribe", "unsubscribed"]:
        to = internJID(to).userhost()
        fro = internJID(fro).userhost()

    el = Element((None, "presence"))
    el.attributes["to"] = to
    el.attributes["from"] = fro
    if ptype:
        el.attributes["type"] = ptype
    if show:
        s = el.addElement("show")
        s.addContent(utils.xmlify(show))
    if status:
        s = el.addElement("status")
        s.addContent(utils.xmlify(status))
    if priority:
        s = el.addElement("priority")
        s.addContent(priority)
    if url:
        s = el.addElement("x")
        s.attributes["xmlns"] = globals.XOOB
        s = el.addElement("url")
        s.addContent(url)

    if not ptype:
        if avatarHash and not config.disableAvatars and not config.disableVCardAvatars:
            x = el.addElement("x")
            x.attributes["xmlns"] = globals.VCARDUPDATE
            p = x.addElement("photo")
            p.addContent(avatarHash)

        if nickname:
            x = el.addElement("x")
            x.attributes["xmlns"] = globals.VCARDUPDATE
            n = x.addElement("nickname")
            n.addContent(nickname)

        if avatarHash and not config.disableAvatars and not config.disableIQAvatars:
            x = el.addElement("x")
            x.attributes["xmlns"] = globals.XAVATAR
            h = x.addElement("hash")
            h.addContent(avatarHash)

        if nickname and ptype == "subscribe":
            n = el.addElement("nick")
            n.attributes["xmlns"] = globals.NICK
            n.addContent(nickname)

    if payload:
        for p in payload:
            el.addChild(p)

    pytrans.send(el)