作业：FTP

 1 #!/usr/bin/env python3
 2 # -*- coding:utf-8 -*-
 3 import os
 4 import sys
 5 
 6 
 7 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 8 sys.path.append(BASE_DIR)
 9 
10 if __name__ == ‘__main__‘:
11     from core import main_server
12     argv_parser = main_server.Mangement(sys.argv)
13     argv_parser.execute()

 1 #！ /usr/bin/env python3
 2 # -*- coding:utf-8 -*-
 3 import os
 4 import socket
 5 import logging
 6 
 7 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 8 HOME_DIR = os.path.join(BASE_DIR,‘home‘)
 9 ACCOUNT_INI = r‘%s\conf\account.ini‘% BASE_DIR
10 
11 address_family = socket.AF_INET
12 socket_type = socket.SOCK_STREAM
13 max_packet_size = 8096
14 request_queue_size = 5
15 
16 LOG_LEVE = logging.INFO
17 
18 LOG_TYPE = {
19     ‘access‘:‘access.log‘,
20 }
21 
22 LOG_FORMATTER =logging.Formatter(‘%(asctime)s - %(name)s - %(levelname)s - %(message)s‘)
23 LOG_PATH = os.path.join(BASE_DIR,‘log‘)
24 
25 SERVER_ADDR = ‘127.0.0.1‘
26 SERVER_PORT = 8080

  1 #!/usr/bin/env python3
  2 # -*- coding:utf-8 -*-
  3 
  4 import socket
  5 import json
  6 import configparser
  7 import hashlib
  8 import struct
  9 import os
 10 import subprocess
 11 import time
 12 from conf import setting
 13 from .logger import logger_log
 14 
 15 access_log = logger_log(‘access‘)
 16 
 17 class Ftpserver:
 18     STATUS_CODE ={
 19         200: "Passed authentication!",
 20         201: "Wrong username or password!",
 21         300: "File does not exist !",
 22         301: "File exist , and this msg include the file size- !",
 23         302: "This msg include the msg size!",
 24         350: "Dir changed !",
 25         351: "Dir doesn‘t exist !",
 26         401: "File exist ,ready to re-send !",
 27         402: "File exist ,but file size doesn‘t match!",
 28         404: "File created successfully！",
 29         405: "File deleted successfully！",
 30         406: "File already exists！",
 31         407: "File does not exist ！",
 32         500: ‘Folder deletion succeeded!‘,
 33         501: ‘Folder does not exist!‘
 34     }
 35     def __init__(self,mangement_instantiation):
 36         self.mangement_instantiation = mangement_instantiation
 37         self.socket = socket.socket(setting.address_family,setting.socket_type)
 38         self.socket.bind((setting.SERVER_ADDR,setting.SERVER_PORT))
 39         self.socket.listen(setting.request_queue_size)
 40         self.account = self.load_accuont()
 41         self.user_obj = None
 42         self.user_client = None
 43         self.user_disk = None
 44         self.username = None
 45 
 46     def run_forever(self):
 47         ‘‘‘启动FTP服务器‘‘‘
 48         print(‘start FTPserver on %s:%s‘.center(50,‘*‘)%(setting.SERVER_ADDR,setting.SERVER_PORT))
 49         while True:
 50             self.request,self.addr = self.socket.accept()
 51             print(‘got a new connection form %s...‘%(self.addr,))
 52 
 53             self.handler()
 54 
 55     def load_accuont(self):
 56         ‘‘‘读取用户数据‘‘‘
 57         config_obj = configparser.ConfigParser()
 58         config_obj.read(setting.ACCOUNT_INI)
 59         print(config_obj.sections())
 60         return config_obj
 61 
 62     def authentication(self,username,password):
 63         ‘‘‘验证用户账户‘‘‘
 64         if username in self.account:
 65             _password = self.account[username][‘password‘]
 66             md5_obj = hashlib.md5()
 67             md5_obj.update(password.encode(‘utf-8‘))
 68             md5_password = md5_obj.hexdigest()
 69             if md5_password == _password:
 70                 # print(‘登陆成功！‘)
 71                 self.user_obj = self.account[username]
 72                 self.user_obj[‘home‘] = os.path.join(setting.HOME_DIR,username)
 73                 self.user_client = self.user_obj[‘home‘]
 74                 self.user_disk = self.account[username][‘file_disk‘]
 75                 access_log.info(‘%s 成功登陆了FTP服务器,IP地址:%s,‘%(username,self.addr))
 76                 return True
 77             else:
 78                 print(‘登陆失败‘)
 79                 access_log.error(‘%s 尝试登陆FTP服务器,IP地址:%s,‘%(username,self.addr))
 80                 return False
 81         else:
 82             print(‘登陆失败！‘)
 83             access_log.error(‘%s 尝试登陆FTP服务器,IP地址:%s,‘ % (username, self.addr))
 84             return False
 85     def handler(self):
 86         ‘‘‘处理用户交互‘‘‘
 87 
 88         while True:
 89             raw_data = self.request.recv(4)
 90             if not raw_data:
 91                 del self.request,self.addr
 92                 break
 93 
 94             data_size = struct.unpack(‘i‘,raw_data)[0]
 95             data_bytes = self.request.recv(data_size)
 96             data = json.loads(data_bytes.decode(‘utf-8‘))
 97             action_type = data.get(‘action_type‘)
 98             if action_type:
 99                 if hasattr(self,‘_%s‘%action_type):
