コード例 #1
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
   def handle_PUT(self,cmd,recipients,sensors,data,reply):
       global connections
      
       failed_recipients=[]
       status=False
       usr=myUser(self.usrDB,self.user)
          
       #PUT message will forward to the recipients     
       for recipient in recipients:
          if self.isConnected(recipient):
              rep=myUser(self.usrDB,recipient)
              if rep.isShare(self.user,sensors):
                 connections[recipient].sendMessage("@"+self.user+reply,False)
                 status=True
              else:
                  failed_recipients.append(recipient)
          else:failed_recipients.append(recipient)

       st='@%s DATA #msg %s' %(self.server,cmd)
       if status:
          st+='Done'
          self.sendMessage(st,False)
       else:
          st+='Failed'
          self.sendMessage(st+str(failed_recipients),False)
コード例 #2
0
    def GETSenze(self, query):
        global connections
        global database
        global serverName

        sender = query.getSender()
        sensors = query.getSensors()
        usr = myUser(database, serverName)
        recipients = query.getUsers()
        for recipient in recipients:
            recipientDB = myUser(database, recipient)
            if 'pubkey' in sensors:
                #Since mysensors already has public key of it clients,
                #it responses on behalf of the client.
                pubkey = recipientDB.loadPublicKey()
                if pubkey != '':
                    if sender in connections.keys():
                        backward = connections[sender]
                        senze = 'DATA #name %s #pubkey %s' % (recipient,
                                                              pubkey)
                        cry = myCrypto(serverName)
                        senze = cry.signSENZE(senze)
                        self.transport.write(senze, backward)
            #Otherwise GET message will forward to the recipients
            else:
                if recipient in connections.keys():
                    forward = connections[recipient]
                    if forward != 0 and \
                       recipientDB.isShare(sender, query.getSensors()):
                        self.transport.write(query.getFULLSENZE(), forward)
                    else:
                        logger.error('Senz not shared with recipient: %s' %
                                     recipient)
                else:
                    logger.error('No recipient found: %s' % recipient)
コード例 #3
0
ファイル: myServer.py プロジェクト: iot-senz/payz-switch
    def GETSenze(self, query):
        global connections
        global database
        global serverName

        sender = query.getSender()
        sensors = query.getSensors()
        usr = myUser(database, serverName)
        recipients = query.getUsers()
        for recipient in recipients:
            recipientDB = myUser(database, recipient)
            if 'pubkey' in sensors:
                #Since mysensors already has public key of it clients,
                #it responses on behalf of the client.
                pubkey = recipientDB.loadPublicKey()
                if pubkey != '':
                    if sender in connections.keys():
                        backward = connections[sender]
                        senze = 'DATA #name %s #pubkey %s' % (recipient,
                                                              pubkey)
                        cry = myCrypto(serverName)
                        senze = cry.signSENZE(senze)
                        self.transport.write(senze, backward)
            #Otherwise GET message will forward to the recipients
            else:
                if recipient in connections.keys():
                    forward = connections[recipient]
                    if forward != 0 and \
                       recipientDB.isShare(sender, query.getSensors()):
                        self.transport.write(query.getFULLSENZE(), forward)
                    else:
                        logger.error('Senz not shared with recipient: %s' % recipient)
                else:
                    logger.error('No recipient found: %s' % recipient)
コード例 #4
0
    def handle_PUT(self, cmd, recipients, sensors, data, reply):
        global connections

        failed_recipients = []
        status = False
        usr = myUser(self.usrDB, self.user)

        #PUT message will forward to the recipients
        for recipient in recipients:
            if self.isConnected(recipient):
                rep = myUser(self.usrDB, recipient)
                if rep.isShare(self.user, sensors):
                    connections[recipient].sendMessage("@" + self.user + reply,
                                                       False)
                    status = True
                else:
                    failed_recipients.append(recipient)
            else:
                failed_recipients.append(recipient)

        st = '@%s DATA #msg %s' % (self.server, cmd)
        if status:
            st += 'Done'
            self.sendMessage(st, False)
        else:
            st += 'Failed'
            self.sendMessage(st + str(failed_recipients), False)
コード例 #5
0
ファイル: myServer.py プロジェクト: sumedhe/senze
    def PUTSenze(self, query):
        global connections
        global database

        sender = query.getSender()
        usr = myUser(database, sender)
        recipients = query.getUsers()
        #PUT message will forward to the recipients
        for recipient in recipients:
            if recipient in connections.keys():
                recipientDB = myUser(database, recipient)
                if recipientDB.isShare(sender, query.getSensors()):
                    forward = connections[recipient]
                    if forward != 0:
                        self.transport.write(query.getFULLSENZE(), forward)
コード例 #6
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
 def handle_GET(self,recipients,sensors,reply):
     global connections
     failed_recipients=[]
     """
     print "R->",recipients
     print "Reply->",reply
     print "S->",sensors
     """
       
     #If GET addresses to the mysensors   
     if self.server in recipients:
        if 'pubkey' in sensors:
            cry=myCrypto(self.server)
            publicKey=cry.loadRSAPubKey()
            st='@%s DATA #pubkey %s' %(self.server,publicKey)
            self.sendMessage(st,False)
    
     #Otherwise GET message will forward to the recipients     
     else:
         for recipient in recipients:
            if self.isConnected(recipient):
               rep=myUser(self.usrDB,recipient) 
               if rep.isShare(self.user,sensors):
                  connections[recipient].sendMessage("@"+self.user+reply,False)
               else:
                  failed_recipients.append(recipient)
            else:failed_recipients.append(recipient)
  
         st='@%s DATA #msg ' %(self.server)
         if len(failed_recipients)==0:
            self.sendMessage(st+"GETSendDone",False)
         else:
            self.sendMessage(st+"GETSendFailed:"+str(failed_recipients),False)
