Beispiel #1
0
 def __init__(self, jid=None, node='', domain='', resource=''):
     '''This constructor allows the use of JID(node='foo'), since we do
        have a notion of default domain. If the default domain was not
        initialized, pyxmpp's JID will still raise a ValueError.'''
     if jid is None and ('' == domain):
         domain = self.domain
     XJID.__init__(self, jid, node, domain, resource)
Beispiel #2
0
 def setOidResquestState( self, mess, state):
     jid = JID(mess.getFrom())
     n_id = jid.getStripped()
     try:
         oidrequest = OidRequest.objects.filter(identity__userprofile__notification_id=n_id, identity__userprofile__notification_type=UserProfile.JABBER_NOTIFICATION_TYPE, identity__userprofile__notification_state=UserProfile.VALID_NOTIFICATION_STATE).latest('date_created')
         oidrequest.validation = state
         oidrequest.save()
         return 'OK'
     except OidRequest.DoesNotExist:
         return 'Error: couldn\'t find any OpenID request pending!'
Beispiel #3
0
    def __init__(self):
        self.jid = JID(config.get('im', 'account'))
        self.jid.setResource('xtunnel')
        self.password = config.get('im', 'password')
        self.debug = config.get('config', 'debug') == 'true'

        self.status = 'Internal %s %s' % (tap.ip, tap.mac)
        if config.has_option('im', 'ip'):
            eip = config.get('im', 'ip')
            eport = int(config.get('im', 'port'))
            self.status = 'External %s %s %s %s' % (tap.ip, tap.mac, eip,
                                                    eport)

        self.reconnect()
Beispiel #4
0
 def send(self, recipients, message):
     """Send message to recipients via xmpp."""
     jid = JID(self.user)
     if self.server:
         server = self.server
     else:
         server = jid.getDomain()
     cl = Client(server, port=self.port, debug=[])
     if not cl.connect():
         raise IOError("Couldn't connect to xmpp server %s" % server)
     if not cl.auth(jid.getNode(), self.password, resource=self.resource):
         cl.Connection.disconnect()
         raise IOError("Xmpp auth erro using %s to %s", jid, server)
     for recip in recipients:
         cl.send(Message(recip[2], message))
Beispiel #5
0
    def get_uname_from_mess(self, mess, full_jid=False):
        nick = self.get_sender_username(mess)
        node = mess.getFrom().getNode()

        # Private message
        if nick == node:
            return mess.getFrom() if full_jid else nick

        # MUC message
        try:
            jid = self.nick_dict[node][nick]
        except KeyError:
            jid = JID("default")

        return jid if full_jid else jid.getNode()
Beispiel #6
0
 def normalize_jid(self, jid):
     if isinstance(jid, JID):
         return jid
     elif isinstance(jid, basestring):
         return JID(jid=unicode(jid))
     raise ValueError(
         "JID value is not a JID or basestring, cannot normalize to JID object: %r"
         % jid)
Beispiel #7
0
	def __init__(self, client, name, nick):
		self.client = client
		self.name = name
		self.nick = nick

		self.roomId = "%s/%s" % (name, nick)
		self.jid = JID(self.roomId)
		self.mucId = self.jid.getStripped()
		self.roster = {}
Beispiel #8
0
 def read(self):
     buf = self.socket.recv(2000)
     self.buffer = buf = self.buffer + buf
     if len(buf) >= 2:
         len_ = (ord(buf[0]) << 8) + ord(buf[1])
         if len(buf) >= (2 + len_):
             jid = JID(buf[2:2 + len_])
             host = hosts.by_jid(jid)
             if host:
                 host.set_link(self.socket, buf[2 + len_:])
             else:
                 self.socket.close()
             listener.close_link(self)
