python 实现简单的FTP

一、开发环境

server端：centos 7  python-3.6.2

客户端：windows 7 python-3.6.2 pycharm-2018

程序目的：1、学习使用socketserver实现并发处理多个客户端。

　　           2、了解使用struct解决tcp粘包。

二、程序设计

（本人菜鸟一枚，对于开发规范，接口设计完全不懂，完全是随心所欲，自娱自乐。写博客主要是记录自己学习的点点滴滴，如有不足之处还请见谅。）

1、server端

1.1 目录结构如下：

 1.2 目录简介：

ftp_server：程序主目录

app：程序主逻辑目录，目录下有四个模块：

          ftpserver.py：ftp  server端启动入口。

          login.py：认证注册模块，用于处理用户注册，登录认证。

          dataanalysis.py：命令解析模块，负责解析，执行客户端命令。

          fileopertion.py：负责文件读，写。数据发送，数据接收。

db：存放user_pwd.db文件，用于存放用户信息（用户名，密码，ftp目录总空间，已使用空间等）

lib：存放公共数据。

1.3 模块中类的继承关系

1.4 执行流程

1.4.1 程序启动文件ftpserver.py，程序启动后进入监听状态。核心代码如下：

class myftpserver(socketserver.baserequesthandler):
    
    def handle(self):  # 重写handle方法,处理socket请求
        print(f"连接来自{self.client_address}的客户端")
        commom_obj = commom()
        data_analy = dataanalysis()
        login_obj = login()
        while 1:
            # 执行用户选项：1、登陆系统 2、注册账号。并返回一个结果
            status_id = login_obj.run_client_choice(self.request, commom_obj)
            if status_id == "01":  # 登陆成功
                if not self.run_ftp_server(data_analy,commom_obj):  # 执行ftpserver主功能
                    break
            elif int(status_id) == -1: # client断开连接了
                break
        print(f"客户端{self.client_address}断开了连接")

    def run_ftp_server(self,data_analy,commom_obj):
        """"
        登陆成功后，接收客户端发来的命令，并进行处理
        :param data_analy:负责解析，执行客户端命令的对象
        :param commom_obj:程序执行时所需的数据对象
        :return 返回false代表客户端断开连接了
        """
        while true:
            try:
                cmd_len_pack = self.request.recv(4)  
                cmd_len = struct.unpack('i',cmd_len_pack)[0] # 获取命令长度，防止粘包  
            except exception:
                break
            recv_data = self.request.recv(cmd_len).decode('utf-8')  # 接收客户端数据
            if recv_data.upper() == "q":  # 客户端提出断开连接了
                break
            # 解析，处理客户端的命令
            data_analy.syntax_analysis(recv_data, self.request, commom_obj)
        return false

if __name__ == '__main__':
    print('运行ftp服务')
    ip_port = ('192.168.10.10',9000)
    # 创建并发服务端对象
    server = socketserver.threadingtcpserver(ip_port, myftpserver)
    # 开启服务
    server.serve_forever()

 1.4.2 服务端进入监听状态后，客户端发起连接请求，服务端接收连接请求后会等待客户单发来状态码，1表示请求登录ftp服务器，2表示客户端要注册用户，注册用户需要服务端手动反馈状态码1才可注册。处理用户登录，注册模块login.py核心代码如下：