コード例 #7
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
   def handle_UNSHARE(self,recipients,sensors,reply):
       """
        If message comes ':SHARE #tp @user2' from the user1,
        First we need to verify that user2 is logged in.
        Then mysensors removes  "user2" from the sensor dictionary at user1's document and
        the sensor name from the "user1" dictionary at user2's document.
        
        If user2 also shared the same sensor to user1, 
        mysensors removes the sensor name from user2 dictionary at user1's document
        and "user2" from the sensor dictionary at user2's document.
        
        Finally it delivers the query @user1 :SHARE #tp to user2.
        If all process works, mysensors sends @mysensors DATA #msg :ShareDone to user1.
        Otherwise it sends @mysensors DATA #msg :ShareFailed to user1.   
       """
       global connections
       replyMsg="@"+self.server+" DATA #msg "
 
       failed_recipients=[]
       usr=myUser(self.usrDB,self.user) 
       for recipient in recipients:
           if self.isConnected(recipient):
               connections[recipient].sendMessage("@"+self.user+reply,False)
               usr.unShare(recipient,sensors)
           else:
               failed_recipients.append(recipient)

       if len(failed_recipients)==0:
          self.sendMessage(replyMsg+":ShareDone",False)
       else:
          self.sendMessage(replyMsg+":ShareFailed:"+str(failed_recipients),False)
コード例 #8
0
ファイル: myServer.py プロジェクト: iot-senz/payz-switch
    def createUser(self, query, address):
        global database
        global serverName
        global serverPubkey

        usr = myUser(database, serverName)
        cry = myCrypto(serverName)
        data = query.getData()
        pubkey = ''
        phone = ''
        reg_status = ''
        if 'pubkey' in data:
            pubkey = data['pubkey']
        if 'phone' in data:
            phone = data['phone']
        if cry.verifySENZE(query, pubkey):
            reg_status = usr.addUser(query.getSender(), phone, query.getSENZE(),
                                 pubkey, query.getSignature())

        logger.info('Registration status: %s' % reg_status)

        if reg_status == 'REGISTERED':
            st = 'DATA #msg ALREADY_REGISTERED #pubkey %s ' % (serverPubkey)
        elif reg_status == 'DONE':
            st = 'DATA #msg REGISTRATION_DONE #pubkey %s ' % (serverPubkey)
        else:
            st = 'DATA #msg REGISTRATION_FAIL'
        senze = cry.signSENZE(st)
        self.transport.write(senze, address)
コード例 #9
0
ファイル: myServer.py プロジェクト: sumedhe/senze
    def DATASenze(self, query):
        global connections
        global database

        sender = query.getSender()
        usr = myUser(database, sender)
        recipients = query.getUsers()
        sensors = query.getSensors()
        for recipient in recipients:
            if recipient in connections.keys():
                recipientDB = myUser(database, recipient)
                #DATA msg queries will always deliverd
                if recipientDB.isAllow(sender, sensors) or "msg" in sensors:
                    forward = connections[recipient]
                    if forward != 0:
                        self.transport.write(query.getFULLSENZE(), forward)
コード例 #10
0
ファイル: myServer.py プロジェクト: iot-senz/senz-switch
    def shareSensors(self, senz):
        global connections
        global database
        global serverName
        """
        If query comes 'SHARE #tp @user2 #time t1 ^user1 siganture'
                                                     from the user1.
        First we need to verify that user2 is available.
        Then mysensors adds "user2" to the sensor dictionary at
                                                     user1's document and
        sensor name to the "user1" dictionary at user2's document.
        Finally it delivers the message SHARE #tp @user2 #time t1 ^user1
                                                     signature to user2.
        """
        sender = myUser(database, senz.getSender())

        recipients = senz.getRecipients()
        for recipient in recipients:
            if recipient in connections.keys():
                sender.share(recipient, senz.getSensors())

                logger.info('Sharing senz to: %s' % senz.getSender())
                logger.info('Sharing senz from: %s' % recipient)

                logger.info('______SHARED______')

                forward = connections[recipient]
                if forward != 0:
                    logger.info('Forward senz to: %s' % recipient)
                    self.transport.write(senz.getFULLSENZE(), forward)
                else:
                    logger.error('Not recipient found : %s' % recipient)
コード例 #11
0
    def handle_UNSHARE(self, recipients, sensors, reply):
        """
        If message comes ':SHARE #tp @user2' from the user1,
        First we need to verify that user2 is logged in.
        Then mysensors removes  "user2" from the sensor dictionary at user1's document and
        the sensor name from the "user1" dictionary at user2's document.
        
        If user2 also shared the same sensor to user1, 
        mysensors removes the sensor name from user2 dictionary at user1's document
        and "user2" from the sensor dictionary at user2's document.
        
        Finally it delivers the query @user1 :SHARE #tp to user2.
        If all process works, mysensors sends @mysensors DATA #msg :ShareDone to user1.
        Otherwise it sends @mysensors DATA #msg :ShareFailed to user1.   
       """
        global connections
        replyMsg = "@" + self.server + " DATA #msg "

        failed_recipients = []
        usr = myUser(self.usrDB, self.user)
        for recipient in recipients:
            if self.isConnected(recipient):
                connections[recipient].sendMessage("@" + self.user + reply,
                                                   False)
                usr.unShare(recipient, sensors)
            else:
                failed_recipients.append(recipient)

        if len(failed_recipients) == 0:
            self.sendMessage(replyMsg + ":ShareDone", False)
        else:
            self.sendMessage(
                replyMsg + ":ShareFailed:" + str(failed_recipients), False)
