コード例 #1
0
ファイル: main.py プロジェクト: zfortier/yakalope
 def sendInvitations(self):
     if config.enableAutoInvite:
         for jid in self.xdb.getRegistrationList():
             LogEvent(INFO, msg="Inviting %r" % jid)
             jabw.sendPresence(self, jid, config.jid, ptype="probe")
             jabw.sendPresence(self,
                               jid,
                               "%s/registered" % (config.jid),
                               ptype="probe")
コード例 #2
0
	def sendInvitations(self):              
		if config.enableAutoInvite:
			for jid in self.xdb.getRegistrationList():
				LogEvent(INFO, msg="Inviting %r" % jid)
				jabw.sendPresence(self, jid, config.jid, ptype="probe")
				jabw.sendPresence(self, jid, "%s/registered" % (config.jid), ptype="probe")
コード例 #3
0
ファイル: register.py プロジェクト: zfortier/yakalope
class RegisterManager:
    def __init__(self, pytrans):
        self.pytrans = pytrans
        if config.allowRegister:
            self.pytrans.discovery.addFeature(disco.IQREGISTER,
                                              self.incomingRegisterIq,
                                              config.jid)
        LogEvent(INFO)

    def removeRegInfo(self, jabberID):
        LogEvent(INFO)
        try:
            # If the session is active then send offline presences
            session = self.pytrans.sessions[jabberID]
            session.removeMe()
        except KeyError:
            pass

        self.pytrans.xdb.remove(jabberID)
        LogEvent(INFO, "", "done")

    def setRegInfo(self, jabberID, username, password):
        LogEvent(INFO)
        if (len(password) == 0):
            (blah1, password, blah3) = self.getRegInfo(jabberID)

        reginfo = legacy.formRegEntry(username, password)
        self.pytrans.xdb.set(
            internJID(jabberID).userhost(), legacy.namespace, reginfo)

    def getRegInfo(self, jabberID):
        LogEvent(INFO)
        result = self.pytrans.xdb.request(
            internJID(jabberID).userhost(), legacy.namespace)
        if (result == None):
            LogEvent(INFO, "", "Not registered!")
            return None

        username, password = legacy.getAttributes(result)

        if (username and password and len(username) > 0 and len(password) > 0):
            LogEvent(INFO, "", "Returning reg info.")
            return (username, password)
        else:
            LogEvent(WARN, "", "Registration data corrupted!")
            return None

    def incomingRegisterIq(self, incoming):
        # Check what type the Iq is..
        itype = incoming.getAttribute("type")
        LogEvent(INFO)
        if (itype == "get"):
            self.sendRegistrationFields(incoming)
        elif (itype == "set"):
            self.updateRegistration(incoming)

    def sendRegistrationFields(self, incoming):
        # Construct a reply with the fields they must fill out
        ID = incoming.getAttribute("id")
        fro = incoming.getAttribute("from")
        LogEvent(INFO)
        reply = Element((None, "iq"))
        reply.attributes["from"] = config.jid
        reply.attributes["to"] = fro
        if ID:
            reply.attributes["id"] = ID
        reply.attributes["type"] = "result"
        query = reply.addElement("query")
        query.attributes["xmlns"] = "jabber:iq:register"
        instructions = query.addElement("instructions")
        ulang = utils.getLang(incoming)
        instructions.addContent(lang.get(ulang).registerText)
        userEl = query.addElement("username")
        passEl = query.addElement("password")

        # Check to see if they're registered
        result = self.getRegInfo(incoming.getAttribute("from"))
        if (result):
            username, password = result
            userEl.addContent(username)
            query.addElement("registered")

        self.pytrans.send(reply)

    def updateRegistration(self, incoming):
        # Grab the username, password
        ID = incoming.getAttribute("id")
        fro = incoming.getAttribute("from")
        LogEvent(INFO)
        source = internJID(fro).userhost()
        ulang = utils.getLang(incoming)
        username = None
        password = None

        for queryFind in incoming.elements():
            if (queryFind.name == "query"):
                for child in queryFind.elements():
                    try:
                        if (child.name == "username"):
                            username = child.__str__()
                        elif (child.name == "password"):
                            password = child.__str__()
                        elif (child.name == "remove"):
                            # The user wants to unregister the transport! Gasp!
                            LogEvent(INFO, "", "Unregistering.")
                            try:
                                self.removeRegInfo(source)
                                self.successReply(incoming)
                            except:
                                self.xdbErrorReply(incoming)
                                return
                            LogEvent(INFO, "", "Unregistered!")
                            return
                    except AttributeError, TypeError:
                        continue  # Ignore any errors, we'll check everything below

        if (self.isValid(username) and password and len(username) > 0
                and len(password) > 0):
            # Valid registration data
            LogEvent(INFO, "", "Updating XDB")
            try:
                self.setRegInfo(source, username, password)
                LogEvent(INFO, "", "Updated XDB")
                self.successReply(incoming)
                LogEvent(INFO, "", "Sent a result Iq")
                to = internJID(incoming.getAttribute("from")).userhost()
                jabw.sendPresence(self.pytrans,
                                  to=to,
                                  fro=config.jid,
                                  ptype="subscribe")
                if (config.registerMessage):
                    jabw.sendMessage(self.pytrans,
                                     to=incoming.getAttribute("from"),
                                     fro=config.jid,
                                     body=config.registerMessage)
            except:
                self.xdbErrorReply(incoming)
                raise

        else:
            self.badRequestReply(incoming)
