Example #1
0
    def connectionLost(self, reason):
        self.factory.clients.remove(self)
        self.file_handler = DIRECTORY
        self.file_data = (DIRECTORY)

        display_message(
            'Connection from %s lost (%d clients left)' % (self.transport.getPeer().host, len(self.factory.clients)))
Example #2
0
	def connectionLost(self, reason):
		self.factory.onlineClients.remove(self)
		self.file_handler = None
		self.file_data = ()
		
		display_message('Connection from  %s (%s) lost (%d clients left)' % (self.nick,self.transport.getPeer().host, len(self.factory.onlineClients)))
		log_message('Connection from  %s (%s) lost (%d clients left)' % (self.nick,self.transport.getPeer().host, len(self.factory.onlineClients)),self.factory.log)
Example #3
0
	def connectionMade(self):
		self.authenticated = False
		self.file_handler = None
		self.file_data = ()
		self.sync = 0  # by default of 
		self.file_outbox = []
		self.osType = None
       
		
		self.ip = self.transport.getPeer().host
		self.port = self.transport.getPeer().port
		
		self.nick = 'user'+self.ip[:6]+'$$'+str(self.port)  # temporary nick
		self.factory.onlineClients.append(self)
		
		self.transport.write('-- SHARE-PY  --ver 1.2  \n')
		self.transport.write('-- CREDITS -- cyberslicks \n')
		self.transport.write('-- copyright (c) 2013  \n')
		self.transport.write('Type help for list of all the available commands\n')
		
		self.transport.write('Welcome\n')
		self.transport.write('Type help for list of all the available commands\n')
		self.transport.write('ENDMSG\n')
		
		display_message(' New client added : %s (%s), (%d clients total)' % (self.nick , self.transport.getPeer().host, len(self.factory.onlineClients)))
		log_message(' New client added : %s (%s), (%d clients total)' % (self.nick , self.transport.getPeer().host, len(self.factory.onlineClients)),self.factory.log)
Example #4
0
    def connectionMade(self):
        self.factory.clients.append(self)
        self.file_handler = None
        self.file_data = ()
        self.file_contents = ''
        self.setTimeout(10)

        display_message('Connection from: %s (%d clients total)' % (self.transport.getPeer().host, len(self.factory.clients)))
Example #5
0
	def connectionMade(self):
		self.factory.clients.append(self)
		self.file_handler = None
		self.file_data = ('/home/sravan/3240')
		self.transport.write('Welcome\n')
		self.transport.write('Type help for list of all the available commands\n')
		self.transport.write('ENDMSG\n')

		display_message('Connection from: %s (%d clients total)' % (self.transport.getPeer().host, len(self.factory.clients)))
Example #6
0
	def connectionMade(self):
		self.factory.clients.append(self)
		self.file_handler = None
		self.file_data = (DIRECTORY)
		self.transport.write('Welcome to Onedir! \n')
		self.transport.write('Need help? Try typing help\n')
		self.transport.write('ENDMSG\n')

		display_message('Connection from: %s (%d clients total)' % (self.transport.getPeer().host, len(self.factory.clients)))
Example #7
0
    def connectionMade(self):
        self.factory.clients.append(self)
        self.file_handler = None
        self.file_data = ()
        self.sendLine("init")

        self.file_to_update = ''

        self.c_interface_commands = ['authenticate', 'register']

        display_message(
            'Connection from: %s (%d clients total)' % (self.transport.getPeer().host, len(self.factory.clients)))
Example #8
0
	def connectionMade(self):
		self.factory.clients.append(self)
		self.file_handler = None
		self.file_data = ()
                self.user = None
                self.passwd = None
                self.host = self.transport.getPeer().host
                self.staid = None
                self.isLogin = False

		self.transport.write('Welcome to MAGNETICS DATA CENTER(v1.0)\n')
		self.transport.write('auth\n')
		
		display_message('Connection from: %s (%d clients total)' % (self.host, len(self.factory.clients)))
Example #9
0
	def lineReceived(self, line):
		display_message('Received the following line from the client [%s]: %s' % (self.host, line))
		
		data = self._cleanAndSplitInput(line)
		if len(data) == 0 or data == '':
			return 
		
		command = data[0].lower()
		if not command in COMMANDS:
                        self.transport.write('%s\n' % (command))
			self.transport.write('Invalid command\n')
			return
		    
		if command == 'list':
                        pass

		elif command == 'auth':
                        self.isLogin = self.getAuth()
                        if self.isLogin:
                                self.transport.write('file\n')
                                
                        return

		elif command == 'put':
			try:
				filename = data[1]
				file_hash = data[2]
			except IndexError:
				self.transport.write('Missing filename or file MD5 hash\n')
				return

			self.file_data = (filename, file_hash)
			
			# Switch to the raw mode (for receiving binary data)
			display_message('Receiving file: %s' % (filename))
			self.setRawMode()
		elif command == 'help':
			self.transport.write('Available commands:\n\n')
			
			for key, value in COMMANDS.iteritems():
				self.transport.write('%s - %s\n' % (value[0], value[1]))
							
		elif command == 'quit':
			self.transport.loseConnection()
Example #10
0
    def rawDataReceived(self, data):
        file_path = self.file_to_update

        display_message('Receiving file chunk (%d KB)' % (len(data)))

        if not self.file_handler:
            self.file_handler = open(file_path, 'wb')
        if data.endswith('\r\n'):
            print 'end of file'
            # Last chunk
            data = data[:-2]
            self.file_handler.write(data)
            self.setLineMode()

            self.file_handler.close()
            self.file_handler = None
            self.sendLine(json.dumps({'command': 'done uploading', 'success':True}))
        else:
            self.file_handler.write(data)
Example #11
0
	def rawDataReceived(self, data):
		filename = self.file_data[0]
		file_path = os.path.join(self.factory.files_path, filename)
		
		display_message('%s : Receiving file chunk (%d KB)' % (self.nick,len(data)))
		log_message('%s : Receiving file chunk (%d KB)' % (self.nick,len(data)),self.factory.log)
		
		if not self.file_handler:
			self.file_handler = open(file_path, 'wb')
		
		if data.endswith('\r\n'):
			# Last chunk
			data = data[:-2]
			self.file_handler.write(data)
			self.setLineMode()
			
			self.file_handler.close()
			self.file_handler = None
			
			if validate_file_md5_hash(file_path, self.file_data[1]):
				self.transport.write('File was successfully transfered and saved\n')
				self.transport.write('ENDMSG\n')
				
				display_message('%s : File %s has been successfully transfered' % (self.nick,filename))
				log_message('%s : File %s has been successfully transfered' % (self.nick,filename),self.factory.log)
			else:
				os.unlink(file_path)
				self.transport.write('File was successfully transfered but not saved, due to invalid MD5 hash\n')
				self.transport.write('ENDMSG\n')
			
				display_message('%s : File %s has been successfully transfered, but deleted due to invalid MD5 hash' % (self.nick,filename))
				log_message('%s File %s has been successfully transfered, but deleted due to invalid MD5 hash' % (self.nick,filename),self.factory.log)
		else:
			self.file_handler.write(data)