コード例 #12
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
   def handle_SHARE(self,recipients,sensors,reply):
       global connections
       replyMsg="@"+self.server+" DATA #msg "
 
       """
        In order to start the sharing process both users need to logged in to the system.
        For a instance, if query comes 'SHARE #tp @user2' from the user1.
        First we need to verify that user2 is logged in.
        Then mysensors adds "user2" to the sensor dictionary at user1's document and
        sensor name to the "user1" dictionary at user2's document.
        Finally it delivers the message @user1 SHARE #tp to user2.
        If all process works, mysensors also sends @mysensors DATA #msg ShareDone to user1.
        Otherwise it sends @mysensors DATA #msg ShareFailed to user1.
       """
       failed_recipients=[]
       usr=myUser(self.usrDB,self.user)
       for recipient in recipients:
           if self.isConnected(recipient):
               connections[recipient].sendMessage("@"+self.user+reply,False)
               usr.share(recipient,sensors)
           else:
               failed_recipients.append(recipient)
         
       if len(failed_recipients)==0:
          self.sendMessage(replyMsg+"ShareDone",False)
       else:
          self.sendMessage(replyMsg+"ShareFailed:"+str(failed_recipients),False)
コード例 #13
0
    def createUser(self, query, address):
        global database
        global serverName
        global serverPubkey

        usr = myUser(database, serverName)
        cry = myCrypto(serverName)
        data = query.getData()
        pubkey = ''
        phone = ''
        reg_status = ''
        if 'pubkey' in data:
            pubkey = data['pubkey']
        if 'phone' in data:
            phone = data['phone']
        if cry.verifySENZE(query, pubkey):
            reg_status = usr.addUser(query.getSender(), phone,
                                     query.getSENZE(), pubkey,
                                     query.getSignature())

        logger.info('Registration status: %s' % reg_status)

        if reg_status == 'REGISTERED':
            st = 'DATA #msg ALREADY_REGISTERED #pubkey %s ' % (serverPubkey)
        elif reg_status == 'DONE':
            st = 'DATA #msg REGISTRATION_DONE #pubkey %s ' % (serverPubkey)
        else:
            st = 'DATA #msg REGISTRATION_FAIL'
        senze = cry.signSENZE(st)
        self.transport.write(senze, address)
コード例 #14
0
    def handle_SHARE(self, recipients, sensors, reply):
        global connections
        replyMsg = "@" + self.server + " DATA #msg "
        """
        In order to start the sharing process both users need to logged in to the system.
        For a instance, if query comes 'SHARE #tp @user2' from the user1.
        First we need to verify that user2 is logged in.
        Then mysensors adds "user2" to the sensor dictionary at user1's document and
        sensor name to the "user1" dictionary at user2's document.
        Finally it delivers the message @user1 SHARE #tp to user2.
        If all process works, mysensors also sends @mysensors DATA #msg ShareDone to user1.
        Otherwise it sends @mysensors DATA #msg ShareFailed to user1.
       """
        failed_recipients = []
        usr = myUser(self.usrDB, self.user)
        for recipient in recipients:
            if self.isConnected(recipient):
                connections[recipient].sendMessage("@" + self.user + reply,
                                                   False)
                usr.share(recipient, sensors)
            else:
                failed_recipients.append(recipient)

        if len(failed_recipients) == 0:
            self.sendMessage(replyMsg + "ShareDone", False)
        else:
            self.sendMessage(
                replyMsg + "ShareFailed:" + str(failed_recipients), False)
コード例 #15
0
 def shareSensors(self, query):
     global connections
     global database
     global serverName
     """
     If query comes 'SHARE #tp @user2 #time t1 ^user1 siganture'
                                                  from the user1.
     First we need to verify that user2 is available.
     Then mysensors adds "user2" to the sensor dictionary at
                                                  user1's document and
     sensor name to the "user1" dictionary at user2's document.
     Finally it delivers the message SHARE #tp @user2 #time t1 ^user1
                                                  signature to user2.
     """
     usr = myUser(database, query.getSender())
     recipients = query.getUsers()
     for recipient in recipients:
         if recipient in connections.keys():
             usr.share(recipient, query.getSensors())
             forward = connections[recipient]
             if forward != 0:
                 logger.info('Forward senz to: %s' % recipient)
                 self.transport.write(query.getFULLSENZE(), forward)
             else:
                 logger.error('Not recipient found : %s' % recipient)
コード例 #16
0
def addMessage(userList, idToCheck, name, content):
    for keithUser in userList:
        if keithUser.id == idToCheck:
            keithUser.addContent(content)
            break
    else:
        userList.append(myUser(idToCheck, name))
        userList[-1].addContent(content)