コード例 #4
0
ファイル: register.py プロジェクト: Ashaman-/pyaimt
								return
							LogEvent(INFO, msg="Unregistered!")
							return
					except AttributeError, TypeError:
						continue # Ignore any errors, we'll check everything below
		
		if username and password and len(username) > 0 and len(password) > 0:
			# Valid registration data
			LogEvent(INFO, msg="Updating XDB")
			try:
				self.pytrans.xdb.setRegistration(source, username, password)
				LogEvent(INFO, msg="Updated XDB")
				self.successReply(incoming)
				LogEvent(INFO, msg="Sent a result Iq")
				to = internJID(incoming.getAttribute("from")).userhost()
				jabw.sendPresence(self.pytrans, to=to, fro=config.jid, ptype="subscribe")
				if config.registerMessage:
					jabw.sendMessage(self.pytrans, to=incoming.getAttribute("from"), fro=config.jid, body=config.registerMessage)
			except:
				self.xdbErrorReply(incoming)
				raise
		
		else:
			self.badRequestReply(incoming)
	
	def badRequestReply(self, incoming):
		LogEvent(INFO)
		# Send an error Iq
		reply = incoming
		reply.swapAttributeValues("to", "from")
		reply.attributes["type"] = "error"
コード例 #5
0
	def sendProbes(self):
		for jid in self.pytrans.xdb.getRegistrationList():
			jabw.sendPresence(self.pytrans, jid, config.jid, ptype="probe")
