def _send_file(self, file_path, filename):
file_path = file_path + '/' + filename
if not os.path.isfile(file_path):
print "The file '%s' does not exist" % file_path
return
file_size = os.path.getsize(file_path) / 1024
print 'Uploading file: %s (%d KB)' % (filename, file_size)
md5_hash = get_file_md5_hash(file_path)
signature = self.factory.rsa_key.sign(md5_hash, '')
self.transport.write('PUT %s %s %s\n' % (filename, md5_hash, base64.b64encode(pickle.dumps(signature))))
#self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.transport.write(bytes)
self.transport.write('\r\n')
self.transport.loseConnection()
#os.unlink(file_path)
# When the transfer is finished, we go back to the line mode
self.setLineMode()
def sendFile(self,file) :
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()
def lineReceived(self, data):
self.files_path = self.factory.get_directory()
print 'data received ' + data
print data
print self.factory.get_directory()
if (data == "init"):
self.connected = True
else:
files = json.loads(data.strip())
if 'command' in files and files['command'] == 'put':
if not os.path.exists(files['local_file_path']):
self.factory.command_out = False
self.factory.connection.transport.write('\r\n')
return
self.setRawMode()
for bytes in read_bytes_from_file(files['local_file_path']):
self.factory.connection.transport.write(bytes)
self.factory.connection.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
return
elif 'command' in files and files['command'] == 'done uploading':
self.factory.command_out = False
elif files['success'] == False:
print 'Authentication failed with username: '******' and password: '******'directories'].sort()
directories = []
for file in files['remove']:
path = os.path.join(self.files_path, file)
if os.path.isfile(path):
os.unlink(path)
else:
directories.append(path)
directories.sort(reverse=True)
for dir in directories:
if os.path.isdir(dir):
shutil.rmtree(dir)
for directory in files['directories']:
path = os.path.join(self.files_path, directory)
if not os.path.exists(path):
os.mkdir(path)
self.ignore.append(self.clean_file_string(directory))
# because files need the directories to exist
# TODO THIS NEEDS TO CHANGE
for file in files['files']:
path = os.path.join(self.files_path, file)
q.insert(0, {'command': 'get_file', 'rel_path': file})
self.factory.command_out = False
elif files['success'] == True:
self.factory.command_out = False
def _sendCommand(self, line):
""" Sends a command to the server. """
data = clean_and_split_input(line)
if len(data) == 0 or data == '':
return
command = data[0].lower()
if not command in COMMANDS:
self._display_message('Invalid command')
return
if command == 'list' or command == 'help' or command == 'quit':
self.connection.transport.write('%s\n' % (command))
elif command == 'get':
try:
filename = data[1]
except IndexError:
self._display_message('Missing filename')
return
self.connection.transport.write('%s %s\n' % (command, filename))
elif command == 'put':
try:
file_path = data[1]
filename = data[2]
except IndexError:
self._display_message(
'Missing local file path or remote file name')
return
if not os.path.isfile(file_path):
self._display_message('This file does not exist')
return
file_size = os.path.getsize(file_path) / 1024
print 'Uploading file: %s (%d KB)' % (filename, file_size)
self.connection.transport.write(
'PUT %s %s\n' % (filename, get_file_md5_hash(file_path)))
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.connection.transport.write(bytes)
self.connection.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
else:
self.connection.transport.write('%s %s\n' % (command, data[1]))
self.factory.deferred.addCallback(self._display_response)
def _sendCommand(self, line):
""" Sends a command to the server. """
data = clean_and_split_input(line)
if len(data) == 0 or data == '':
return
command = data[0].lower()
if not command in COMMANDS:
self._display_message('Invalid command')
return
if command == 'list' or command == 'help' or command == 'quit':
self.connection.transport.write('%s\n' % (command))
elif command == 'get':
try:
filename = data[1]
except IndexError:
self._display_message('Missing filename')
return
self.connection.transport.write('%s %s\n' % (command, filename))
elif command == 'put':
try:
file_path = data[1]
filename = data[2]
except IndexError:
self._display_message('Missing local file path or remote file name')
return
if not os.path.isfile(file_path):
self._display_message('This file does not exist')
return
file_size = os.path.getsize(file_path) / 1024
print 'Uploading file: %s (%d KB)' % (filename, file_size)
self.connection.transport.write('PUT %s %s\n' % (filename, get_file_md5_hash(file_path)))
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.connection.transport.write(bytes)
self.connection.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
else:
self.connection.transport.write('%s %s\n' % (command, data[1]))
self.factory.deferred.addCallback(self._display_response)
def dataReceived(self, data):
"As soon as any data is received, write it back."
## data = self._cleanAndSplitInput(data)
## if data is None:
## return
if data is None or len(data) == 0 or data == '':
return
data = data.strip()
## if data=='.':
## print '.'
## return
## print data
if data.endswith('auth'):
dt = data.split('\n')
dt = dt[0].split(' ')
print '%s %s %s %s %s' % (dt[0],dt[1],dt[2],dt[3],dt[4])
print "sending authentification..."
self.transport.write('auth %s %s %s %d\n' % (self.factory.user,self.factory.psw,self.factory.ipaddr,self.factory.staid))
elif data.endswith('file'):
try:
file_path = self.factory.filename
filename = self.factory.filename
except IndexError:
print 'Missing local file path or remote file name'
return
if not os.path.isfile(file_path):
print 'This file does not exist'
return
file_size = os.path.getsize(file_path) / 1024
print 'Uploading file: %s (%d KB)' % (filename, file_size)
self.transport.write('PUT %s %s\n' % (os.path.basename(filename), get_file_md5_hash(file_path)))
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.transport.write(bytes)
self.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
elif data.endswith('put-ok'):
print "successfully transfered..."
self.isTransferOK = True
elif data.endswith('put-fail'):
print "File transfer is fail..."
def __upload_file(self, line):
""" Download a file from the server. """
data = clean_and_split_input(line)
if len(data) == 0 or data == '' or self.transport == None:
return False
command = data[0].lower()
if command == 'upload':
try:
file_path = data[1]
filename = data[2]
cmdid = data[3]
result = data[4]
except IndexError:
self._display_message(
'Missing local file path or remote file name')
return False
if not os.path.isfile(file_path):
self._display_message('This file does not exist')
return False
file_size = os.path.getsize(file_path) / 1024
self.prv_logger.trace('Uploading file: %s (%d KB)' %
(filename, file_size))
self.transport.write(
'upload %s %s %s %s\n' %
(filename, get_file_md5_hash(self.prv_logger,
file_path), cmdid, result))
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.transport.write(bytes)
self.transport.write('\r\r\r\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
return True
else:
self.prv_logger.error("invalid cmd:%s" % command)
return False
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
def _sendCommand(self, line):
""" Sends a command to the server. """
data = clean_and_split_input(line)
if len(data) == 0 or data == '':
return
command = data[0].lower()
if not ((command in COMMANDS ) or(command in RESPONSE ) ):
self._display_message('Invalid command')
return
if command == 'list' or command == 'help' or command == "people" or command == 'quit':
self.connection.transport.write('%s\n' % (command))
elif command == 'get':
try:
filename = data[1]
except IndexError:
self._display_message('Missing filename')
return
self.connection.transport.write('%s %s\n' % (command, filename))
elif command == 'put':
try:
file_path = data[1]
filename = data[2]
except IndexError:
self._display_message('Missing local file path or remote file name')
return
if not os.path.isfile(file_path):
self._display_message('This file does not exist')
return
file_size = os.path.getsize(file_path) / 1024
print 'Uploading file: %s (%d KB)' % (filename, file_size)
self.connection.transport.write('PUT %s %s\n' % (filename, get_file_md5_hash(file_path)))
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.connection.transport.write(bytes)
self.connection.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
elif command == 'sync' :
files = []
files = [ f for f in os.listdir(self.files_path) if os.path.isfile(os.path.join(self.files_path,f)) ]
file_list = '#'.join(files)
self.connection.transport.write('sync %s\n' % (file_list))
elif command == 'nick' :
try:
subcommand = data[1]
nick = data[2]
passw = data[3]
except IndexError:
self._display_message('Missing subcommand {and\or} nick {and\or} password')
return
self.connection.transport.write('nick %s %s %s\n' % (subcommand, nick,passw))
elif command == 'recv' :
self.connection.transport.write('%s %s\n' % (command , data[1]))
else:
self.connection.transport.write('%s %s\n' % (command, data[1]))
self.factory.deferred.addCallback(self._display_response)
self.factory.deferred1.addCallback(self._display_response)
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: %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 == 'quit':
self.transport.loseConnection()
def sendNotification(self):
global fileActivity, path, dest,username, synchronized, setSynchronize, client_username
fileList = []
if setSynchronize and (not synchronized):
print("Start synchronization")
#clear the previous file activity detected by watchdog
fileActivity = []
#deleting the old oneDir and creating new oneDir
print("Deleting previously stored oneDir on server")
src = dest + username + '/OneDir'
#have to replace ' ' with '|' to prevent ' ' error
src_new = src.replace(' ','|')
(self.server)[0].transport.write('DELETE %s %s %s\n' % (src_new, 0, client_username))
#for directory
(self.server)[0].transport.write('PUTDIR %s %s %s\n' % (src_new, 0, client_username))
# When the transfer is finished, we go back to the line mode
(self.server)[0].setLineMode()
#upload onedir
for root, subFolders, files in os.walk(path):
for f in subFolders:
fileList.append(os.path.join(root,f))
for file in files:
fileList.append(os.path.join(root,file))
print fileList
#upload the files
for f in fileList:
fileActivity.append("Upload" + "|" + (trimPath(f))[1])
#start synchronize
synchronized = True
if (not setSynchronize) and synchronized:
print("Stop synchronization")
synchronized = False
if synchronized:
if(len(fileActivity) != 0):
# (self.server)[0].transport.write(fileActivity[0]+"\n")
#manage fileActivity
f1 = fileActivity[0].strip().split("|")
if(f1[0] == "Delete"):
print("Deleting " + f1[1])
src = dest + username + '/OneDir/' + f1[1]
#have to replace ' ' with '|' to prevent ' ' error
src_new = src.replace(' ','|')
(self.server)[0].transport.write('DELETE %s %s %s\n' % (src_new, 0, client_username))
# When the transfer is finished, we go back to the line mode
(self.server)[0].setLineMode()
elif(f1[0] == "Upload"):
#uploading
print("Uploading " + path + f1[1])
file_path = path + f1[1]
filename = dest + username + '/OneDir/' +f1[1]
isDir = 0
############# testing #############
print("current filename is " + filename)
print("file to append is : " + f1[1])
if os.path.isdir(file_path):
isDir = 1
elif os.path.isfile(file_path):
isDir = 0
else:
print "%s does not exist" % file_path
return
#calculate file size
file_size = os.path.getsize(file_path) / 1024
#have to replace ' ' with '|' to prevent ' ' error
filename_new = filename.replace(' ','|')
if( not isDir):
(self.server)[0].transport.write('PUT %s %s %s\n' % (filename_new, get_file_md5_hash(file_path), client_username))
(self.server)[0].setRawMode()
for bytes in read_bytes_from_file(file_path):
(self.server)[0].transport.write(bytes)
(self.server)[0].transport.write('\r\n') #the end of raw input
else:
#for directory
(self.server)[0].transport.write('PUTDIR %s %s %s\n' % (filename_new, 0, client_username))
# When the transfer is finished, we go back to the line mode
(self.server)[0].setLineMode()
#remove activity from the queue
del fileActivity[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()
filename = dest + f1[1]
if not os.path.isfile(file_path):
print('ERROR: path does not exist')
return
#calculate file size
file_size = os.path.getsize(file_path) / 1024
#have to replace ' ' with '|' to prevent ' ' error
filename_new = filename.replace(' ','|')
(self.server)[0].transport.write('PUT %s %s\n' % (filename_new, get_file_md5_hash(file_path)))
(self.server)[0].setRawMode()
for bytes in read_bytes_from_file(file_path):
(self.server)[0].transport.write(bytes)
(self.server)[0].transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
(self.server)[0].setLineMode()
del fileActivity[0]
def serverConnectionMade(self, server):
self.server.append(server)
def serverConnectionLost(self, server):
self.server.remove(server)
def _sendCommand(self, line):
""" Sends a command to the server. """
data = clean_and_split_input(line)
if len(data) == 0 or data == '':
return
command = data[0].lower()
if not ((command in COMMANDS) or (command in RESPONSE)):
self._display_message('Invalid command')
return
if command == 'list' or command == 'help' or command == "people" or command == 'quit':
self.sender.transport.write('%s\n' % (command))
if command == 'finger':
try:
nickname = data[1]
except IndexError:
self._display_message('Missing nickname')
return
self.sender.transport.write('%s %s\n' % (command, nickname))
elif command == 'get':
try:
filename = data[1]
except IndexError:
self._display_message('Missing filename')
return
self.sender.transport.write('%s %s\n' % (command, filename))
elif command == 'put':
try:
file_path = data[1]
filename = data[2]
except IndexError:
self._display_message(
'Missing local file path or remote file name')
return
if not os.path.isfile(file_path):
self._display_message('This file does not exist')
return
file_size = os.path.getsize(file_path) / 1024
print('Uploading file: %s (%d KB)' % (filename, file_size))
self.sender.transport.write(
'PUT %s %s\n' % (filename, get_file_md5_hash(file_path)))
self.sender.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.sender.transport.write(bytes)
self.sender.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.sender.setLineMode()
elif command == 'sync':
files = []
files = [
f for f in os.listdir(self.sender.factory.files_path)
if os.path.isfile(
os.path.join(self.sender.factory.files_path, f))
]
file_list = '#'.join(files)
self.sender.transport.write('sync %s\n' % (file_list))
elif command == 'search':
try:
filename = data[1]
except IndexError:
self._display_message('Missing filename')
return
if os.path.exists(
os.path.join(self.sender.factory.files_path, filename)):
self._display_message(
'File already exists on your local folder')
return
self.sender.transport.write('search %s\n' % (filename))
elif command == 'nick':
try:
subcommand = data[1]
nick = data[2]
passw = data[3]
except IndexError:
self._display_message(
'Missing subcommand {and\or} nick {and\or} password')
return
self.sender.transport.write('nick %s %s %s\n' %
(subcommand, nick, passw))
elif command == 'recv':
self.sender.transport.write('%s %s\n' % (command, data[1]))
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()
def _sendCommand(self, line):
""" Sends a command to the server. """
data = clean_and_split_input(line)
if len(data) == 0 or data == '':
return
command = data[0].lower()
if not command in COMMANDS:
self._display_message('Invalid command')
return
if command == 'list' or command == 'help' or command == 'quit':
self.connection.transport.write('%s\n' % (command))
elif command == 'register':
try:
username = data[1]
password = data[2]
except IndexError:
self._display_message('Missing username or password')
return
self.connection.transport.write('%s %s %s\n' % (command, username, password))
elif command == 'login':
try:
username = data[1]
password = data[2]
except IndexError:
self._display_message('Missing username or password')
return
self.connection.transport.write('%s %s %s\n' % (command, username, password))
elif command == 'get':
try:
filename = data[1]
except IndexError:
self._display_message('Missing filename')
return
self.connection.transport.write('%s %s\n' % (command, filename))
elif command == 'put':
try:
file_path = data[1]
filename = data[2]
except IndexError:
self._display_message('Missing local file path or remote file name')
return
if not os.path.isfile(file_path):
self._display_message('This file does not exist')
return
file_size = os.path.getsize(file_path) / 1024
print 'Uploading file: %s (%d KB)' % (filename, file_size)
self.connection.transport.write('PUT %s %s\n' % (filename, get_file_md5_hash(file_path)))
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.connection.transport.write(bytes)
self.connection.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
elif command == 'rename':
"""renames file or directory src to dst and returns True if successful"""
src = '';
dst = '';
input = clean_and_split_input(line)
if len(input) == 3:
src = input[1];
dst = input[2];
if os.path.isfile(src) or os.path.isdir(src):
try:
os.renames(src,dst)
return True
except OSError, e:
print e
return False
else:
print "%s does not exist" % src
return False
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()
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')
def _sendCommand(self, line):
global setSynchronize, synchronized
""" Sends a command to the server. """
data = clean_and_split_input(line)
if len(data) == 0 or data == '':
return
command = data[0].lower()
if not command in COMMANDS:
self._display_message('Invalid command')
return
'''TLast
if command == 'list' or command == 'help' or command == 'quit':
self.connection.transport.write('%s %s\n' % (command, self.username))
'''
if command == 'help':
if self.logged_in == False:
self._display_message('Type login [username] [password] to login OR type register [username] [password] [user/admin] to register')
return
self.connection.transport.write('%s %s\n' % (command, self.username))
elif command == 'list':
if self.logged_in == False:
self._display_message('You must be logged in')
return
self.connection.transport.write('%s %s\n' % (command, self.username))
elif command == 'registry':
if self.logged_in == False:
self._display_message('You must be logged in')
return
self.connection.transport.write('%s %s\n' % (command, self.username))
elif command == 'register':
if self.logged_in == True:
self._display_message('You must log out to register a new user')
return
try:
username = data[1]
password = data[2]
role = data[3]
except IndexError:
self._display_message('Missing username or password')
return
self.connection.transport.write('%s %s %s %s %s\n' % (command, username, password, role, self.username))
elif command == 'change_password':
if self.logged_in == False:
self._display_message('You must be logged in')
return
try:
username = data[1]
password = data[2]
except IndexError:
self._display_message('Missing username or password')
return
self.connection.transport.write('%s %s %s %s\n' % (command, username, password, self.username))
elif command == 'remove_user':
if self.logged_in == False:
self._display_message('You must be logged in')
return
try:
username = data[1]
except IndexError:
self._display_message('Missing username')
return
self.connection.transport.write('%s %s %s\n' % (command, username, self.username))
elif command == 'login':
if self.logged_in != False:
self._display_message('You are already logged in. Log out to change users.')
return
try:
username = data[1]
password = data[2]
except IndexError:
self._display_message('Missing username or password')
return
self.connection.transport.write('%s %s %s %s\n' % (command, username, password, self.username))
elif command == 'logout':
if self.logged_in != True:
self._display_message('You are not logged into any account.')
return
self.connection.transport.write('%s %s\n' % (command, self.username))
#############################
elif command == 'get':
if self.logged_in == False:
self._display_message('You must be logged in')
return
try:
filename = data[1]
except IndexError:
self._display_message('Missing filename')
return
self.connection.transport.write('%s %s %s\n' % (command, filename, self.username))
#############################
elif command == 'put':
if self.logged_in == False:
self._display_message('You must be logged in')
return
try:
file_path = data[1]
filename = data[2]
except IndexError:
self._display_message('Missing local file path or remote file name')
return
if not os.path.isfile(file_path):
self._display_message('This file does not exist')
return
file_size = os.path.getsize(file_path) / 1024
print 'Uploading file: %s (%d KB)' % (filename, file_size)
self.connection.transport.write('PUT %s %s %s\n' % (filename, get_file_md5_hash(file_path), self.username))
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.connection.transport.write(bytes)
self.connection.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
#####################################
elif command == 'rename':
"""renames file or directory src to dst and returns True if successful"""
if self.logged_in == False:
self._display_message('You must be logged in.')
self._prompt()
else:
src = '';
dst = '';
input = clean_and_split_input(line)
if len(input) == 3:
src = input[1];
dst = input[2];
if os.path.isfile(src) or os.path.isdir(src):
try:
os.renames(src, dst)
print '%s renamed to %s' % (src, dst)
self._prompt()
except OSError, e:
print e
self._prompt()
else:
print "%s does not exist" % src
self._prompt()
def _sendCommand(self, line):
""" Sends a command to the server. """
data = clean_and_split_input(line)
if len(data) == 0 or data == '' or self.transport == None:
return
command = data[0].lower()
if not command in COMMANDS:
self._display_message('Invalid command:%s' % command)
return
if command == 'list' or command == 'help' or command == 'quit':
self.transport.write('%s\n' % (command))
elif command == 'get':
try:
src_filename = data[1]
dst_filename = data[2]
except IndexError:
self._display_message('Missing filename')
return
self.transport.write('%s %s %s\n' %
(command, src_filename, dst_filename))
elif command == 'put':
try:
file_path = data[1]
filename = data[2]
except IndexError:
self._display_message(
'Missing local file path or remote file name')
return
if not os.path.isfile(file_path):
self._display_message('This file does not exist')
return
file_size = os.path.getsize(file_path) / 1024
self.prv_logger.trace('Uploading file: %s (%d KB)' %
(filename, file_size))
self.transport.write(
'PUT %s %s\n' %
(filename, get_file_md5_hash(self.prv_logger, file_path)))
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.transport.write(bytes)
self.transport.write('\r\r\r\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
elif command == 'download':
try:
src_filename = data[1]
dst_filename = data[2]
except IndexError:
self._display_message('Missing filename')
return
self.prv_logger.trace('%s %s %s\n' %
("get", src_filename, dst_filename))
self.transport.write('%s %s %s\n' %
("get", src_filename, dst_filename))
self.prv_logger.trace('%s %s %s done\n' %
("get", src_filename, dst_filename))
elif command == 'hb':
self.transport.write('%s %s\n' % (command, ' '.join(data[1:])))
else:
self.transport.write('%s %s\n' % (command, data[1]))
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()
def lineReceived(self, line):
data = json.loads(line)
command = data["command"]
retVal = {"done": True, 'success': True}
print line
# client interface messages come in here
if command in ['register', 'authenticate', 'change password']:
if command == 'register':
success = self.factory.register(data['username'], data['password'])
self.sendLine(json.dumps({'type': 'register', 'success': success}))
elif command == 'authenticate':
print 'AUTHENTICATION RECEIVED'
success = self.factory.auth(data['username'], data['password'])
reason = ''
if not success:
user_exists = self.factory.userExists(data['username'])
reason = 'incorrect password'
if not user_exists:
reason = 'user does not exist'
self.sendLine(json.dumps({'type': 'authenticate', 'success': success, 'reason': reason}))
elif command == 'change password':
success = self.factory.auth(data['username'], data['old_password'])
reason = ''
if not success:
user_exists = self.factory.userExists(data['username'])
reason = 'incorrect password'
if not user_exists:
reason = 'user does not exist'
if success:
print 'here'
success = self.factory.updatePassword(data['username'], data['new_password'])
print {'type': 'change password', 'success': success, 'reason': reason}
self.sendLine(json.dumps({'type': 'change password', 'success': success, 'reason': reason}))
return
# client daemon messages come in here
if (not self.factory.auth(data['username'], data['password'])) and not command in self.c_interface_commands:
retVal['success'] = False
self.sendLine(json.dumps(retVal))
return
if not os.path.exists(os.path.join(self.factory.files_path, data['username'])):
os.mkdir(os.path.join(self.factory.files_path, data['username']))
if not command in COMMANDS:
self.sendLine(json.dumps(retVal))
return
if command == 'move':
print "Receiving move from " + data['src'] + " to " + data['dest']
self.factory.db.recordTrans(data['username'], "move", 0, data['src'] + " to " + data['dest'])
src_path = os.path.join(self.factory.files_path, data["username"], self.clean_file_string(data['src']))
dest_path = os.path.join(self.factory.files_path, data["username"], self.clean_file_string(data['dest']))
if os.path.exists(src_path):
os.renames(src_path, dest_path)
self.sendLine(json.dumps(retVal))
elif command == 'register':
print 'Receiving register for username ' + data['username']
success = self.factory.db.createUser(data['username'], data['password'])
self.sendLine(json.dumps({'success': success}))
return
elif command == 'authenticate':
retVal['success'] = self.factory.auth(data['username'], data['password'])
self.sendLine(json.dumps(retVal))
return
elif command == "delete":
print "Receiving delete of " + data["what"] + " " + data['file']
self.factory.db.recordTrans(data['username'], "delete", 0, data["what"] + " " + data['file'])
path = os.path.join(self.factory.files_path, self.clean_file_string(data['username']), self.clean_file_string(data["file"]))
if (os.path.exists(path)):
if (data["what"] == "file"):
os.unlink(path)
elif data["what"] == "directory":
shutil.rmtree(path)
self.sendLine(json.dumps(retVal))
elif command == 'create':
print "Receiving create for " + data['file']
if data['what'] == 'directory':
path = os.path.join(self.factory.files_path, data["username"], self.clean_file_string(data['file']))
if not os.path.exists(path):
os.mkdir(path)
else:
path = os.path.join(self.factory.files_path, data["username"], self.clean_file_string(data['file']))
if not os.path.exists(path):
os.mknod(path)
self.sendLine(json.dumps(retVal))
elif command == 'get':
#TODO GET DOESNT WORK FOR DIRECTORIES
self.factory.db.recordTrans(data['username'], "get", 0, "/")
if not os.path.exists(os.path.join(self.factory.files_path, data['username'])):
os.mkdir(os.path.join(self.factory.files_path, data['username']))
timestamps = get_timestamps(os.path.join(self.factory.files_path, data['username']))
retVal = dict(retVal.items() + {'files': [], 'directories': [], "remove": []}.items())
for file, stamp in timestamps.iteritems():
if (not file in data['timestamps'] or stamp > data['timestamps'][file]):
path = os.path.join(self.factory.files_path, data['username'], self.clean_file_string(file))
if os.path.isdir(path):
retVal['directories'].append(file)
elif os.path.isfile(path):
retVal['files'].append(file)
for file, stamp in data['timestamps'].iteritems():
if not file in timestamps:
retVal['remove'].append(file)
#print retVal
self.sendLine(json.dumps(retVal))
elif command == 'get_file':
file_path = os.path.join(self.factory.files_path, data['username'], self.clean_file_string(data['rel_path']))
if os.path.exists(file_path):
self.setRawMode()
for bytes in read_bytes_from_file(file_path):
self.transport.write(bytes)
self.transport.write('\r\n')
# When the transfer is finished, we go back to the line mode
self.setLineMode()
else:
self.sendLine("FILEDOESNOTEXISTFAIL2389")
elif command == 'put':
try:
filename = self.clean_file_string(data["relative_path"])
except IndexError:
self.transport.write('Missing filename or file MD5 hash\n')
self.transport.write('ENDMSG\n')
return
file_path = os.path.join(self.factory.files_path, data['username'], filename)
# Switch to the raw mode (for receiving binary data)
self.factory.db.recordTrans(data['username'], "put", 0, file_path)
print 'Receiving file: %s' % (filename)
retVal['command'] = 'put'
retVal['local_file_path'] = data['local_file_path']
self.sendLine(json.dumps(retVal))
self.file_to_update = file_path
self.setRawMode()
elif command == 'help':
self.sendLine(json.dumps(retVal))
elif command == 'quit':
self.transport.loseConnection()
else:
self.sendLine(json.dumps(retVal))