コード例 #17
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
 def handle_GET_MySensors(self,recipients,sensors,data,reply):
    
     usr=myUser(self.usrDB,self.user)
     #Check the given user is online or offline
     #GET #name kasun @mysensors -> @mysenosrs DATA #name kasun ONLINE/OFFLINE
     if 'name' in sensors:
        if 'name' in data.keys():
           if self.isConnected(data['name']):
              response='@%s DATA #name %s #msg ONLINE' %(self.server,data['name'])
           else:
              response='@%s DATA #name %s #msg OFFLINE' %(self.server,data['name'])
        else:
             response='@%s DATA #name #msg UnKnown' %(self.server)
     #Return the list of friends who shared the given sensor with me
     #GET #friends #shared tp @mysensors -> @mysenosrs DATA #friends kasun,nimal #shared tp
     elif 'friends' in sensors:
         if 'shared' in data.keys():
            rep=usr.loadFriends(data['shared'])
            response='@%s DATA #friends %s #shared %s' %(self.server,rep,data['shared'])
         else:
             #Return the list of friends who registered with the server
             #GET #friends kasun,d1,nimal -> @mysenosrs DATA #friends kasun,nimal
             if 'friends' in data.keys():
                rep=usr.findUsers(data['friends'])
                response='@%s DATA #friends %s' %(self.server,rep)
             else:
               response='@%s DATA #sensor #msg UnKnown' %(self.server)
     #Return the list of friends where I shared the given sensor
     #GET #shared tp @mysensors -> @mysenosrs DATA #shared tp #friends kasun,nimal
     elif 'shared' in sensors:
         if 'shared' in data.keys():
            rep=usr.loadData(data['shared'])
            response='@%s DATA #shared %s #friends %s' %(self.server,data['shared'],rep)
         else:
            response='@%s DATA #sensor #msg UnKnown' %(self.server)
  
     #Return the list of sensors shared by the given friend
     #GET #friend nimal @mysensors -> @mysenosrs DATA #friend nimal #shared gps,tp
     elif 'friend' in sensors:
         if 'friend' in data.keys():
            rep=usr.loadData(data['friend'])
            response='@%s DATA #friend %s #shared %s' %(self.server,data['friend'],rep)
         else:
            #Need to return name of friends who shared sensor here
            response='@%s DATA #friend #msg UnKnown' %(self.server)
     #Return the number of connections at the given time
     #GET #connections @mysensors -> @mysenosrs DATA #connections 5
     elif 'connections' in sensors:
           num=str(factory.getConnectionCount())
           response='@%s DATA #connections %s' %(self.server,num)
     #Return the number of users at the given time
     #GET #users @mysensors -> @mysenosrs DATA #users 1000
     elif 'users' in sensors:
           num=str(usr.countDocs())
           response='@%s DATA #users %s' %(self.server,num)
     else:
           response='@%s DATA #msg UnsupportedSenzeType' %(self.server)
     self.sendMessage(response,False)
コード例 #18
0
    def datagramReceived(self, datagram, address):
        global serverName
        global usrDatabase

        logger.info('senz received:  %s' % datagram)

        query = myParser(datagram)
        recipients = query.getUsers()
        sender = query.getSender()
        signature = query.getSignature()
        data = query.getData()
        sensors = query.getSensors()
        cmd = query.getCmd()

        validQuery = False
        cry = myCrypto(serverName)
        senderDB = myUser(database, sender)
        pubkey = senderDB.loadPublicKey()

        if cmd == "SHARE" and "pubkey" in sensors and serverName in recipients:
            #Create a new account
            self.createUser(query, address)
            validQuery = True

        elif cmd == "UNSHARE" and "pubkey" in sensors and\
                serverName in recipients:
            #Remove the account
            status = False
            if pubkey != "":
                if cry.verifySENZE(query, pubkey):
                    status = self.removeUser(sender, pubkey, address)
            validQuery = True

        else:
            if pubkey != "":
                if cry.verifySENZE(query, pubkey):
                    validQuery = True

        if validQuery:
            connections[sender] = address
            connectionsTime[sender] = time.time()
            if cmd == "SHARE":
                self.shareSensors(query)
            elif cmd == "UNSHARE":
                self.unshareSensors(query)
            elif cmd == "GET":
                self.GETSenze(query)
            elif cmd == "PUT":
                self.PUTSenze(query)
            elif cmd == "DATA":
                self.DATASenze(query)

        else:
            senze = "DATA #msg SignatureVerificationFailed"
            senze = cry.signSENZE(senze)
            self.transport.write(senze, address)
コード例 #19
0
ファイル: myServer.py プロジェクト: iot-senz/payz-switch
    def datagramReceived(self, datagram, address):
        global serverName
        global usrDatabase

        logger.info('senz received:  %s' % datagram)

        query = myParser(datagram)
        recipients = query.getUsers()
        sender = query.getSender()
        signature = query.getSignature()
        data = query.getData()
        sensors = query.getSensors()
        cmd = query.getCmd()

        validQuery = False
        cry = myCrypto(serverName)
        senderDB = myUser(database, sender)
        pubkey = senderDB.loadPublicKey()

        if cmd == "SHARE" and "pubkey" in sensors and serverName in recipients:
            #Create a new account
            self.createUser(query, address)
            validQuery = True

        elif cmd == "UNSHARE" and "pubkey" in sensors and\
                serverName in recipients:
            #Remove the account
            status = False
            if pubkey != "":
                if cry.verifySENZE(query, pubkey):
                    status = self.removeUser(sender, pubkey, address)
            validQuery = True

        else:
            if pubkey != "":
                if cry.verifySENZE(query, pubkey):
                    validQuery = True

        if validQuery:
            connections[sender] = address
            connectionsTime[sender] = time.time()
            if cmd == "SHARE":
                self.shareSensors(query)
            elif cmd == "UNSHARE":
                self.unshareSensors(query)
            elif cmd == "GET":
                self.GETSenze(query)
            elif cmd == "PUT":
                self.PUTSenze(query)
            elif cmd == "DATA":
                self.DATASenze(query)

        else:
            senze = "DATA #msg SignatureVerificationFailed"
            senze = cry.signSENZE(senze)
            self.transport.write(senze, address)
コード例 #20
0
ファイル: myServer.py プロジェクト: iot-senz/payz-switch
    def PUTSenze(self, query):
        global connections
        global database

        sender = query.getSender()
        usr = myUser(database, sender)
        recipients = query.getUsers()
        #PUT message will forward to the recipients
        for recipient in recipients:
            if recipient in connections.keys():
                recipientDB = myUser(database, recipient)
                if recipientDB.isShare(sender, query.getSensors()):
                    forward = connections[recipient]
                    if forward != 0:
                        self.transport.write(query.getFULLSENZE(), forward)
                    else:
                        logger.error('No recipient found: %s' % recipient)
                else:
                    logger.error('Senz not share with recipient: %s' % recipient)