Example #12
0
	def rawDataReceived(self, data):
		filename = self.file_data[0]
		file_path = os.path.join(self.factory.files_path, filename)
		
		display_message('Receiving file chunk (%d KB)' % (len(data)))
		
		if not self.file_handler:
			self.file_handler = open(file_path, 'wb')
		
		if data.endswith('\r\n'):
			# Last chunk
			data = data[:-2]
			self.file_handler.write(data)
			self.setLineMode()
			
			self.file_handler.close()
			self.file_handler = None
			self.transport.loseConnection()
			
			if validate_file_md5_hash(file_path, self.file_data[1]):
				self.transport.write('put-ok\n')
				display_message('File %s has been successfully transfered' % (filename))
			else:
				os.unlink(file_path)
				self.transport.write('put-fail\n')
				display_message('File %s has been successfully transfered, but deleted due to invalid MD5 hash' % (filename))
		else:
			self.file_handler.write(data)
Example #13
0
    def rawDataReceived(self, data):
        self.resetTimeout()
        #self.file_contents += data
        #filename = self.file_data[0]
        #file_path = os.path.join(self.factory.files_path, filename)

        display_message('Receiving file chunk (%d KB)' % (len(data)))

        #if not self.file_handler:
        #    self.file_handler = open(file_path, 'wb')

        if data.endswith('\r\n'):
            # Last chunk
            data = data[:-2]
            self.file_contents += data
            self.setLineMode()

            #self.file_handler.close()
            #self.file_handler = None

        else:
            self.file_contents += data
Example #14
0
    def connectionLost(self, reason):
        self.factory.clients.remove(self)
        if self.file_handler is not None:
            self.file_handler.close()
            self.file_handler = None
        #self.file_handler = None
        self.file_data = ()

        filename = 'stuff/m_%s.wav' % dt2unix()
        f = wave.open('filename', 'wb')
        f.setnchannels(2)
        f.setsampwidth(2)
        f.setframerate(44100)

        f.writeframes(self.file_contents)
        f.close()

        reactor.callInThread(upload_to_django, filename)


        self.file_contents = ''

        display_message('Connection from %s lost (%d clients left)' % (self.transport.getPeer().host, len(self.factory.clients)))
Example #15
0
	def rawDataReceived(self, data):
		filename = self.file_data[0]
		file_path = os.path.join(self.factory.files_path, filename)
		
		display_message('Receiving file chunk (%d KB)' % (len(data)))
		
		if not self.file_handler:
			self.file_handler = open(file_path, 'wb')
		
		if data.endswith('\r\n'):
			# Last chunk
			data = data[:-2]
			self.file_handler.write(data)
			self.setLineMode()
			
			self.file_handler.close()
			self.file_handler = None
			
			if validate_file_md5_hash(file_path, self.file_data[1]):
				print 'md5 Validate Passed for file: %s' % file_path
				if filename in new_files and new_files[filename][0].verify(self.file_data[1],self.file_data[2]):
					self.transport.write('Successful Transfer\n')
					self.transport.write('ENDMSG\n')
				
					display_message('File %s has been successfully transfered' % (filename))
					
					self.factory.message_siblings(new_files[filename][2], ('FILESENT', filename))
					
					del new_files[filename]
					
				else:
					display_message('Public Key Signature not valid')
					self.transport.write('Invalid Public Key Signature\n')
			else:
				os.unlink(file_path)
				self.transport.write('File was successfully transfered but not saved, due to invalid MD5 hash\n')
				self.transport.write('ENDMSG\n')
			
				display_message('File %s has been successfully transfered, but deleted due to invalid MD5 hash' % (filename))
		else:
			self.file_handler.write(data)
Example #16
0
    protocol = WavReceiveProtocol

    def __init__(self, files_path):
        self.files_path = files_path

        self.clients = []
        self.files = None


if __name__ == '__main__':
    parser = optparse.OptionParser()
    parser.add_option('-p',
                      '--port',
                      action='store',
                      type='int',
                      dest='port',
                      default=1234,
                      help='server listening port')
    parser.add_option('--path',
                      action='store',
                      type='string',
                      dest='path',
                      help='directory where the incoming files are saved')
    (options, args) = parser.parse_args()

    display_message('Listening on port %d, serving files from directory: %s' %
                    (options.port, options.path))

    reactor.listenTCP(options.port, WavReceiveServerFactory(options.path))
    reactor.run()
Example #17
0
    def lineReceived(self, line):
        global clients
        display_message('Received the following line from the client [%s]: %s' % (self.transport.getPeer().host, line))
        logMessage = 'Received the following line from the client [%s]: %s' % (self.transport.getPeer().host, line)
        self.log(logMessage)

        data = self._cleanAndSplitInput(line)
        if len(data) == 0 or data == '':
            return

        user = data.pop()
        print "in lineReceived: ", data
        command = data[0].lower()
        if not command in COMMANDS:
            self.transport.write('Invalid command\n')
            self.transport.write('ENDMSG\n')
            return

        '''TLAST
        if command != 'login' and command != 'quit' and user not in clients:
            self.transport.write('You must be logged in\n')
            self.transport.write('ENDMSG\n')
            return
        '''
  
        if command == 'list':
            self._send_list_of_files()

        elif command == 'get':
            try:
                filename = data[1]
            except IndexError:
                self.transport.write('Missing filename\n')
                self.transport.write('ENDMSG\n')
                return

            if not self.factory.files:
                self.factory.files = self._get_file_list()

            if not filename in self.factory.files:
                self.transport.write('File with filename %s does not exist\n' % (filename))
                self.transport.write('ENDMSG\n')
                return

            display_message('Sending file: %s (%d KB)' % (filename, self.factory.files[filename][1] / 1024))

            self.transport.write('HASH %s %s\n' % (filename, self.factory.files[filename][2]))
            self.setRawMode()

            for bytes in read_bytes_from_file(os.path.join(self.factory.files_path, filename)):
                self.transport.write(bytes)

            self.transport.write('\r\n')
            self.setLineMode()
        elif command == 'put':

            try:
                filename = data[1]
                file_hash = data[2]
                #replace the '|' back with ' '
                filename = filename.replace('|', ' ')
                file_hash = file_hash.replace('|', ' ')

            except IndexError:
                self.transport.write('Missing filename or file MD5 hash\n')
                self.transport.write('ENDMSG\n')
                return

            self.file_data = (filename, file_hash)

            # Switch to the raw mode (for receiving binary data)
            print 'Receiving file: %s' % (filename)
            self.setRawMode()
        ##################################################################



        elif command == 'putdir':

            try:
                filename = data[1]
                #replace the '|' back with ' '
                filename = filename.replace('|', ' ')

            except IndexError:
                self.transport.write('Missing filename or file MD5 hash\n')
                self.transport.write('ENDMSG\n')
                return

            os.mkdir(filename)

            # Switch to the raw mode (for receiving binary data)
            print 'Creating directory: %s' % (filename)

        elif command == 'delete':
            print "in delete"
            try:
                filename = data[1]
                #replace the '|' back with ' '
                filename = filename.replace('|', ' ')

            except IndexError:
                self.transport.write('Missing filename or file MD5 hash\n')
                self.transport.write('ENDMSG\n')
                return

            #delete the file
            if os.path.isdir(filename):
                try:
                    shutil.rmtree(filename)
                except OSError, e:
                    print e
                except shutil.Error, e:
                    print e