コード例 #6
0
class PyTransport(component.Service):
    def __init__(self):
        LogEvent(INFO)
        LogEvent(INFO, msg="Reactor: " + str(reactor))

        # Discovery, as well as some builtin features
        self.discovery = disco.ServerDiscovery(self)
        self.discovery.addIdentity("gateway", legacy.id, config.discoName,
                                   config.jid)
        self.discovery.addIdentity("conference", "text",
                                   config.discoName + " Chatrooms", config.jid)
        self.discovery.addFeature(
            disco.XCONFERENCE, None, config.jid
        )  # So that clients know you can create groupchat rooms on the server
        self.discovery.addFeature(
            "jabber:iq:conference", None, config.jid
        )  # We don't actually support this, but Psi has a bug where it looks for this instead of the above
        self.discovery.addIdentity("client", "pc", "MSN Messenger", "USER")
        self.discovery.addIdentity("conference", "text", "MSN Groupchat",
                                   "ROOM")

        self.xdb = xdb.XDB(config.jid, legacy.mangle)
        self.avatarCache = avatar.AvatarCache()
        self.registermanager = register.RegisterManager(self)
        self.gatewayTranslator = misciq.GatewayTranslator(self)
        self.versionTeller = misciq.VersionTeller(self)
        self.pingService = misciq.PingService(self)
        self.adHocCommands = misciq.AdHocCommands(self)
        self.vCardFactory = misciq.VCardFactory(self)
        self.iqAvatarFactor = misciq.IqAvatarFactory(self)
        self.connectUsers = misciq.ConnectUsers(self)
        if config.ftJabberPort:
            self.ftSOCKS5Receive = ft.Proxy65(int(config.ftJabberPort))
            self.ftSOCKS5Send = misciq.Socks5FileTransfer(self)
        if config.ftOOBPort:
            self.ftOOBReceive = ft.FileTransferOOBReceive(int(
                config.ftOOBPort))
            self.ftOOBSend = misciq.FileTransferOOBSend(self)
        self.statistics = misciq.Statistics(self)
        self.startTime = int(time.time())

        self.xmlstream = None
        self.sessions = {}

        # Groupchat ID handling
        self.lastID = 0
        self.reservedIDs = []

        # Message IDs
        self.messageID = 0

        self.loopTask = task.LoopingCall(self.loopFunc)
        self.loopTask.start(60.0)

    def removeMe(self):
        LogEvent(INFO)
        for session in self.sessions.copy():
            self.sessions[session].removeMe()

    def makeMessageID(self):
        self.messageID += 1
        return str(self.messageID)

    def makeID(self):
        newID = "r" + str(self.lastID)
        self.lastID += 1
        if self.reservedIDs.count(newID) > 0:
            # Ack, it's already used.. Try again
            return self.makeID()
        else:
            return newID

    def reserveID(self, ID):
        self.reservedIDs.append(ID)

    def loopFunc(self):
        numsessions = len(self.sessions)

        #if config.debugOn and numsessions > 0:
        #	print "Sessions:"
        #	for key in self.sessions:
        #		print "\t" + self.sessions[key].jabberID

        self.statistics.stats["Uptime"] = int(time.time()) - self.startTime
        self.statistics.stats["OnlineUsers"] = numsessions
        legacy.updateStats(self.statistics)
        if numsessions > 0:
            oldDict = self.sessions.copy()
            self.sessions = {}
            for key in oldDict:
                s = oldDict[key]
                if not s.alive:
                    LogEvent(WARN, "", "Ghost session found.")
                    # Don't add it to the new dictionary. Effectively removing it
                else:
                    self.sessions[key] = s

    def componentConnected(self, xmlstream):
        LogEvent(INFO)
        self.xmlstream = xmlstream
        self.xmlstream.addObserver("/iq", self.discovery.onIq)
        self.xmlstream.addObserver("/presence", self.onPresence)
        self.xmlstream.addObserver("/message", self.onMessage)
        self.xmlstream.addObserver("/route", self.onRouteMessage)
        if config.useXCP:
            pres = Element((None, "presence"))
            pres.attributes["to"] = "presence@-internal"
            pres.attributes["from"] = config.compjid
            x = pres.addElement("x")
            x.attributes[
                "xmlns"] = "http://www.jabber.com/schemas/component-presence.xsd"
            x.attributes["xmlns:config"] = "http://www.jabber.com/config"
            x.attributes["config:version"] = "1"
            x.attributes["protocol-version"] = "1.0"
            x.attributes["config-ns"] = legacy.url + "/component"
            self.send(pres)

    def componentDisconnected(self):
        LogEvent(INFO)
        self.xmlstream = None

    def onRouteMessage(self, el):
        for child in el.elements():
            if child.name == "message":
                self.onMessage(child)
            elif child.name == "presence":
                # Ignore any presence broadcasts about other XCP components
                if child.getAttribute("to") and child.getAttribute("to").find(
                        "@-internal") > 0:
                    return
                self.onPresence(child)
            elif child.name == "iq":
                self.discovery.onIq(child)

    def onMessage(self, el):
        fro = el.getAttribute("from")
        try:
            froj = internJID(fro)
        except Exception, e:
            LogEvent(WARN, "", "Failed stringprep.")
            return
        mtype = el.getAttribute("type")
        s = self.sessions.get(froj.userhost(), None)
        if mtype == "error" and s:
            LogEvent(INFO, s.jabberID,
                     "Removing session because of message type=error")
            s.removeMe()
        elif s:
            s.onMessage(el)
        elif mtype != "error":
            to = el.getAttribute("to")
            ulang = utils.getLang(el)
            body = None
            for child in el.elements():
                if child.name == "body":
                    body = child.__str__()
            LogEvent(
                INFO, "",
                "Sending error response to a message outside of session.")
            jabw.sendErrorMessage(self, fro, to, "auth", "not-authorized",
                                  lang.get(ulang).notLoggedIn, body)
            jabw.sendPresence(self, fro, to, ptype="unavailable")
