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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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)
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()
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)
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)
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)