class login(fileoperation):
    """
    登陆注册类。主要负责用户的登陆认证，和用户注册。
    """
    def run_client_choice(self,socket_obj,commom):
        """
        获取客户端的请求，1是登陆，2是注册用户
        :param socket_obj: socket对象
        :param commom: ftpserver运行时所需要的数据对象
        :return:
        """
        recv_choice = socket_obj.recv(1).decode("utf-8")  # 获取用户选项：1是登陆，2是注册用户
        if recv_choice == "1":  # client请求登陆
            return self.login_authen(socket_obj,commom)
        elif recv_choice == "2":  # client请求注册账号
            return self.register_user(socket_obj,commom)
        else:
            return -1  # client断开连接了

    # 用户登陆认证
    def login_authen(self,socket_obj,commom):
        """
        客户端登陆认证
        :param socket_obj:  socket对象
        :param commom:  ftpserver运行时需要的数据对象
        :return:返回1代表登陆成功
        """
        # 接收client发来的用户名，密码
        recv_userpwd = self.recv_data(socket_obj).decode("utf-8").split("|")  
        # 效验用户名密码
        check_ret = self.check_user_pwd(recv_userpwd, socket_obj,commom)
        if check_ret:  # 用户名密码正确
            self.check_user_home_dir(commom,recv_userpwd[0]) # 检测用户家目录
            return commom.status_info["login_success"]
        else:
            return commom.status_info["login_fail"]

   ...

    # 注册用户
    def register_user(self,socket_obj,commom):
        """
        :param socket_obj:
        :param commom:
        :return: 返回是否允许注册的结果，1允许客户端注册，2拒绝客户端注册
        """
        while true:
            choice_id = input("请输入回应码：1是允许注册，2是不允许注册:")
            if choice_id.isdigit() and 3 > int(choice_id) > 0:
                socket_obj.send(choice_id.encode("utf-8"))  # 发通知告知客户端，处理结果
                if choice_id == "1":  # 注册用户
                    return self.client_register(socket_obj, commom)
                return choice_id
            else:
                print("您输入的信息有误，请重新输入。")

   ...

 1.4.3 客户端登录成功后，服务端会等待接收客户端发来的命令，命令的解析，执行由dataanalysis.py模块执行，核心代码如下：

class dataanalysis(fileoperation):
    """
    数据分析处理类，主要负责解析client发送过来的指令。
    """
    def syntax_analysis(self,recv_data, socket_obj, commom):
        """
        负责解析客户端传来的数据。
        :param recv_data:接收到的客户端用户数据
        :param socket_obj:socket对象
        :param commom:数据对象
        :return:
        """
        clientdata = recv_data.split(" ")
        if hasattr(self,clientdata[0]):  # 判断对象方法是否存在
            get_fun = getattr(self,clientdata[0])#获取对象方法
            get_fun(clientdata,socket_obj,commom)  # 运行对象方法
        else:
            pass
    ...

执行客户端命令后，继续等待接收客户端发来的命令，如此循环...。

2、客户端

2.1 目录结构如下：

2.2 目录简介：

client：程序主目录。

bin：程序入口，程序启动文件main.py用于建立socket连接，然后调用ftpclient.py模块下的run_ftp_client方法运行程序。

app：程序主逻辑，目录下有四个模块如下：

          ftpclient.py：ftp客户端，根据用户选项，执行用户指令。

          login.py：认证注册模块，用于处理用户注册，登录认证。

          dataanalysis.py：命令解析模块，解析用户输入的命令，发给服务端获取结果。

          fileopertion.py：负责文件读，写。

lib：存放公共数据，有两个文件：

       commom.py：主要存放的是公共变量。

       help.txt：存放的是帮助文档，当用户执行help命令时会调用该文件。

2.3 模块中类的继承关系

2.4 执行流程

2.4.1 程序入口main.py，启动后会与ftp服务端建立连接，与服务端连接成功后会调用ftpclient.py模块下的run_ftp_client方法，执行用户功能。核心代码如下：

socket_obj = socket.socket(socket.af_inet,socket.sock_stream)
socket_obj.connect(("192.168.10.10",9000))

client_obj = client()
client_obj.run_ftp_client(socket_obj)  # 接收用户输入的选项，执行对应的功能

2.4.2 ftpclient.py模块下的run_ftp_client方法会打印菜单，并等待用户输入选项，执行相应功能，核心代码如下：