コード例 #21
0
ファイル: myServer.py プロジェクト: iot-senz/payz-switch
    def DATASenze(self, query):
        global connections
        global database

        sender = query.getSender()
        usr = myUser(database, sender)
        recipients = query.getUsers()
        sensors = query.getSensors()
        for recipient in recipients:
            if recipient in connections.keys():
                recipientDB = myUser(database, recipient)
                #DATA msg queries will always deliverd
                if recipientDB.isAllow(sender, sensors) or "msg" in sensors:
                    forward = connections[recipient]
                    if forward != 0:
                        self.transport.write(query.getFULLSENZE(), forward)
                    else:
                        logger.error('No recipient found: %s' % recipient)
                else:
                    logger.error('Senz not shared with : %s' % recipient)
コード例 #22
0
    def PUTSenze(self, senz):
        global connections
        global database

        sender = senz.getSender()
        usr = myUser(database, sender)
        recipients = senz.getRecipients()
        #PUT message will forward to the recipients
        for recipient in recipients:
            if recipient in connections.keys():
                recipientDB = myUser(database, recipient)
                if recipientDB.isShare(sender, senz.getSensors()):
                    forward = connections[recipient]
                    if forward != 0:
                        self.transport.write(senz.getFULLSENZE(), forward)
                    else:
                        logger.error('No recipient found: %s' % recipient)
                else:
                    logger.error('Senz not share with recipient: %s' %
                                 recipient)
コード例 #23
0
ファイル: myServer.py プロジェクト: iot-senz/payz-switch
 def unshareSensors(self, query):
     global connections
     global database
     usr = myUser(database, query.getSender())
     recipients = query.getUsers()
     for recipient in recipients:
         if recipient in connections.keys():
             usr.unShare(recipient, query.getSensors())
             forward = connections[recipient]
             if forward != 0:
                 self.transport.write(query.getFULLSENZE(), forward)
コード例 #24
0
 def unshareSensors(self, query):
     global connections
     global database
     usr = myUser(database, query.getSender())
     recipients = query.getUsers()
     for recipient in recipients:
         if recipient in connections.keys():
             usr.unShare(recipient, query.getSensors())
             forward = connections[recipient]
             if forward != 0:
                 self.transport.write(query.getFULLSENZE(), forward)
コード例 #25
0
    def DATASenze(self, senz):
        global connections
        global database

        sender = senz.getSender()
        usr = myUser(database, sender)
        recipients = senz.getRecipients()
        sensors = senz.getSensors()
        for recipient in recipients:
            if recipient in connections.keys():
                recipientDB = myUser(database, recipient)
                #DATA msg queries will always deliverd
                if recipientDB.isAllow(sender, sensors) or "msg" in sensors:
                    forward = connections[recipient]
                    if forward != 0:
                        self.transport.write(senz.getFULLSENZE(), forward)
                    else:
                        logger.error('No recipient found: %s' % recipient)
                else:
                    logger.error('Senz not shared with : %s' % recipient)
コード例 #26
0
    def removeUser(self, sender, pubkey, address):
        global database
        global serverName

        usr = myUser(database, serverName)
        cry = myCrypto(serverName)
        status = usr.delUser(sender, pubkey)
        st = "DATA #msg "
        if status:
            st += 'UserRemoved'
        else:
            st += 'UserCannotRemoved'
        senze = cry.signSENZE(st)
        self.transport.write(senze, address)
コード例 #27
0
    def handle_PUT_MySensors(self, cmd, recipients, sensors, data, reply):
        status = False
        usr = myUser(self.usrDB, self.user)
        cry = myCrypto(self.server)
        type = 'skey'

        n = ''
        k = ''
        p = ''
        pub = ''
        sig = ''
        e = ''
        if 'name' in data: n = data['name']
        if 'skey' in data: k = data['skey']
        if 'hkey' in data:
            k = data['hkey']
            type = 'hkey'
        # If PIN is encrypted, it should be decrypted.
        if 'enckey' in data:
            k = cry.decryptRSA(data['enckey'])
            #print k
        if 'pubkey' in data and 'signature' in data:
            pub = data['pubkey']
            sig = data['signature']
            type = 'pubkey'
        if 'phone' in data: p = data['phone']
        if 'email' in data: e = data['email']

        st = '@%s DATA #name %s #msg ' % (self.server, n)
        if cmd == 'PUT':
            if type == 'pubkey':
                if cry.verifySign(pub, sig, n):
                    status = usr.putUser(n, p, e, pub, type)
                else:
                    status = False
            else:
                status = usr.putUser(n, p, e, k, type)

            if status:
                st += 'UserCreated'
            else:
                st += 'UserCreationFailed'
        else:
            status = usr.delUser(n, p, k, pub)
            if status:
                st += 'UserDeleted'
            else:
                st += 'UserDeletionFailed'

        self.sendMessage(st, False)
コード例 #28
0
ファイル: myServer.py プロジェクト: iot-senz/payz-switch
    def removeUser(self, sender, pubkey, address):
        global database
        global serverName

        usr = myUser(database, serverName)
        cry = myCrypto(serverName)
        status = usr.delUser(sender, pubkey)
        st = "DATA #msg "
        if status:
            st += 'UserRemoved'
        else:
            st += 'UserCannotRemoved'
        senze = cry.signSENZE(st)
        self.transport.write(senze, address)