100                     func = getattr(self,‘_%s‘%action_type)
101                     func(data)
102     def send_response(self,status_code,*args,**kwargs):
103         ‘‘‘发送消息给客户端‘‘‘
104         data = kwargs
105         data[‘status_code‘] = status_code
106         data[‘status_msg‘] = self.STATUS_CODE[status_code]
107 
108         bytes_data = json.dumps(data).encode(‘utf-8‘)
109         data_struct = struct.pack(‘i‘,len(bytes_data))
110         self.request.send(data_struct)
111         self.request.send(bytes_data)
112 
113     def _auth(self,data):
114         ‘‘‘处理用户认证‘‘‘
115         if self.authentication(data.get(‘username‘),data.get(‘password‘)):
116             print(‘登陆成功‘)
117             self.send_response(status_code=200)
118         else:
119             self.send_response(status_code=201)
120 
121     def _get(self,data):
122         ‘‘‘接收客户端下载‘‘‘
123         filename = data.get(‘filename‘)
124         full_path = os.path.join(self.user_client,filename)
125         if os.path.isfile(full_path):
126             file_size = os.stat(full_path).st_size
127             self.send_response(301,file_size=file_size)
128             print(‘准备发送!‘)
129             with open(full_path,‘rb‘) as f:
130                 for line in f:
131                     self.request.send(line)
132                 else:
133                     print(‘文件发送成功‘)
134                     access_log.info(‘%s 下载了文件%s,IP地址:%s,‘% (self.user_obj[‘username‘],filename,self.addr))
135         else:
136             self.send_response(300)
137             access_log.info(‘%s 下载文件%s失败,IP地址:%s,‘ % (self.user_obj[‘username‘],filename,self.addr))
138 
139     def _put(self,data):
140         filename = data.get(‘filename‘)
141         full_path = os.path.join(self.user_client, filename)
142         if os.path.isfile(full_path):
143             filename = ‘%s.%s‘%(full_path,time.time())
144         else:
145             filename = full_path
146         with open(filename,‘wb‘) as f:
147             total_size = data.get(‘file_size‘)
148             recv_size = 0
149             while recv_size < total_size:
150                 recv_data = self.request.recv(1024)
151                 f.write(recv_data)
152                 recv_size += len(recv_data)
153                 print(‘总大小:%s，已接收:%s‘%(total_size,recv_size))
154             else:
155                 print(‘接收成功‘)
156                 access_log.info(‘%s 上传了文件%s,IP地址:%s,‘ % (self.user_obj[‘username‘], filename,self.addr))
157 
158     def _ls(self,data):
159         ‘‘‘查看‘‘‘
160         cmd_obj = subprocess.Popen(‘dir %s‘%self.user_client,shell=True,
161                                    stdout=subprocess.PIPE,
162                                    stderr=subprocess.PIPE)
163         stdout = cmd_obj.stdout.read()
164         stderr = cmd_obj.stderr.read()
165         request = stdout + stderr
166         if not request:
167            request = bytes(‘此目录无文件！‘)
168         self.send_response(302,cmd_size=len(request))
169         self.request.sendall(request)
170 
171     def _mkdir(self,data):
172         ‘‘‘创建文件夹‘‘‘
173         filename = data.get(‘inp‘)
174         full_path = os.path.abspath(os.path.join(self.user_client,filename))
175         cmd_obj = subprocess.Popen(‘mkdir  %s‘%(full_path),shell=True,
176                                    stdout=subprocess.PIPE,
177                                    stderr=subprocess.PIPE)
178         stdout = cmd_obj.stdout.read()
179         stderr = cmd_obj.stderr.read()
180         request = stderr + stdout
181         if request:
182             self.send_response(406)
183         self.send_response(404,cmd_mkdir=len(request))
184         self.request.sendall(request)
185         access_log.info(‘%s 成功创建文件%s,IP地址:%s,‘ % (self.user_obj[‘username‘],filename,self.addr))
186     def _del(self,data):
187         ‘‘‘删除文件‘‘‘
188         del_name = data.get(‘del_name‘)
189         full_path = os.path.abspath(os.path.join(self.user_client,del_name))
190         cmd_obj = subprocess.Popen(‘del  %s‘%(full_path),shell=True,
191                                    stdout=subprocess.PIPE,
192                                    stderr=subprocess.PIPE)
193         stdout = cmd_obj.stdout.read()
194         stderr = cmd_obj.stderr.read()
195         request = stderr + stdout
196         if not request:
197            self.send_response(407)
198         self.send_response(405,del_mkdir=len(request))
199         self.request.sendall(request)
200         access_log.info(‘%s 成功删除文件%s,IP地址:%s,‘ % (self.user_obj[‘username‘], del_name, self.addr))
201 
202     def _rm(self,data):
203         ‘‘‘删除文件夹‘‘‘
204         rm_name = data.get(‘rm_name‘)
205         full_path = os.path.abspath(os.path.join(self.user_client,rm_name))
206         cmd_obj = subprocess.Popen(‘rd %s‘%(full_path),shell=True,
207                                    stdout=subprocess.PIPE,
208                                    stderr=subprocess.PIPE)
209         stdout = cmd_obj.stdout.read()
210         stderr = cmd_obj.stderr.read()
211         request = stderr + stdout
212         if not request:
213            self.send_response(501)
214         self.send_response(500,rm_mkdir=len(request))
215         self.request.sendall(request)
216         access_log.info(‘%s 成功删除文件%s,IP地址:%s,‘ % (self.user_obj[‘username‘], rm_name, self.addr))
217 
218     def _cd(self,data):
219         ‘‘‘切换目录‘‘‘
220         target = data.get(‘target_dir‘)
221         full_path = os.path.abspath(os.path.join(self.user_client,target))
222         if os.path.isdir(full_path):
223             if full_path.startswith(self.user_obj[‘home‘]):
224                 self.user_client = full_path
225                 relative_dir = self.user_client.replace(self.user_obj[‘home‘],‘‘)
226                 self.send_response(350,current_dir=relative_dir)
227             else:
228                 self.send_response(351)
229         else:
230             self.send_response(351)
231 
232     def _re_get(self,data):
233         filename = data.get(‘filename‘)
234         file_size = data.get(‘file_size‘)
235         full_path = os.path.join(self.user_client,filename.strip(‘\\‘))
236         if os.path.isfile(full_path):
237             if os.path.getsize(full_path) == file_size:
238                 self.send_response(401,filename=filename)
239                 with open(full_path,‘rb‘) as f:
240                     f.seek(data.get(‘recveived_size‘))
241                     for line in f:
242                         self.request.send(line)
243                     else:
244                       print(‘发送完毕！‘)
245             else:
246                self.send_response(402)
247         else:
248             self.send_response(300)

 1 #!/usr/bin/env python3
 2 # -*- coding:utf-8 -*-
 3 
 4 from .main import Ftpserver
 5 
 6 class Mangement:
 7 
 8     def __init__(self,sys_argv):
 9         ‘‘‘解析指令，调用相应的模块‘‘‘