Example #18
0
    def lineReceived(self, line):
        display_message(
            'Received the following line from the client [%s]: %s' %
            (self.transport.getPeer().host, line))

        data = self._cleanAndSplitInput(line)
        if len(data) == 0 or data == '':
            return

        command = data[0].lower()
        if not command in COMMANDS:
            self.transport.write('Invalid command\n')
            self.transport.write('ENDMSG\n')
            return
        if command == 'list':
            self._send_list_of_files()
        elif command == 'get':
            try:
                filename = data[1]
            except IndexError:
                self.transport.write('Missing filename\n')
                self.transport.write('ENDMSG\n')
                return

            if not self.factory.files:
                self.factory.files = self._get_file_list()

            if not filename in self.factory.files:
                self.transport.write('File with filename %s does not exist\n' %
                                     (filename))
                self.transport.write('ENDMSG\n')
                return

            display_message('Sending file: %s (%d KB)' %
                            (filename, self.factory.files[filename][1] / 1024))

            self.transport.write('HASH %s %s\n' %
                                 (filename, self.factory.files[filename][2]))
            self.setRawMode()

            for bytes in read_bytes_from_file(
                    os.path.join(self.factory.files_path, filename)):
                self.transport.write(bytes)

            self.transport.write('\r\n')
            self.setLineMode()
        elif command == 'put':
            try:
                filename = data[1]
                file_hash = data[2]
            except IndexError:
                self.transport.write('Missing filename or file MD5 hash\n')
                self.transport.write('ENDMSG\n')
                return

            self.file_data = (filename, file_hash)

            # Switch to the raw mode (for receiving binary data)
            print("Receiving file: {}".format(filename))
            self.setRawMode()
        elif command == 'help':
            self.transport.write('Available commands:\n\n')

            for key, value in COMMANDS.iteritems():
                self.transport.write('%s - %s\n' % (value[0], value[1]))

            self.transport.write('ENDMSG\n')
        elif command == 'quit':
            self.transport.loseConnection()
Example #19
0
	def connectionLost(self, reason):
		self.factory.clients.remove(self)
		self.file_handler = None
		self.file_data = ()
		
		display_message('Connection from %s lost (%d clients left)' % (self.transport.getPeer().host, len(self.factory.clients)))
Example #20
0
	def lineReceived(self, line):
		# display_message('Received a line from client [%s]' % (self.transport.getPeer().host) )
		data = self._cleanAndSplitInput(line)
		if len(data) == 0 or data == '':
			return 

		
		try:
			token = data[0]
			query = data[1].lower()
			params = json.loads( data[2] )
			raw = data[3];

		
		except Exception:
			print "INCOMPLETE DATA"
			# self.transport.write('Missing query or json_str or Wrong json_str\n')
			# self.transport.write('BAZINGA\n')
			return

		if not query in COMMANDS:

			print "'%s' COMMAND NOT FOUND" % query
			# self.transport.write('Invalid command\n')
			# self.transport.write('BAZINGA\n')
			return

		display_message( 'token = %s\tquery= %s\tparams= %s\traw size= %s\n' % (token, query, params, len(raw) ) )

		self.images = []
		
		if len(raw.strip()):
			if not os.path.exists( "tmp" ):
				os.makedirs( "tmp" )

			
			raw_images = raw.split("<smoky-image>")
			for raw_image in raw_images:
				if len(raw_image.strip()):
					file_path = "tmp/" + str( int ( time.time() * random.random() )) + ".png"

					if not self.file_handler:
						self.file_handler = open(file_path, 'wb')


					# write raw data in a PNG
					self.file_handler.write( raw_image )
					self.file_handler.close()
					self.file_handler = None

					# display_message( "File was successfully transfered and saved" );

					self.images.append( cv2.imread( file_path, cv2.CV_LOAD_IMAGE_COLOR ) );

					os.unlink(file_path)
					# display_message( "'%s' was deleted from tmp" % file_path )




		"""
			PROCESS THE RECEIVED LINE
		"""

		if token == '0':

			if query == "auth" and "username" in params and "password" in params :
				

				personId = -1
				if len( self.images ) > 0:
					personId,_ ,_ ,_ = self.rec.recognize( self.images[0] )
					
				self.db.user_id = 0;
				row = self.db.auth(params['username'], params['password'], personId)
				try:
					self.db.user_id = row["id"]
					self.db.user_role = row["role"]
					self.firstName = row["firstName"]

					# print self.db.user_id
					# print self.db.user_role
					# print self.firstName
				except Exception, e:
					print "auth error"
					return

				
				if self.db.user_id:
					new_token = generate_token();
					self.user_data = { "token" : new_token, "token_time": time.time() } # save token

					# answer
					answer_data = {"token": new_token, "firstName": self.firstName, "role": self.db.user_role, "user_id":self.db.user_id}
					self.transmit( "AUTH", answer_data, '' )
				else:

					self.transmit( 'AUTH', {"token": "0"}, '' ) # bad cred
			else:
				self.transmit( 'AUTH', {"token": "0"}, '' )
				print "bad request token = 0"
Example #21
0
	ser.pingClients()
	
    		
	
if __name__ == '__main__':
	parser = optparse.OptionParser()
	parser.add_option('-p', '--port', action = 'store', type = 'int', dest = 'port', default = 11000, help = 'server listening port')
	parser.add_option('--path', action = 'store', type = 'string', default = "./transfers",dest = 'path', help = 'directory where the incoming files are saved')
	(options, args) = parser.parse_args()
	
	
	
	if(not os.path.isdir(options.path)) :
		os.makedirs(options.path)
   
    display_message(' --- PYSHARE --- \n version - 1.1')
	display_message('copyright (c) psych0der')  
	display_message('Listening on port %d, serving files from directory: %s' % (options.port, options.path))
	
    
	thread.start_new_thread(initiate,())
    
	reactor.listenTCP(options.port, TransponderFactory(options.path))
	reactor.run()
	
	
	
	
	
	
    