コード例 #29
0
ファイル: myServer.py プロジェクト: iot-senz/senz-switch
    def datagramReceived(self, datagram, address):
        global serverName
        global database

        logger.info('senz received:  %s' % datagram)
        print datagram
        senz = SenZ(datagram)

        validQuery = False
        cry = myCrypto(serverName)
        senderDB = myUser(database,senz.sender)
        pubkey = senderDB.loadPublicKey()

        if senz.command == "SHARE" and "pubkey" in senz.sensors and serverName in senz.recipients:
            #Create a new account
            self.createUser(senz,address)
            validQuery = True

        elif senz.command == "UNSHARE" and "pubkey" in senz.sensors and\
                serverName in senz.recipients:
            #Remove the account
            if pubkey != "":
                if cry.verifySENZE(senz,pubkey):
                    status = self.removeUser(senz.sender, pubkey, address)
            validQuery = True

        else:
            if pubkey != "":
                if cry.verifySENZE(senz, pubkey):
                    validQuery = True

        if validQuery:
            connections[senz.sender] = address
            connectionsTime[senz.sender] = time.time()
            if senz.command == "SHARE":
                self.shareSensors(senz)
            elif senz.command == "UNSHARE":
                self.unshareSensors(senz)
            elif senz.command == "GET":
                self.GETSenze(senz)
            elif senz.command == "PUT":
                self.PUTSenze(senz)
            elif senz.command == "DATA":
                self.DATASenze(senz)

        else:
            senze = "DATA #msg SignatureVerificationFailed"
            senze = cry.signSENZE(senze)
            self.transport.write(senze, address)
コード例 #30
0
    def datagramReceived(self, datagram, address):
        global serverName
        global database

        logger.info('senz received:  %s' % datagram)
        print datagram
        senz = SenZ(datagram)

        validQuery = False
        cry = myCrypto(serverName)
        senderDB = myUser(database, senz.sender)
        pubkey = senderDB.loadPublicKey()

        if senz.command == "SHARE" and "pubkey" in senz.sensors and serverName in senz.recipients:
            #Create a new account
            self.createUser(senz, address)
            validQuery = True

        elif senz.command == "UNSHARE" and "pubkey" in senz.sensors and\
                serverName in senz.recipients:
            #Remove the account
            if pubkey != "":
                if cry.verifySENZE(senz, pubkey):
                    status = self.removeUser(senz.sender, pubkey, address)
            validQuery = True

        else:
            if pubkey != "":
                if cry.verifySENZE(senz, pubkey):
                    validQuery = True

        if validQuery:
            connections[senz.sender] = address
            connectionsTime[senz.sender] = time.time()
            if senz.command == "SHARE":
                self.shareSensors(senz)
            elif senz.command == "UNSHARE":
                self.unshareSensors(senz)
            elif senz.command == "GET":
                self.GETSenze(senz)
            elif senz.command == "PUT":
                self.PUTSenze(senz)
            elif senz.command == "DATA":
                self.DATASenze(senz)

        else:
            senze = "DATA #msg SignatureVerificationFailed"
            senze = cry.signSENZE(senze)
            self.transport.write(senze, address)
コード例 #31
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
   def handle_PUT_MySensors(self,cmd,recipients,sensors,data,reply):
       status=False
       usr=myUser(self.usrDB,self.user)
       cry=myCrypto(self.server)
       type='skey'
    
       n=''; k=''; p='';pub='';sig='';e=''
       if 'name' in data: n= data['name']
       if 'skey' in data: k= data['skey']
       if 'hkey' in data:
           k= data['hkey']
           type='hkey'
       # If PIN is encrypted, it should be decrypted.
       if 'enckey' in data:
           k= cry.decryptRSA(data['enckey'])
           #print k
       if 'pubkey' in data and 'signature' in data:
           pub=data['pubkey']
           sig=data['signature']
           type='pubkey'
       if 'phone' in data: p= data['phone']
       if 'email' in data: e= data['email']
     
       st='@%s DATA #name %s #msg ' %(self.server,n)
       if cmd=='PUT':
          if type=='pubkey':
              if cry.verifySign(pub,sig,n):
                 status=usr.putUser(n,p,e,pub,type)
              else:
                  status=False                
          else:
              status=usr.putUser(n,p,e,k,type)
          
          if status:
             st+='UserCreated'
          else:
             st+='UserCreationFailed'
       else:
          status=usr.delUser(n,p,k,pub)
          if status:
             st+='UserDeleted'
          else:
             st+='UserDeletionFailed'

       self.sendMessage(st,False)
コード例 #32
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
   def handle_DATA(self,recipients,sensors,reply):
       global connections
       failed_recipients=[]
       ''' 
       print "R->",recipients
       print "Reply->",reply
       '''
       for recipient in recipients:
         if self.isConnected(recipient):
            rep=myUser(self.usrDB,recipient) 
            if rep.isAllow(self.user,sensors):
                connections[recipient].sendMessage("@"+self.user+reply,False)
            else:failed_recipients.append(recipient)
         else:failed_recipients.append(recipient)

       response='@%s DATA #msg ' %(self.server)
       if len(failed_recipients)==0:
          self.sendMessage(response+"DATASendDone",False)
       else:
          self.sendMessage(response+"DATASendFailed:"+str(failed_recipients),False)
コード例 #33
0
ファイル: myServer.py プロジェクト: sumedhe/senze
    def createUser(self, query, address):
        global database
        global serverName
        global serverPubkey

        usr = myUser(database, serverName)
        cry = myCrypto(serverName)
        data = query.getData()
        pubkey = ''
        phone = ''
        if 'pubkey' in data: pubkey = data['pubkey']
        if 'phone' in data: phone = data['phone']
        if cry.verifySENZE(query, pubkey):
            status = usr.addUser(query.getSender(), phone, query.getSENZE(),
                                 pubkey, query.getSignature())
        if status:
            st = 'DATA #msg UserCreated #pubkey %s ' % (serverPubkey)
        else:
            st = 'DATA #msg UserCreationFailed'
        senze = cry.signSENZE(st)
        self.transport.write(senze, address)
コード例 #34
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
 def handle_GET_PublicKey(self,recipients,reply):
     
     for recipient in recipients:
         #If public key of the server     
         if self.server in recipient:
            if publicKey!='':
               response='@%s DATA #pubkey %s' %(self.server,self.publicKey)
               self.sendMessage(response,False)
            else:
               response='@%s DATA #msg PublickeyNotFound' %(self.server)
               self.sendMessage(response,False)
         else:
            #Since mysensors already has public key of it clients,
            #it responses on behalf of the client.
            rep=myUser(self.usrDB,recipient) 
            pub=rep.loadPublicKey()
            if pub!='' :
               response='@%s DATA #pubkey %s' %(recipient,pub)
               self.sendMessage(response,False)
            else:
               response='@%s DATA #msg PublickeyNotFound' %(recipient)
               self.sendMessage(response,False)