class client(login,dataanalysis):

    def run_ftp_client(self,socket_obj):
        """
        运行用户输入的选项：1、是登陆  2、是注册账号
        :return:
        """
        while true:
            self.login_menu()  # 打印系统菜单
            choice_id = self.get_user_choice()  # 获取用户输入的选项
            if choice_id:
                if self.run_user_choice(choice_id,socket_obj):
                    break
            else:
                print("您输入的有误")
    def get_user_choice(self):
        """
        获取用户输入的选项
        :return:
        """
        choice_id = input("请输入选项：")
        if choice_id.isdigit() and 4 > int(choice_id) > 0 or choice_id.upper() == "q":
            return choice_id
        return false
    def run_user_choice(self,choice_id,socket_obj):
        if choice_id == "1":  # 登陆系统
            socket_obj.send(choice_id.encode("utf-8"))  # 发通知告知服务器准备登陆
            if self.run_login(socket_obj) == true:  # 执行登陆
                return true
        elif choice_id == "2":  # 注册用户
            socket_obj.send(choice_id.encode("utf-8"))  # 请求服务器，注册用户
            self.register_user(socket_obj)  # 执行注册
        elif choice_id.upper() == "q":  # 退出程序
            socket_obj.send(choice_id.encode("utf-8"))  # 通知服务器，准备退出程序
            socket_obj.close()
            print("程序正常退出")
            return true

    def run_login(self,socket_obj,):
        """
        运行登陆认证模块，如果登陆成功执行程序主逻辑，否则重新登陆。
        :param socket_obj:
        :return:
        """
        if self.login_authention(socket_obj):
            while true:
                send_data = input(">>>").strip(" ")  # 获取发送数据（用户执行的命令）
                if send_data.upper() == "q":  # 正常退出程序
                    socket_obj.send(send_data.encode("utf-8"))  # 通知服务区断开连接
                    socket_obj.close()
                    print("程序正常退出")
                    return true
                if self.syntax_analysis(send_data, socket_obj):  # 解析用户数据并处理数据
                    print("异常退出")
                    return true
        return false

    def login_menu(self):
        print("-"*41)
        print("          欢迎登陆迷你ftpv1.0")
        print("-"*41)
        print("1、登陆系统")
        print("2、用户注册")
        print("q、退出程序")

2.4.3 login.py模块主要用于处理注册和登录的功能，核心代码如下：

class login(commom):
    def login_authention(self,socket_obj):
        """
        登陆认证
        :param socket_obj:socket 对象
        :return:
        """
        user_pwd = self.get_user_pwd()  # 获取用户名密码
        self.send_data(socket_obj,user_pwd)  # 将用户名和密码发给服务器
        recv_status = socket_obj.recv(2).decode("utf-8")  # 等待接收状态码
        print(self.status_info[recv_status])  # 打印状态码对应的结果
        if self.status_info[recv_status] == '登录成功':
            return true
        return false
    ...

    def register_user(self,socket_obj):
        """
        等待服务端反馈是否允许注册用户。
        :param socket_obj:
        :return:
        """
        print("请等待服务端回应.....")
        recv_status = socket_obj.recv(1).decode("utf-8")
        if recv_status == "1":  # 服务端同意申请账号
            user_pwd = self.get_regist_user_pwd()  # 获取注册用户名和密码
            if user_pwd:
                self.send_data(socket_obj,user_pwd)
                result = socket_obj.recv(2).decode("utf-8")
                print(self.status_info[result])
            else:
                print("用户名密码有误")
        else:  # 客户端拒绝申请账号的请求
            print("服务端拒绝了您申请账号的请求，请与管理员取得联系。")
        return false
    ...

2.4.4 用户登录成功后，会等待接收用户输入命令，由dataanalysis.py模块负责解析用户输入的命令，并将命令发给ftp服务器，然后接收服务器的反馈。核心代码如下：

class dataanalysis(fileoperation):

    def syntax_analysis(self,cmd,socket_obj):
        """
        解析用户输入的命令。
        :param cmd:用户执行的命令，如：put 上传的文件
        :param socket_obj:socket对象发送和接收数据
        :return:
        """
        cmd_split = cmd.split(" ")  # 将字符串命令分割成列表，用于验证命令是否存在
        if hasattr(self,cmd_split[0]):
            run_fun = getattr(self,cmd_split[0])
            run_fun(cmd_split,socket_obj)
        else:
            print("无效的命令")
    ...

三、功能演示