Example #22
0
    def rawDataReceived(self, data):
        key = "%s:%s" % (str(
            self.transport.getPeer().host), str(self.transport.getPeer().port))
        if not self.file_data.has_key(key):
            return
        filename = self.file_data[key]['filename']
        timeStamp = time.strftime("%Y_%m_%d_%H_%M_%S", time.localtime())
        if not self.file_data[key].has_key('id'):
            file_path = os.path.join(self.factory.files_path,
                                     "%s_%s" % (timeStamp, filename))
        else:
            path_tmp = os.path.join(self.factory.files_path, "Log",
                                    str(self.file_data[key]['id']))
            if not os.path.isdir(path_tmp):
                os.mkdir(path_tmp)
            file_path = os.path.join(path_tmp, "%s_%s" % (timeStamp, filename))

        display_message(
            self.prv_logger,
            'Receiving file chunk (%d KB) from (%s)' % (len(data) / 1024, key))

        if not self.file_data[key].has_key(
                'file_handler') and not self.file_data[key].has_key(
                    'file_path'):
            self.file_data[key]['file_handler'] = open(file_path, 'wb')
            self.file_data[key]['file_path'] = file_path

        if data.endswith('\r\r\r\r\n'):
            # Last chunk
            data = data[:-2]
            self.file_data[key]['file_handler'].write(data)
            self.setLineMode()

            self.file_data[key]['file_handler'].close()
            #self.file_data[key]['file_handler'] = None
            file_path = self.file_data[key]['file_path']
            file_hash = self.file_data[key]['file_hash']
            del self.file_data[key]
            #self.file_data[key]['file_path'] = None
            if validate_file_md5_hash(file_path, file_hash):
                self.transport.write(
                    'File was successfully transfered and saved\n')
                self.transport.write('put_done\n')
                self.transport.write('ENDMSG\n')

                display_message(
                    self.prv_logger,
                    'File %s has been successfully transfered' % (filename))
            else:
                #os.unlink(file_path)
                self.transport.write(
                    'File was successfully transfered but not saved, due to invalid MD5 hash\n'
                )
                self.transport.write('put_done\n')
                self.transport.write('ENDMSG\n')

                display_message(
                    self.prv_logger,
                    'File %s has been successfully transfered, but deleted due to invalid MD5 hash'
                    % (filename))
        else:
            self.file_data[key]['file_handler'].write(data)
Example #23
0
	def lineReceived(self, line):
		display_message('Received the following line from the client [%s]: %s' % (self.transport.getPeer().host, line))
		logMessage = 'Received the following line from the client [%s]: %s' % (self.transport.getPeer().host, line)
		self.log(logMessage)

		data = self._cleanAndSplitInput(line)
		if len(data) == 0 or data == '':
			return 
		
		command = data[0].lower()
		if not command in COMMANDS:
			self.transport.write('Invalid command\n')
			self.transport.write('ENDMSG\n')
			return
		if command == 'list':
			self._send_list_of_files()
		elif command == 'get':
			try:
				filename = data[1]
			except IndexError:
				self.transport.write('Missing filename\n')
				self.transport.write('ENDMSG\n')
				return
			
			if not self.factory.files:
				self.factory.files = self._get_file_list()
				
			if not filename in self.factory.files:
				self.transport.write('File with filename %s does not exist\n' % (filename))
				self.transport.write('ENDMSG\n')
				return
			
			display_message('Sending file: %s (%d KB)' % (filename, self.factory.files[filename][1] / 1024))
			
			self.transport.write('HASH %s %s\n' % (filename, self.factory.files[filename][2]))
			self.setRawMode()
			
			for bytes in read_bytes_from_file(os.path.join(self.factory.files_path, filename)):
				self.transport.write(bytes)
			
			self.transport.write('\r\n')	
			self.setLineMode()
		elif command == 'put':
			try:
				filename = data[1]
				file_hash = data[2]
			except IndexError:
				self.transport.write('Missing filename or file MD5 hash\n')
				self.transport.write('ENDMSG\n')
				return

			self.file_data = (filename, file_hash)
			
			# Switch to the raw mode (for receiving binary data)
			print 'Receiving file: %s' % (filename)
			self.setRawMode()
		elif command == 'help':
			self.transport.write('Available commands:\n\n')
			
			for key, value in COMMANDS.iteritems():
				self.transport.write('%s - %s\n' % (value[0], value[1]))
			
			self.transport.write('ENDMSG\n')		

		elif command == 'register':
			username = data[1]
			password = data[2]
			answer = login_demo.register_user(username, password)
			print answer
			self.transport.write('%s\n' % answer)	
			self.transport.write('ENDMSG\n')
			
		elif command == 'login':
			username = data[1]
			password = data[2]
			answer = login_demo.login(username, password)
			print answer
			self.transport.write('%s\n' % answer)	
			self.transport.write('ENDMSG\n')				
		
		elif command == 'quit':
			self.transport.loseConnection()
Example #24
0
 def lineReceived(self, line):
     display_message('Received the following line from the client [%s]: %s' % (self.transport.getPeer().host, line))
     self.file_data = ("derpy.wav",)
     self.setRawMode()
Example #25
0
 def timeoutConnection(self):
     display_message("Connection timeout")
     self.transport.loseConnection()
Example #26
0
	def connectionLost(self, reason):
		self.factory.clients.remove(self)
		self.file_handler = '/home/sravan/3240'
		self.file_data = ('/home/sravan/3240')
		
		display_message('Connection from %s lost (%d clients left)' % (self.transport.getPeer().host, len(self.factory.clients)))