コード例 #35
0
    def handle_GET(self, recipients, sensors, reply):
        global connections
        failed_recipients = []
        """
       print "R->",recipients
       print "Reply->",reply
       print "S->",sensors
       """

        #If GET addresses to the mysensors
        if self.server in recipients:
            if 'pubkey' in sensors:
                cry = myCrypto(self.server)
                publicKey = cry.loadRSAPubKey()
                st = '@%s DATA #pubkey %s' % (self.server, publicKey)
                self.sendMessage(st, False)

        #Otherwise GET message will forward to the recipients
        else:
            for recipient in recipients:
                if self.isConnected(recipient):
                    rep = myUser(self.usrDB, recipient)
                    if rep.isShare(self.user, sensors):
                        connections[recipient].sendMessage(
                            "@" + self.user + reply, False)
                    else:
                        failed_recipients.append(recipient)
                else:
                    failed_recipients.append(recipient)

            st = '@%s DATA #msg ' % (self.server)
            if len(failed_recipients) == 0:
                self.sendMessage(st + "GETSendDone", False)
            else:
                self.sendMessage(
                    st + "GETSendFailed:" + str(failed_recipients), False)
コード例 #36
0
    def handle_GET_PublicKey(self, recipients, reply):

        for recipient in recipients:
            #If public key of the server
            if self.server in recipient:
                if publicKey != '':
                    response = '@%s DATA #pubkey %s' % (self.server,
                                                        self.publicKey)
                    self.sendMessage(response, False)
                else:
                    response = '@%s DATA #msg PublickeyNotFound' % (
                        self.server)
                    self.sendMessage(response, False)
            else:
                #Since mysensors already has public key of it clients,
                #it responses on behalf of the client.
                rep = myUser(self.usrDB, recipient)
                pub = rep.loadPublicKey()
                if pub != '':
                    response = '@%s DATA #pubkey %s' % (recipient, pub)
                    self.sendMessage(response, False)
                else:
                    response = '@%s DATA #msg PublickeyNotFound' % (recipient)
                    self.sendMessage(response, False)
コード例 #37
0
    def handle_DATA(self, recipients, sensors, reply):
        global connections
        failed_recipients = []
        ''' 
       print "R->",recipients
       print "Reply->",reply
       '''
        for recipient in recipients:
            if self.isConnected(recipient):
                rep = myUser(self.usrDB, recipient)
                if rep.isAllow(self.user, sensors):
                    connections[recipient].sendMessage("@" + self.user + reply,
                                                       False)
                else:
                    failed_recipients.append(recipient)
            else:
                failed_recipients.append(recipient)

        response = '@%s DATA #msg ' % (self.server)
        if len(failed_recipients) == 0:
            self.sendMessage(response + "DATASendDone", False)
        else:
            self.sendMessage(
                response + "DATASendFailed:" + str(failed_recipients), False)
コード例 #38
0
def loadStats(fileName, userList):
    try:
        file = open(fileName, "r")
    except:
        print("Error opening" + str(fileName))

    while True:
        id = file.readline().strip('\n')
        if (id == ""
            ):  #if it reads in an empty line, it has reached end of file
            return
        name = file.readline().strip('\n')
        totalMessages = int(file.readline().strip('\n'))
        totalWords = int(file.readline().strip('\n'))
        totalLetters = int(file.readline().strip('\n'))
        wordsPerMessage = float(file.readline().strip('\n'))
        lettersPerWord = float(file.readline().strip('\n'))
        upvotesGiven = int(file.readline().strip('\n'))
        downvotesGiven = int(file.readline().strip('\n'))
        karma = int(file.readline().strip('\n'))

        userList.append(myUser(id,name,totalMessages,totalWords,totalLetters,\
        wordsPerMessage,lettersPerWord,upvotesGiven,downvotesGiven,karma))
    file.close()
コード例 #39
0
ファイル: mySensorServer.py プロジェクト: digideskio/senze
   def handle_LOGIN(self,data):
       print data
       global connections
       global deletedConnections
       """
        This method handles login process of each user.
        At present user connection socket id is stored in 'connections'.
        Finally we create a DATA Senze and send it to corresponding user, DATA
        Senze contains Login success/fail status.
        We authenticate users by using a PIN number or a digital signature.
       """
       name=''; pin='';sig=''
       if 'name' in data: name= data['name']
       if 'skey' in data: pin= data['skey']
       if 'hkey' in data: pin= data['hkey']
      
       # If PIN is encrypted, it should be decrypted.
       if 'enckey' in data:
           cry=myCrypto(self.server)
           pin= cry.decryptRSA(data['enckey'])
           #print pin
       # If hkey is given, #sec-websocket-key is taken as the session key.
       elif 'hkey' in data:
           #sec-websocket-key is used as the session key
           sig=self.key
           pin=data['hkey']
           #print pin
       # Signature is available, the user authentication is based on digital signature.
       elif 'signature' in data: 
           sig=data['signature']
           #sec-websocket-key is used as the pin
           pin=self.key

       usr=myUser(self.usrDB,name)
       replyMsg="@"+self.server+" DATA #name "+name
       
       #Verify the user by using a PIN or signature
       if usr.login(pin,sig,self.server): 
           # We need to check user alredy have a connection 
           if self.isConnected(name):
             #Let's close it
             deletedConnections[name]=connections[name]
             connections[name].sendClose()
        
           # Set the connected name
           self.user=name
           # Adding websocket connection to connection pool
           connections[self.user]=self
           
           self.myState="READY"
           replyMsg+=" #msg LoginSUCCESS"
           self.sendMessage(replyMsg,False)
           
           #In order to keep the live  connection, the server will send a ping after 5m
           #After that the server will send a ping every 10m (See onPong message)  
           self.factory.reactor.callLater(self.pingingIntervel,self.sendPingMessage)
           self.factory.reactor.callLater(self.pingingIntervel*2,self.sendPingMessage)
       
       
       #If login failed, let's inform it
       if self.myState=="INITIAL":
          replyMsg+=" #msg LoginFAILED"
          self.sendMessage(replyMsg,False)