Beispiel #9
0
class Muc(object):

	def __init__(self, client, name, nick):
		self.client = client
		self.name = name
		self.nick = nick

		self.roomId = "%s/%s" % (name, nick)
		self.jid = JID(self.roomId)
		self.mucId = self.jid.getStripped()
		self.roster = {}

	def getId(self):
		return self.mucId

	def getUser(self, nick):
		if nick not in self.roster:
			return None
		return self.roster[nick]

	def getNick(self):
		return self.nick

	def sendPresence(self, password):
		presence = xmpp.Presence(to=self.roomId)
		x = presence.setTag('x', namespace=xmpp.NS_MUC)
		x.setTagData('password', password)
		x.addChild('history', {'maxchars': '0', 'maxstanzas': '0'});
		self.client.client.send(presence)

	def sendMessage(self, body):
		message = xmpp.protocol.Message(to=self.mucId, body=body, typ='groupchat')
		self.client.client.send(message)

	def setRole(self, user, role, reason=None):
		iqMap = {'role': role}
		if reason is not None:
			iqMap['reason'] = reason
		self.client.client.send(user.iq(iqMap))

	def setAffiliation(self, user, affiliation):
		self.client.client.send(user.iq({'affiliation': affiliation}))

	def onRoster(self, presence):
		nick = presence.getFrom().getResource()

		if presence.getType() == 'unavailable':
			if nick not in self.roster:
				return

			user = self.roster[nick]

			# This unpleasantness checks for and handles nickname changes:
			x = presence.getTag(presence, {}, NS_MUC_USER)
			if x is None:
				return
			item = x.getTag('item')
			status = x.getTag('status')

			if status and status.getAttr('code') == '303':
				newNick = item.getAttr('nick')
				if newNick == nick:
					return

				# nick -> newNick
				user.updateNick(newNick)
				del self.roster[nick]
				self.roster[newNick] = user
				if nick == self.nick:
					self.nick = nick
				self.client.emitMucNickChange(self, user, nick)
			else:
				# Seems like this user was deleted.
				self.client.emitMucPart(self, self.roster[nick])
				del self.roster[nick]
		else:
			if nick in self.roster:
				user = self.roster[nick]
				user.updateFromPresence(nick, presence)
			else:
				self.roster[nick] = self.userFromPresence(nick, presence)
				self.client.emitMucJoin(self, self.roster[nick])
			pass

	def userFromPresence(self, nick, presence):
		return User(self, nick).updateFromPresence(nick, presence)
Beispiel #10
0
class XMPPClient(object):
    def __init__(self):
        self.jid = JID(config.get('im', 'account'))
        self.jid.setResource('xtunnel')
        self.password = config.get('im', 'password')
        self.debug = config.get('config', 'debug') == 'true'

        self.status = 'Internal %s %s' % (tap.ip, tap.mac)
        if config.has_option('im', 'ip'):
            eip = config.get('im', 'ip')
            eport = int(config.get('im', 'port'))
            self.status = 'External %s %s %s %s' % (tap.ip, tap.mac, eip,
                                                    eport)

        self.reconnect()

    def connect(self):
        if not self.client.connect():
            print 'Failed to connect to the XMPP server.\nExiting...'
            return False

        auth = self.client.auth(self.jid.getNode(), self.password,
                                self.jid.getResource())
        if not auth:
            print 'Failed to authenticate you.\nExiting...'
            return False

        self.client.RegisterHandler('message', self.handle_message)
        self.client.RegisterHandler('presence', self.handle_presence)
        self.client.send(Presence(status=self.status))

        return True

    def handle_presence(self, dispatcher, presence):
        type_ = presence.getType()
        jid = presence.getFrom()

        # When I login to the gtalk server, I have set my resource name to
        # 'xtunnel'.  But when I get the presence information, the server
        # will add some random characters after the resource string.
        # Following lines is to deal with this situation.
        if not jid.getResource().startswith('xtunnel'):
            return
        jid.setResource('xtunnel')

        if jid == self.jid:
            return  # TODO google kick me out?

        if type_ is None:  # available
            if presence.getStatus():
                info = presence.getStatus().split()
                if len(info) == 3 and info[0] == 'Internal':
                    [ip, mac] = info[1:]
                    host = Host(jid, ip, mac)
                    hosts.add_host(host)
                elif len(info) == 5 and info[0] == 'External':
                    [ip, mac, eip, eport] = info[1:]
                    if self.status.startswith('External') and tap.mac > mac:
                        host = Host(jid, ip, mac)
                    else:
                        host = Host(jid, ip, mac, eip, int(eport))
                    hosts.add_host(host)
        elif type_ == 'unavailable':
            hosts.remove_host(jid)

    def handle_message(self, dispatcher, message):
        if message.getType() != 'normal':
            return
        tap.write(base64.b64decode(message.getBody()))

    def read(self):
        try:
            self.client.Process()
        except:
            self.reconnect()

    def send_frame(self, jid, frame):
        message = base64.b64encode(repr(frame))
        try:
            self.client.send(Message(to=jid, typ='normal', body=message))
        except:
            self.reconnect()

    def fileno(self):
        return self.client.Connection._sock.fileno()

    def reconnect(self):
        try:
            time.sleep(7)
            self.client.disconnect()
        except:
            pass

        if self.debug:
            self.client = Client(self.jid.getDomain())
        else:
            self.client = Client(self.jid.getDomain(), debug=[])

        try:
            if not self.connect():
                self.reconnect()
        except:
            self.reconnect()