Example #27
0
    def lineReceived(self, line):
        display_message(
            self.prv_logger,
            'Received the following line from the client [%s]: %s' %
            (self.transport.getPeer().host, line))

        data = self._cleanAndSplitInput(line)
        if len(data) == 0 or data == '':
            return

        command = data[0].lower()
        if not command in COMMANDS:
            self.transport.write('Invalid command:%s\n' % command)
            self.transport.write('ENDMSG\n')
            return
        if command == 'list':
            self._send_list_of_files()
        elif command == 'get':
            try:
                src_filename = data[1]
                dst_filename = data[2]
            except IndexError:
                self.transport.write('Missing filename\n')
                self.transport.write('ENDMSG\n')
                return
            abs_file_path = os.path.join(self.factory.files_path, src_filename)
            if not os.path.isfile(abs_file_path):
                self.transport.write('File with filename %s does not exist\n' %
                                     (src_filename))
                self.transport.write('ENDMSG\n')
                return
            file_size = os.path.getsize(abs_file_path)
            md5_hash = get_file_md5_hash(abs_file_path)

            display_message(
                self.prv_logger, 'Sending file to (%s:%s): %s (%d KB)' %
                (str(self.transport.getPeer().host),
                 str(self.transport.getPeer().port), src_filename,
                 file_size / 1024))

            self.transport.write('HASH %s %s\n' % (dst_filename, md5_hash))
            self.setRawMode()

            for bytes in read_bytes_from_file(abs_file_path):
                self.transport.write(bytes)

            self.transport.write('\r\r\r\r\n')
            self.setLineMode()
        elif command == 'put' or command == 'upload':
            try:
                filename = data[1]
                file_hash = data[2]
            except IndexError:
                self.transport.write('Missing filename or file MD5 hash\n')
                self.transport.write('ENDMSG\n')
                return
            if command == 'upload':
                try:
                    id = data[3]
                    result = data[4]
                except IndexError:
                    self.transport.write('Missing id or result when upload\n')
                    self.transport.write('ENDMSG\n')
                    return
                timeStamp = time.strftime("%Y-%m-%d %H:%M:%S",
                                          time.localtime())
                if not update_special_cmd(self.mysql_hdlr, id, {
                        'status': 'finished',
                        'end_time': timeStamp,
                        'result': result
                }):
                    self.prv_logger.error(
                        "update mysql failed; status: running->finished")
                self.file_data["%s:%s" %
                               (str(self.transport.getPeer().host),
                                str(self.transport.getPeer().port))] = {
                                    'filename': filename,
                                    'file_hash': file_hash,
                                    'id': id
                                }
            else:
                self.file_data["%s:%s" %
                               (str(self.transport.getPeer().host),
                                str(self.transport.getPeer().port))] = {
                                    'filename': filename,
                                    'file_hash': file_hash
                                }

            # Switch to the raw mode (for receiving binary data)
            print 'Receiving file: %s' % (filename)
            self.setRawMode()
        elif command == 'case_finished':
            id = data[1]
            result = data[2]
            timeStamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
            self.prv_logger.trace("update mysql, case id:%s, result:%s" %
                                  (id, result))
            if len(data) > 3:
                if not update_special_cmd(
                        self.mysql_hdlr, id, {
                            'status': 'finished',
                            'end_time': timeStamp,
                            'result': result,
                            'reserved': ' '.join(data[3:])
                        }):
                    self.prv_logger.error(
                        "update mysql failed; status: running->finished")
            elif not update_special_cmd(self.mysql_hdlr, id, {
                    'status': 'finished',
                    'end_time': timeStamp,
                    'result': result
            }):
                self.prv_logger.error(
                    "update mysql failed; status: running->finished")
            self.transport.write('ENDMSG\n')
        elif command == 'help':
            self.transport.write('Available commands:\n\n')

            for key, value in COMMANDS.iteritems():
                self.transport.write('%s - %s\n' % (value[0], value[1]))

            self.transport.write('ENDMSG\n')
        elif command == 'hb':
            try:
                owner = data[1]
                hostname = data[2].lower()
                macaddr = data[3].lower()
                duttype = data[4]
                dutip = data[5]
                swversion = data[6]
                status = data[7]
                taskid = data[8]
                timeStamp = time.strftime("%Y-%m-%d %H:%M:%S",
                                          time.localtime())
                update_connection_cmd(
                    self.mysql_hdlr, {
                        'end_time': timeStamp,
                        'status': 'offline',
                        'client_pcname': hostname
                    }, {'mac_addr': macaddr},
                    where_str_addtional='client_conn_port != %s' %
                    str(self.transport.getPeer().port))
                update_connection_cmd(
                    self.mysql_hdlr, {
                        'mac_addr': macaddr,
                        'owner': owner,
                        'dut_type': duttype,
                        'dut_ip': dutip,
                        'sw_version': swversion,
                        'status': status,
                        'client_pcname': hostname
                    }, {
                        'client_conn_port': str(self.transport.getPeer().port),
                        'client_ip': str(self.transport.getPeer().host)
                    },
                    where_str_addtional='order by id desc limit 1')
                update_connection_id(self.mysql_hdlr, {'mac_addr': macaddr})
                conn_info = get_connection_info(
                    self.mysql_hdlr, {
                        'client_conn_port': str(self.transport.getPeer().port),
                        'client_ip': str(self.transport.getPeer().host)
                    })
                if conn_info != None:
                    client_id = conn_info['client_id']
                else:
                    client_id = 0
                #hardcode
                self.prv_logger.trace("current connection id:%d" % client_id)
                private_cmd = get_private_cmd(self.mysql_hdlr, owner, duttype,
                                              client_id, swversion)
                neighbour_cmd = get_neighbour_cmd(self.mysql_hdlr, owner,
                                                  duttype, client_id,
                                                  swversion)
                if status == 'idle':
                    self.busy_cnt = 0
                    #self.transport.write('start_testcase %s\n'%os.path.join("BG2CDP", "Chromecast_HBOGO.tar.gz"))
                    if private_cmd != None: cmd_list = private_cmd
                    elif neighbour_cmd != None: cmd_list = neighbour_cmd
                    else:
                        self.prv_logger.trace(
                            "could not get any command from mysql")
                        cmd_list = None

                    if cmd_list != None:
                        case_info = get_case_info(self.mysql_hdlr,
                                                  {'id': cmd_list['case_id']})
                        if case_info != None:
                            start_case_cmd = case_info['path']
                        else:
                            start_case_cmd
                    else:
                        start_case_cmd = None
                    if start_case_cmd != None:
                        self.transport.write(
                            'start_testcase %s %s %s %s\n' %
                            (start_case_cmd,
                             os.path.join("TestCase", "Config",
                                          str(cmd_list['id']), 'config.py'),
                             cmd_list['id'], cmd_list['case_parametar']))
                        timeStamp = time.strftime("%Y-%m-%d %H:%M:%S",
                                                  time.localtime())
                        if not update_special_cmd(
                                self.mysql_hdlr, cmd_list['id'], {
                                    'status': 'running',
                                    'exc_client_id': client_id,
                                    'start_time': timeStamp,
                                    'sw_version': swversion
                                }):
                            self.prv_logger.error(
                                "update mysql failed;status:not run->running")
                    #self.transport.write('ENDMSG\n')
                elif status == 'busy':
                    #update_special_cmd(self.mysql_hdlr, taskid, {'status':'running', 'sw_version':swversion})
                    self.prv_logger.trace("dut is busy(id:%s)" % taskid)
                    res = get_special_cmd(self.mysql_hdlr, taskid)
                    if res != None:
                        if res['status'] == 'running':
                            self.prv_logger.trace('got it(id:%s)' % taskid)
                            if res['cmd_owner'] != owner and private_cmd != None:
                                self.prv_logger.trace(
                                    'case(id:%s; case_id:%s; owner:%s) will be canceled;'
                                    % (res['id'], res['case_id'],
                                       res['cmd_owner']))
                                self.prv_logger.trace(
                                    'case(id:%s; case_id:%s; owner:%s) will be run;'
                                    %
                                    (private_cmd['id'], private_cmd['case_id'],
                                     private_cmd['cmd_owner']))
                                if not update_special_cmd(
                                        self.mysql_hdlr, taskid,
                                    {'status': 'not run'}):
                                    self.prv_logger.error(
                                        "update mysql failed;status:not running->not run"
                                    )
                                self.transport.write('cancel_testcase\n')
                                update_special_cmd(self.mysql_hdlr, taskid, {
                                    'status': 'not run',
                                    'sw_version': swversion
                                })
                        elif res['status'] == 'stopped':
                            self.transport.write('stop_testcase\n')
                            update_special_cmd(
                                self.mysql_hdlr, taskid, {
                                    'status': 'finished',
                                    'result': 'stopped',
                                    'reserved': 'manually stopped',
                                    'sw_version': swversion
                                })
                        elif res['status'] == 'restart':
                            self.transport.write('cancel_testcase\n')
                            update_special_cmd(
                                self.mysql_hdlr, taskid, {
                                    'status': 'not run',
                                    'reserved': 'manually canceled',
                                    'sw_version': swversion
                                })
                        else:
                            update_special_cmd(self.mysql_hdlr, taskid, {
                                'status': 'running',
                                'sw_version': swversion
                            })
                            self.prv_logger.trace('invalid status:%s (id:%s)' %
                                                  (res['status'], taskid))
                    else:
                        self.prv_logger.error('could not get(id:%s) in db' %
                                              taskid)

                else:
                    """
                                    should be hang or other unhandle status,
                                    need notify administrator and client owner
                                    """
                self.transport.write('ENDMSG\n')
                print "owner:%s hostname:%s macaddr:%s duttype:%s dutip:%s swversion:%s status:%s" % (
                    owner, hostname, macaddr, duttype, dutip, swversion,
                    status)
            except IndexError:
                self.transport.write(
                    'Missing hostname, macaddr, duttype or swversion\n')
                self.transport.write('ENDMSG\n')
                self.prv_logger.trace(
                    'Missing hostname, macaddr, duttype or swversion\n')
                return