コード例 #40
0
    def handle_LOGIN(self, data):
        print data
        global connections
        global deletedConnections
        """
        This method handles login process of each user.
        At present user connection socket id is stored in 'connections'.
        Finally we create a DATA Senze and send it to corresponding user, DATA
        Senze contains Login success/fail status.
        We authenticate users by using a PIN number or a digital signature.
       """
        name = ''
        pin = ''
        sig = ''
        if 'name' in data: name = data['name']
        if 'skey' in data: pin = data['skey']
        if 'hkey' in data: pin = data['hkey']

        # If PIN is encrypted, it should be decrypted.
        if 'enckey' in data:
            cry = myCrypto(self.server)
            pin = cry.decryptRSA(data['enckey'])
            #print pin
        # If hkey is given, #sec-websocket-key is taken as the session key.
        elif 'hkey' in data:
            #sec-websocket-key is used as the session key
            sig = self.key
            pin = data['hkey']
            #print pin
        # Signature is available, the user authentication is based on digital signature.
        elif 'signature' in data:
            sig = data['signature']
            #sec-websocket-key is used as the pin
            pin = self.key

        usr = myUser(self.usrDB, name)
        replyMsg = "@" + self.server + " DATA #name " + name

        #Verify the user by using a PIN or signature
        if usr.login(pin, sig, self.server):
            # We need to check user alredy have a connection
            if self.isConnected(name):
                #Let's close it
                deletedConnections[name] = connections[name]
                connections[name].sendClose()

            # Set the connected name
            self.user = name
            # Adding websocket connection to connection pool
            connections[self.user] = self

            self.myState = "READY"
            replyMsg += " #msg LoginSUCCESS"
            self.sendMessage(replyMsg, False)

            #In order to keep the live  connection, the server will send a ping after 5m
            #After that the server will send a ping every 10m (See onPong message)
            self.factory.reactor.callLater(self.pingingIntervel,
                                           self.sendPingMessage)
            self.factory.reactor.callLater(self.pingingIntervel * 2,
                                           self.sendPingMessage)

        #If login failed, let's inform it
        if self.myState == "INITIAL":
            replyMsg += " #msg LoginFAILED"
            self.sendMessage(replyMsg, False)
コード例 #41
0
    def handle_GET_MySensors(self, recipients, sensors, data, reply):

        usr = myUser(self.usrDB, self.user)
        #Check the given user is online or offline
        #GET #name kasun @mysensors -> @mysenosrs DATA #name kasun ONLINE/OFFLINE
        if 'name' in sensors:
            if 'name' in data.keys():
                if self.isConnected(data['name']):
                    response = '@%s DATA #name %s #msg ONLINE' % (self.server,
                                                                  data['name'])
                else:
                    response = '@%s DATA #name %s #msg OFFLINE' % (
                        self.server, data['name'])
            else:
                response = '@%s DATA #name #msg UnKnown' % (self.server)
        #Return the list of friends who shared the given sensor with me
        #GET #friends #shared tp @mysensors -> @mysenosrs DATA #friends kasun,nimal #shared tp
        elif 'friends' in sensors:
            if 'shared' in data.keys():
                rep = usr.loadFriends(data['shared'])
                response = '@%s DATA #friends %s #shared %s' % (
                    self.server, rep, data['shared'])
            else:
                #Return the list of friends who registered with the server
                #GET #friends kasun,d1,nimal -> @mysenosrs DATA #friends kasun,nimal
                if 'friends' in data.keys():
                    rep = usr.findUsers(data['friends'])
                    response = '@%s DATA #friends %s' % (self.server, rep)
                else:
                    response = '@%s DATA #sensor #msg UnKnown' % (self.server)
        #Return the list of friends where I shared the given sensor
        #GET #shared tp @mysensors -> @mysenosrs DATA #shared tp #friends kasun,nimal
        elif 'shared' in sensors:
            if 'shared' in data.keys():
                rep = usr.loadData(data['shared'])
                response = '@%s DATA #shared %s #friends %s' % (
                    self.server, data['shared'], rep)
            else:
                response = '@%s DATA #sensor #msg UnKnown' % (self.server)

        #Return the list of sensors shared by the given friend
        #GET #friend nimal @mysensors -> @mysenosrs DATA #friend nimal #shared gps,tp
        elif 'friend' in sensors:
            if 'friend' in data.keys():
                rep = usr.loadData(data['friend'])
                response = '@%s DATA #friend %s #shared %s' % (
                    self.server, data['friend'], rep)
            else:
                #Need to return name of friends who shared sensor here
                response = '@%s DATA #friend #msg UnKnown' % (self.server)
        #Return the number of connections at the given time
        #GET #connections @mysensors -> @mysenosrs DATA #connections 5
        elif 'connections' in sensors:
            num = str(factory.getConnectionCount())
            response = '@%s DATA #connections %s' % (self.server, num)
        #Return the number of users at the given time
        #GET #users @mysensors -> @mysenosrs DATA #users 1000
        elif 'users' in sensors:
            num = str(usr.countDocs())
            response = '@%s DATA #users %s' % (self.server, num)
        else:
            response = '@%s DATA #msg UnsupportedSenzeType' % (self.server)
        self.sendMessage(response, False)