コード例 #7
0
                        self.sessions[froj.userhost()] = s
                        LogEvent(INFO, "", "New session created.")
                        # Send the first presence
                        s.onPresence(el)
                    else:
                        LogEvent(INFO, "", "Failed to create session")
                        jabw.sendMessage(self,
                                         to=froj.userhost(),
                                         fro=config.jid,
                                         body=lang.get(ulang).notRegistered)

                elif el.getAttribute("type") != "error":
                    LogEvent(
                        INFO, "",
                        "Sending unavailable presence to non-logged in user.")
                    jabw.sendPresence(self, fro, to, ptype="unavailable")
                    return

            elif ptype and (ptype.startswith("subscribe")
                            or ptype.startswith("unsubscribe")):
                # They haven't logged in, and are trying to change subscription to a user
                # No, lets not log them in. Lets send an error :)
                jabw.sendPresence(self, fro, to, ptype="error")

                # Lets log them in and then do it
                #LogEvent(INFO, "", "Attempting to create a session to do subscription stuff.")
                #s = session.makeSession(self, froj.userhost(), ulang)
                #if s:
                #	self.sessions[froj.userhost()] = s
                #	LogEvent(INFO, "", "New session created.")
                #	# Tell the session there's a new resource
コード例 #8
0
 def sendProbes(self):
     for jid in self.pytrans.xdb.files():
         jabw.sendPresence(self.pytrans, jid, config.jid, ptype="probe")
コード例 #9
0
 def sendProbes(self):
     for jid in self.pytrans.xdb.getRegistrationList():
         jabw.sendPresence(self.pytrans, jid, config.jid, ptype="probe")
コード例 #10
0
                            LogEvent(INFO, msg="Unregistered!")
                            return
                    except AttributeError, TypeError:
                        continue  # Ignore any errors, we'll check everything below

        if username and password and len(username) > 0 and len(password) > 0:
            # Valid registration data
            LogEvent(INFO, msg="Updating XDB")
            try:
                self.pytrans.xdb.setRegistration(source, username, password)
                LogEvent(INFO, msg="Updated XDB")
                self.successReply(incoming)
                LogEvent(INFO, msg="Sent a result Iq")
                to = internJID(incoming.getAttribute("from")).userhost()
                jabw.sendPresence(self.pytrans,
                                  to=to,
                                  fro=config.jid,
                                  ptype="subscribe")
                if config.registerMessage:
                    jabw.sendMessage(self.pytrans,
                                     to=incoming.getAttribute("from"),
                                     fro=config.jid,
                                     body=config.registerMessage)
            except:
                self.xdbErrorReply(incoming)
                raise

        else:
            self.badRequestReply(incoming)

    def badRequestReply(self, incoming):
        LogEvent(INFO)