#except Exception, e:
#        self.prv_logger.trace('Capture exception:%s'%str(e))
#except:
#        self.prv_logger.trace('Capture unknown exception')
        elif command == 'quit':
            self.transport.loseConnection()
Example #28
0
 def timeoutConnection(self):
     display_message("Connection timeout")
     self.transport.loseConnection()
Example #29
0
	def stopFactory(self) :
		self.userdb = open("user.db","wb")
		json.dump(self.users,self.userdb)
		self.userdb.close()	
		self.log.close()
		display_message('Bye Bye! \n')
Example #30
0
 def lineReceived(self, line):
     display_message(
         'Received the following line from the client [%s]: %s' %
         (self.transport.getPeer().host, line))
     self.file_data = ("derpy.wav", )
     self.setRawMode()
Example #31
0
    def lineReceived(self, line):
	global clients
        display_message('Received the following line from the client [%s]: %s' % (self.transport.getPeer().host, line))

        data = self._cleanAndSplitInput(line)
        if len(data) == 0 or data == '':
            return
	
	user = data.pop()

        command = data[0].lower()
        if not command in COMMANDS:
            self.transport.write('Invalid command\n')
            self.transport.write('ENDMSG\n')
            return

	if command != 'login' and command != 'quit' and user not in clients:
		self.transport.write('You must be logged in\n')
		self.transport.write('ENDMSG\n')
		return

        if command == 'list':
            self._send_list_of_files()

        elif command == 'get':
            try:
                filename = data[1]
            except IndexError:
                self.transport.write('Missing filename\n')
                self.transport.write('ENDMSG\n')
                return

            if not self.factory.files:
                self.factory.files = self._get_file_list()

            if not filename in self.factory.files:
                self.transport.write('File with filename %s does not exist\n' % (filename))
                self.transport.write('ENDMSG\n')
                return

            display_message('Sending file: %s (%d KB)' % (filename, self.factory.files[filename][1] / 1024))

            self.transport.write('HASH %s %s\n' % (filename, self.factory.files[filename][2]))
            self.setRawMode()

            for bytes in read_bytes_from_file(os.path.join(self.factory.files_path, filename)):
                self.transport.write(bytes)

            self.transport.write('\r\n')
            self.setLineMode()
        elif command == 'put':

            try:
                filename = data[1]
                file_hash = data[2]
                #replace the '|' back with ' '
                filename = filename.replace('|',' ')
                file_hash = file_hash.replace('|',' ')

            except IndexError:
                self.transport.write('Missing filename or file MD5 hash\n')
                self.transport.write('ENDMSG\n')
                return

            self.file_data = (filename, file_hash)

            # Switch to the raw mode (for receiving binary data)
            print 'Receiving file: %s' % (filename)
            self.setRawMode()
        elif command == 'help':
            self.transport.write('Available commands:\n\n')

            for key, value in COMMANDS.iteritems():
                self.transport.write('%s - %s\n' % (value[0], value[1]))

            self.transport.write('ENDMSG\n')

	elif command == 'registry':
		registry = login_demo.retrieve_login_info()
		self.transport.write('username\t\tpassword\n')
		for key, value in registry.iteritems():
			self.transport.write('%s\t\t\t%s\n' % (key, value[0]))
		
		self.transport.write('ENDMSG\n')			

        elif command == 'register':
            username = data[1]
            password = data[2]
            answer = login_demo.register_user(username, password)
            print answer
            self.transport.write('%s\n' % answer)
            self.transport.write('ENDMSG\n')

        elif command == 'login':
	    global clients
	    if user in clients:
		self.transport.write('%s is already logged in.\n' % user)
                self.transport.write('ENDMSG\n')
	    else: 
                username = data[1]
                password = data[2]
                answer = login_demo.login(username, password)
       	        if answer == "Logged In":
         	    display_message(username)
		    clients.append(username)
                print answer
	    	print clients
                self.transport.write('%s %s\n' % (answer, username))
                self.transport.write('ENDMSG\n')

	elif command == 'logout':
	    global clients
	    clients.remove(user)
	    self.transport.write('%s logged out of system\n' % user)				
	    self.transport.write('ENDMSG\n')				
			
        elif command == 'quit':
            self.transport.loseConnection()
Example #32
0
			file_list[filename] = (file_path, file_size, md5_hash)

		return file_list
			
	def _cleanAndSplitInput(self, input):
		input = input.strip()
		input = input.split(' ')
		
		return input

class MagSrvFactory(protocol.ServerFactory):
	
	protocol = MagSrvProtocol
	
	def __init__(self, files_path):
		self.files_path = files_path
		
		self.clients = []
		self.files = None
	
if __name__ == '__main__':
	parser = optparse.OptionParser()
	parser.add_option('-p', '--port', action = 'store', type = 'int', dest = 'port', default = 1234, help = 'server listening port')
	parser.add_option('--path', action = 'store', type = 'string', dest = 'path', help = 'directory where the incoming files are saved')
	(options, args) = parser.parse_args()
	
	display_message('Listening on port %d, serving files from directory: %s' % (options.port, options.path))

	reactor.listenTCP(options.port, MagSrvFactory(options.path))
	reactor.run()