10         self.sys_argv = sys_argv
11         print(sys_argv)
12         self.verify_argv()
13 
14     def verify_argv(self):
15         ‘‘‘验证指令是否合法‘‘‘
16         if len(self.sys_argv) <2:
17             self.help_msg()
18         cmd = self.sys_argv[1]
19         if not hasattr(self,cmd):
20             print(‘输入错误！‘)
21             self.help_msg()
22 
23     def help_msg(self):
24         msg = ‘‘‘
25         start      start FTP server
26         stop       stop FTP server
27         restart    restart FTP server      
28         ‘‘‘
29         exit(msg)
30 
31     def execute(self):
32         cmd = self.sys_argv[1]
33         func = getattr(self,cmd)
34         func()
35 
36     def start(self):
37         server = Ftpserver(self)
38         server.run_forever()

  1 #!/usr/bin/env python3
  2 # -*- coding:utf-8 -*-
  3 
  4 import socket
  5 import struct
  6 import os
  7 import json
  8 import optparse
  9 import shelve
 10 
 11 class Myclient:
 12     def __init__(self):
 13         self.username = None
 14         self.terminal_dis = None
 15         self.current_dir = None
 16         self.shelve_obj = shelve.open(‘.‘)
 17         parser = optparse.OptionParser()
 18         parser.add_option("-s","--server", dest="server", help="ftp server ip_addr")
 19         parser.add_option("-P","--port",type="int", dest="port", help="ftp server port")
 20         parser.add_option("-u","--username", dest="username", help="username info")
 21         parser.add_option("-p","--password", dest="password", help="password info")
 22         self.options , self.args = parser.parse_args()
 23         self.arvs_verify()
 24         self.make_connt()
 25 
 26     def arvs_verify(self):
 27         ‘‘‘检查命令的合法性‘‘‘
 28         if not self.options.server or not self.options.port:
 29             print(‘缺少必要的参数！‘)
 30 
 31     def make_connt(self):
 32         ‘‘‘建立链接‘‘‘
 33         self.sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 34         self.sock.connect((self.options.server,self.options.port))
 35 
 36     def get_response(self):
 37         data = self.sock.recv(4)
 38         hear_size = struct.unpack(‘i‘,data)[0]
 39         hear_bytes = self.sock.recv(hear_size)
 40         hear_dic = json.loads(hear_bytes)
 41         return hear_dic
 42 
 43     def auth(self):
 44         count = 0
 45         while count < 3:
 46             username = input(‘请输入账号：‘).strip()
 47             password = input(‘请输入密码：‘).strip()
 48             auth_info = {
 49                 ‘action_type‘:‘auth‘,
 50                 ‘username‘:username,
 51                 ‘password‘:password,
 52             }
 53             hear_json = json.dumps(auth_info)
 54             hear_bytes = hear_json.encode(‘utf-8‘)
 55             self.sock.send(struct.pack(‘i‘, len(hear_bytes)))
 56             self.sock.send(hear_bytes)
 57             response = self.get_response()
 58             if response.get(‘status_code‘) == 200:
 59                 self.username = username
 60                 self.terminal_dis = ‘[%s]>>‘%self.username
 61                 self.current_dir = ‘\\‘
 62                 print(‘登陆成功！‘)
 63                 msg = ‘‘‘
 64                       del      删除文件
 65                       ls       查看当前文件
 66                       cd       切换目录
 67                       mkdir    创建文件夹
 68                       put      上传文件
 69                       get      下载文件
 70                       rm        删除文件夹
 71                   ‘‘‘
 72                 print(msg)
 73                 return  True
 74             else:
 75                 print(response.get(‘status_msg‘))
 76                 count += 1
 77 
 78     def file_check(self):
 79         if  list(self.shelve_obj.keys()):
 80             print(‘未下载成功的列表‘.center(50,‘*‘))
 81             for index,abs_file in enumerate(self.shelve_obj.keys()):
 82                 print(self.shelve_obj[abs_file][1])
 83                 recv_size = os.path.getsize(self.shelve_obj[abs_file][1])
 84                 print(‘ %s.%s  %s  %s   %s‘%(index,abs_file,
 85                                              self.shelve_obj[abs_file][0],
 86                                              recv_size,
 87                                              recv_size/self.shelve_obj[abs_file][0]*100))
 88 
 89             while True:
 90                 choice = input(‘请选择继续下载的文件：‘).strip()
 91                 if not choice:continue
 92                 if choice == ‘back‘:break
 93                 if choice.isdigit():
 94                     choice = int(choice)
 95                     if choice >=0 and choice <= index:
 96                         selected_file = list(self.shelve_obj.keys())[choice]
 97                         already_rec_size = os.path.getsize(self.shelve_obj[selected_file][1])
 98                         self.send_msg(‘re_get‘,file_size=self.shelve_obj[selected_file][0],
 99                                       filename=selected_file,
100                                       recveived_size=already_rec_size)
101                         response = self.get_response()
102                         new_filename = response.get(‘filename‘).strip(‘\\‘)
103                         if response.get(‘status_code‘) == 401:
104                             local_filename = self.shelve_obj[selected_file][1]
105                             with open(local_filename,‘ab‘) as f:
106                                 total_size = self.shelve_obj[selected_file][0]
107                                 recv_size = already_rec_size
108                                 current_percent = int(recv_size / total_size * 100)
109                                 progress_generator = self.progress_bar(total_size,
110                                                                        current_percent,current_percent)
111                                 progress_generator.__next__()
112                                 while recv_size < total_size:
113                                     res = self.sock.recv(1024)
114                                     f.write(res)
115                                     recv_size += len(res)
116                                     progress_generator.send(recv_size)
117                                 else:
118                                     print(‘下载完毕‘)
119                                     del self.shelve_obj[selected_file]
120                             os.rename(local_filename, new_filename)
121 
122                         else:
123                             print(response.get(‘status_msg‘))
124 
125 
126 
127     def interactive(self):
128         if self.auth():
129             self.file_check()
130             while True:
131                 user_input = input(self.terminal_dis).strip()
132                 if not user_input:continue
133                 cmd_list = user_input.split()
134                 if hasattr(self,‘_%s‘%cmd_list[0]):
135                     func = getattr(self,‘_%s‘%cmd_list[0])
136                     func(cmd_list[1:])
137 
138 
139     def send_msg(self,acttion_type,*args,**kwargs):
140         ‘‘‘将消息发送到远程‘‘‘
141         my_data = {
142             ‘action_type‘:acttion_type
143 
144         }
145         my_data.update(kwargs)
146         hear_json = json.dumps(my_data)
147         hear_bytes = hear_json.encode(‘utf-8‘)
148         self.sock.send(struct.pack(‘i‘,len(hear_bytes)))
149         self.sock.send(hear_bytes)
150 
151     def parameter_check(self, args, min_args=None, max_args=None, exact_args=None):
152         """参数个数合法性检查"""
153         if min_args:
154             if len(args) < min_args:
155                 print("must provide at least %s parameters but %s received." %(min_args,len(args)))
156                 return False
157         if max_args:
158             if len(args) > max_args:
159                 print("need at most %s parameters but %s received." %(max_args,len(args)))
160                 return False
161         if exact_args:
162             if len(args) != exact_args:
163                 print("need exactly %s parameters but %s received." % (exact_args, len(args)))
164                 return False
165         return True
166 
167     def progress_bar(self,total_size,current_percent=0,last_percent=0):
168         ‘‘‘进度条‘‘‘
169         while True:
170             received_size = yield current_percent
171             current_percent = int(received_size /total_size * 100)
172             if current_percent > last_percent:
173                 print(‘>‘ * int(current_percent / 2) + ‘{percnet}%‘.format(percnet=current_percent),end=‘\r‘,
174                       flush=True)
175                 last_percent = current_percent
176 
177     def _get(self,cmd_argv):
178         ‘‘‘下载文件‘‘‘
179         if self.parameter_check(cmd_argv,min_args=1):
180             filename = cmd_argv[0]
181             self.send_msg(acttion_type=‘get‘,filename=filename)
182             response = self.get_response()
183             if response.get(‘status_code‘) == 301:
184                 file_size = response.get(‘file_size‘)
185                 recv_size = 0
186                 progress_gen = self.progress_bar(file_size)
187                 progress_gen.__next__()
188 
189                 file_abs_path = os.path.join(self.current_dir,filename)
190                 self.shelve_obj[file_abs_path] = [file_size,‘%s.download‘%filename]
191 
192                 with open(‘%s.download‘%filename,‘wb‘) as f:
193                     while recv_size < file_size:
194                         res = self.sock.recv(1024)
195                         recv_size += len(res)
196                         f.write(res)
197                         progress_gen.send(recv_size)
198                     else:
199                         print(‘\n‘)
200                         print(‘下载成功！‘)
201                         del self.shelve_obj[file_abs_path]
202                 os.rename(‘%s.download‘%filename,filename)
203             else:
204                 print(response.get(‘status_msg‘))
205 
206 
207 
208 
209     def _put(self,cmd_argv):
210         ‘‘‘上传文件‘‘‘
211         if self.parameter_check(cmd_argv,exact_args=1):
212             filename = cmd_argv[0]
213             if os.path.isfile(filename):
214                 file_size = os.path.getsize(filename)
215                 self.send_msg(acttion_type=‘put‘,file_size=file_size,filename=filename)
216                 print(‘准备发送‘)
217                 send_size = 0
218                 progress_gen = self.progress_bar(file_size)
219                 progress_gen.__next__()
220                 with open(filename,‘rb‘) as f:
221                     for line in f:
222                         self.sock.send(line)
223                         send_size += len(line)
224                         progress_gen.send(send_size)
225 
226                     else:
227                         print(‘\n‘)
228                         print(‘上传成功！‘)
229 
230 
231     def _ls(self,cmd_argv):
232         ‘‘‘查看‘‘‘
233         self.send_msg(acttion_type=‘ls‘)
234         response = self.get_response()
235         if response.get(‘status_code‘) == 302:
236             cmd_size = response.get(‘cmd_size‘)
237             recv_size = 0
238             cmd_result = b‘‘
239             while recv_size < cmd_size:
240                 res = self.sock.recv(1024)
241                 cmd_result += res
242                 recv_size += len(res)
243             else:
244                 print(cmd_result.decode(‘gbk‘))
245 
246 
247     def _mkdir(self,cmd_argv):
248         ‘‘‘创建文件夹‘‘‘
249         if self.parameter_check(cmd_argv,exact_args=1):
250             inp = cmd_argv[0]
251             self.send_msg(acttion_type=‘mkdir‘,inp=inp)
252             response = self.get_response()
253             if response.get(‘status_code‘) == 404:
254                 print(response.get(‘status_msg‘))
255             elif response.get(‘status_code‘) == 406:
256                 print(response.get(‘status_msg‘))
257 
258     def _del(self,cmd_argv):
259         ‘‘‘删除文件‘‘‘
260         if self.parameter_check(cmd_argv,exact_args=1):
261             del_name = cmd_argv[0]
262             self.send_msg(acttion_type=‘del‘,del_name=del_name)
263             response = self.get_response()
264             if response.get(‘status_code‘) == 405:
265                 print(response.get(‘status_msg‘))
266             elif response.get(‘status_code‘) == 407:
267                 print(response.get(‘status_msg‘))
268 
269     def _rm(self,cmd_argv):
270         ‘‘‘删除文件夹‘‘‘
271         if self.parameter_check(cmd_argv,exact_args=1):
272             rm_name = cmd_argv[0]
273             self.send_msg(acttion_type=‘rm‘,rm_name=rm_name)
274             response = self.get_response()
275             if response.get(‘status_code‘) == 500:
276                 print(response.get(‘status_msg‘))
277             elif response.get(‘status_code‘) == 501:
278                 print(response.get(‘status_msg‘))
279 
280     def _cd(self,cmd_argv):
281         ‘‘‘切换目录‘‘‘
282         if self.parameter_check(cmd_argv,exact_args=1):
283             target_dir = cmd_argv[0]
284             self.send_msg(acttion_type=‘cd‘,target_dir=target_dir)
285             response = self.get_response()
286             if response.get(‘status_code‘) == 350:
287                 self.terminal_dis = ‘[[%s]>>\%s]‘% (self.username,response.get(‘current_dir‘))
288                 self.current_dir = response.get(‘current_dir‘)
289 
290 
291 
292 
293 
294 if __name__ == ‘__main__‘:
295     obj = Myclient()
296     obj.interactive()