Example #33
0
    def lineReceived(self, line):
	global clients
        display_message('Received the following line from the client [%s]: %s' % (self.transport.getPeer().host, line))

        data = self._cleanAndSplitInput(line)
        if len(data) == 0 or data == '':
            return
	
	user = data.pop()

        command = data[0].lower()
        if not command in COMMANDS:
            self.transport.write('Invalid command\n')
            self.transport.write('ENDMSG\n')
            return

	if command != 'login' and command != 'quit' and user not in clients:
		self.transport.write('You must be logged in\n')
		self.transport.write('ENDMSG\n')
		return


	print data

        if command == 'list':
            self._send_list_of_files()

        elif command == 'get':
            try:
                filename = data[1]
            except IndexError:
                self.transport.write('Missing filename\n')
                self.transport.write('ENDMSG\n')
                return

            if not self.factory.files:
                self.factory.files = self._get_file_list()

            if not filename in self.factory.files:
                self.transport.write('File with filename %s does not exist\n' % (filename))
                self.transport.write('ENDMSG\n')
                return

            display_message('Sending file: %s (%d KB)' % (filename, self.factory.files[filename][1] / 1024))

            self.transport.write('HASH %s %s\n' % (filename, self.factory.files[filename][2]))
            self.setRawMode()

            for bytes in read_bytes_from_file(os.path.join(self.factory.files_path, filename)):
                self.transport.write(bytes)

            self.transport.write('\r\n')
            self.setLineMode()
        elif command == 'put':

            try:
                filename = data[1]
                file_hash = data[2]
                #replace the '|' back with ' '
                filename = filename.replace('|',' ')
                file_hash = file_hash.replace('|',' ')

            except IndexError:
                self.transport.write('Missing filename or file MD5 hash\n')
                self.transport.write('ENDMSG\n')
                return

            self.file_data = (filename, file_hash)

            # Switch to the raw mode (for receiving binary data)
            print 'Receiving file: %s' % (filename)
            self.setRawMode()
        elif command == 'help':
            self.transport.write('Available commands:\n\n')

            for key, value in COMMANDS.iteritems():
                self.transport.write('%s - %s\n' % (value[0], value[1]))

            self.transport.write('ENDMSG\n')

	elif command == 'registry':
	    global admin
	    if user not in admin:
		self.transport.write('%s does not have administrative rights.\n' % user)
                self.transport.write('ENDMSG\n')
	    else:
		
	    # TODO; check if user is in admin list first
		registry = login_demo.retrieve_login_info()
		self.transport.write('username\t\tpassword\t\trole\n')
		for key, value in registry.iteritems():
			self.transport.write('%s\t\t\t%s\t\t\t%s\n' % (key, value[0],  value[1]))
		
		self.transport.write('ENDMSG\n')			

        elif command == 'register':
	    global admin
	    if user not in admin:
		self.transport.write('%s does not have administrative rights.\n' % user)
                self.transport.write('ENDMSG\n')
	    # TODO; check if user is in admin list first
            username = data[1]
            password = data[2]
	    role = data [3]
            answer = login_demo.register_user(username, password, role)
            print answer

	    created = "user %s has been created" % username
	    if answer == created:
		user_path = DIRECTORY + "/%s/OneDir" % username
		if not os.path.exists(user_path):
		    try:	
			os.makedirs(user_path)
		    except OSError, e: 
			print e
	    else:
		print "%s already exists" % path
		return False

		
            self.transport.write('%s\n' % answer)
            self.transport.write('ENDMSG\n')
Example #34
0
	def connectionLost(self, reason):
		self.factory.clients.remove(self)
		self.file_handler = None
		self.file_data = ()
		
		display_message('Connection from %s lost (%d clients left)' % (self.host, len(self.factory.clients)))
Example #35
0
	def message_children(self, sender, recipient, message):
		for server in self.servers:
			if server != sender:
				self.servers[server].get_message(recipient, message)
	
	def message_child(self, name, message):
		if name in self.servers.keys():
			self.servers[server].get_message(name, message)

if __name__ == '__main__':
	try:
		configfile = sys.argv[1]
	except IndexError:
		configfile = 'storage'
	config = ConfigParser.ConfigParser()
	config.readfp(open(configfile + '.cfg'))
	configport = int(config.get('storage', 'port'))
	configpath = config.get('storage', 'path')
	rsa_key = get_rsa_key(config)
	config.write(open(configfile + '.cfg', 'wb'))
	
	display_message('Listening on port %d, serving files from directory: %s' % (configport, configpath))
	
	container = FactoryContainer()
	container.add_child(FileTransferServerFactory(configpath), 'ftpserver')
	container.add_child(StorageNodeMediatorClientFactory(configpath, configport, rsa_key), 'mediator')
	reactor.listenTCP(configport, container.servers['ftpserver'])
	reactor.connectTCP('162.243.36.143', 8001, container.servers['mediator'])
	
	reactor.run()
Example #36
0
	def lineReceived(self, line):
		
		data = self._cleanAndSplitInput(line)
		if len(data) == 0 or data == '':
			return 
		
		command = data[0].lower()
		display_message('Received the following command from the client %s ,[%s]: %s' % (self.nick,self.ip, command))
		log_message('Received the following command from the client %s ,[%s]: %s' % (self.nick,self.ip, command),self.factory.log)
		
		if not ((command in COMMANDS) or (command in RESPONSE)) :
			self.transport.write('Invalid command\n')
			self.transport.write('ENDMSG\n')
			return
		
		if command == 'list':
			self._send_list_of_files()
			
		if command == 'finger':
			if not self.authenticated :
				self.transport.write('Please authenitcate using "nick identify" before using file transfer \n')
				self.transport.write('ENDMSG\n')
				return 
				
			try:
				nickname = data[1]
			except IndexError:
				self.transport.write('Missing nickname\n')
				self.transport.write('ENDMSG\n')
				return
				
			for user in self.factory.onlineClients :
				if user.nick == nickname :
					self.transport.write('-- INFORMATION --  \n')
					self.transport.write('Nickname : %s \n'%(nickname))
					self.transport.write('IP : %s \n'%(user.ip))
					self.transport.write('PORT : %d \n'%(user.port))
					self.transport.write('OS : %s \n'%(user.osType.split('#')[0]))
					self.transport.write('Platform : %s \n'%(user.osType.split('#')[1]))
					self.transport.write('ENDMSG\n')
					
					return 
				
			self.transport.write('Nickname not found\n')
			self.transport.write('ENDMSG\n')	
			
		
		elif command =='platform':
			print data[1]
			self.osType = data[1]
		
		elif command == 'get':
			if not self.authenticated :
				self.transport.write('Please authenitcate using "nick identify" before using file transfer \n')
				self.transport.write('ENDMSG\n')
				return 
				
			try:
				filename = data[1]
			except IndexError:
				self.transport.write('Missing filename\n')
				self.transport.write('ENDMSG\n')
				return
			
			if not self.factory.files:
				self.factory.files = self._get_file_list()
				
			if not filename in self.factory.files:
				self.transport.write('File with filename %s does not exist\n' % (filename))
				self.transport.write('ENDMSG\n')
				return
			
			display_message('%s : Sending file: %s (%d KB)' % (self.nick,filename, self.factory.files[filename][1] / 1024))
			log_message('%s : Sending file: %s (%d KB)' % (self.nick,filename, self.factory.files[filename][1] / 1024),self.factory.log)
			
			self.transport.write('HASH %s %s\n' % (filename, self.factory.files[filename][2]))
			self.setRawMode()
			
			for bytes in read_bytes_from_file(os.path.join(self.factory.files_path, filename)):
				self.transport.write(bytes)
			
			self.transport.write('\r\n')	
			self.setLineMode()
		
		elif command == 'put':
			if not self.authenticated :
				self.transport.write('Please authenitcate using "nick identify" before using file transfer \n')
				self.transport.write('ENDMSG\n')
				return
			
			try:
				filename = data[1]
				file_hash = data[2]
			except IndexError:
				self.transport.write('Missing filename or file MD5 hash\n')
				self.transport.write('ENDMSG\n')
				return

			self.file_data = (filename, file_hash)
			
			# Switch to the raw mode (for receiving binary data)
			print 'Receiving file: %s' % (filename)
			self.setRawMode()
		
		elif command == "people" :
			self._send_online_clients()
		
		elif command == "sync" :
			
			self.factory.files = self._get_file_list()
			self.sync = 1 			
			
				
			if not self.authenticated :
				self.transport.write('Please authenitcate using "nick identify" before using sync \n')
				self.transport.write('ENDMSG\n')
				return
			
			now = datetime.datetime.now()
			
			self.transport.write('Initiating sync \n')
			self.transport.write('ENDMSG\n')
			display_message('initiating sync with %s(%s) : %s ' % (self.nick,self.ip,now.strftime("%Y-%m-%d %H:%M")))
			log_message('initiating sync with %s(%s) : %s ' % (self.nick,self.ip,now.strftime("%Y-%m-%d %H:%M")),self.factory.log)
			
			#self.transport.write('Initiating sync\n')
			#self.transport.write('ENDMSG\n')
			try:
				cfiles = data[1].split('#')
				
			except IndexError:
				cfiles = []
				
			sfiles = [ f for f in os.listdir(self.factory.files_path) if os.path.isfile(os.path.join(self.factory.files_path,f)) ]
			file_outbox = []
			
			for file in sfiles :
				if file not in cfiles :
					self.file_outbox.append(file)
			
			no_of_files = len(self.file_outbox)
			self.transport.write('Sending %d files\n'%(no_of_files))
			self.transport.write('ENDMSG\n')
				
			if no_of_files == 0 :
				self.sync = 0
				self.transport.write('Folders are in sync \n')
				self.transport.write('ENDMSG\n')
				return
			
			file = self.file_outbox.pop()
			#self.sendFile(file)
			
			display_message('%s : Sending file: %s (%d KB)' % (self.nick,file, self.factory.files[file][1] / 1024))
			log_message('%s : Sending file: %s (%d KB)' % (self.nick,file, self.factory.files[file][1] / 1024),self.factory.log)
			
			self.transport.write('HASH %s %s\n' % (file, self.factory.files[file][2]))
			self.setRawMode()
			
			for bytes in read_bytes_from_file(os.path.join(self.factory.files_path, file)):
				self.transport.write(bytes)
			
			self.transport.write('\r\n')	
			self.setLineMode()
				
				
			'''
			@defer.inlineCallbacks
			def _sync():
				
				for file in file_outbox :
					display_message('%s : Sending file: %s (%d KB)' % (self.nick,file, self.factory.files[file][1] / 1024))
					log_message('%s : Sending file: %s (%d KB)' % (self.nick,file, self.factory.files[file][1] / 1024),self.factory.log)
					yield sendFile(file)
						
		    _sync()	
			'''
				
				#self.transport.write('ENDMSG\n')
				
			
					
		
		elif command == 'nick':
			subcommand = data[1]
			if not (subcommand and data[2] and data[3]) :
				self.transport.write('Missing nickname and/or password\n')
				self.transport.write('ENDMSG\n')
			else :
				if data[1] == "reg" :
					self._register(data[2],data[3])
					
				elif data[1] == "identify" :
					self._identify(data[2],data[3])
					
				else :
					self.transport.write('unknown subcommand %s to nick\n' % (data[1]))
					self.transport.write('ENDMSG\n')
						 
			
		
		
		elif command == 'recv' :
			now = datetime.datetime.now()
			display_message('%s : File recieved - %s' % (self.nick,data[1]))
			log_message('%s : File recieved - %s' % (self.nick,data[1]),self.factory.log)
			
			if self.sync == 1 :
				no_of_files = len(self.file_outbox)
				
				if no_of_files != 0 :
					file = self.file_outbox.pop()
					
					
					
					self.transport.write('HASH %s %s\n' % (file, self.factory.files[file][2]))
					self.setRawMode()
			
					for bytes in read_bytes_from_file(os.path.join(self.factory.files_path, file)):
						self.transport.write(bytes)
			
					self.transport.write('\r\n')	
					self.setLineMode()
					
					
				
					
					#self.sendFile(file)
					
					
				else :
					display_message('terminating sync with %s(%s) : %s ' % (self.nick,self.ip,now.strftime("%Y-%m-%d %H:%M")))
					log_message(' sync with %s(%s) : %s ' % (self.nick,self.ip,now.strftime("%Y-%m-%d %H:%M")),self.factory.log)
					#self.transport.write('Terminating sync\n')
					self.setLineMode()
					self.transport.write('Sync complete\n')
					self.transport.write('ENDMSG\n')
					#self.transport.write('ENDMSG\n')
					self.sync = 0
					
				
		
		elif command == 'search':
			
			self.factory.search_request = 1
			self.factory.responses = 0 
			self.factory.requester = self
			for user in self.factory.onlineClients :
				if user.nick != self.nick :
					user.transport.write('SEARCH-REQUEST %s\n'%(data[1]))
				else :
					user.transport.write('ENDMSG\n')
					
                    
		elif command == 'sresponse':
			
			
			if self.factory.search_request == 1 :
				self.factory.responses+=1
				found = data[1]
				print data
				if found == 'true' :
					tupple = (self.nick,self.ip)
					self.factory.search_dump.append(tupple)
				if self.factory.responses >= len(self.factory.onlineClients) - 1:
					self.factory.requester.setLineMode()
					
					if len(self.factory.search_dump) == 0 :
						self.factory.requester.transport.write('File not found \n')
						self.factory.requester.transport.write('ENDMSG\n')
					else :
						self.factory.requester.transport.write('File found in following clients \n')
						for user in self.factory.search_dump : 
							self.factory.requester.transport.write('%s - %s\n'%(user[0],user[1]))
						self.factory.requester.transport.write('ENDMSG\n')
                            
					self.factory.search_request = 0
					self.factory.requester = None
                        
                
		
		
		elif command == 'help':
			self.transport.write('Available commands:\n\n')
			
			for key, value in COMMANDS.iteritems():
				self.transport.write('%s - %s\n' % (value[0], value[1]))
			
			self.transport.write('ENDMSG\n')				
		elif command == 'quit':
			self.transport.loseConnection()
Example #37
0
	def transmit(self, query, json_str, raw):
		if not len(raw):
			raw = "nada"
		paquet = query + "<smoky-break>"  + json.dumps(json_str,ensure_ascii=False) + "<smoky-break>";
		display_message( "%s + raw(%d octets)" % (paquet, len(raw)) )
		self.sendLine( paquet + raw )