FTP

服务端：

import socket
import socketserver
import struct
import json
import os
import time
import subprocess

#os.path.abspath(__file__) 显示当前文件的绝对路径
#os.path.dirname           显示当前文件/目录 所在的目录
#os.path.normpath()        规范路径，在Linux平台自动转换路径


flag="FBI"

class Ftp_server(socketserver.BaseRequestHandler):
    code="utf-8"
    def handle(self):
        while True:
            pwd=os.getcwd()
            os.chdir(pwd)

            recv_head_len=struct.unpack("i",self.request.recv(4))[0] #接收 客户端发来固定的报头长度数字（字节格式）
            recv_head_data=json.loads(self.request.recv(recv_head_len)) #接收报头信息 (字典类型)
                                                 #根据客户端发来的报头，执行响应的方法，fla=FBI登录
            if recv_head_data.get("flag")==flag:# print(recv_head_data)    # d1 = {"name": name, "pwd": pwd,"cmd":cmd,"flag":flag}
                self.login(recv_head_data)
                print(recv_head_data)
            if hasattr(self,recv_head_data["cmd"]):#其他情况 就是 put 和 get操作
                cmd=recv_head_data["cmd"]
                file=recv_head_data['file_name']
                print(cmd,file)
                func=getattr(self,cmd)
                func(cmd,file,recv_head_data)


    def put(self,cmd,file,head_data):  #上传
        data_size =head_data["data_size"]
        print(data_size)
        res =head_data

        file_path = os.path.normpath(os.path.join(r"E:full_stackday38"  #拼接用户路径
                                                  'put',
                                                  res["name"],
                                                  res['pwd']))

                                                #姓名+密码=用户目录
        if os.path.exists(file_path) == True:  # 如果用户存在
            os.chdir(file_path)                 #判断用户目录下的文件是否存在
            os.path.exists(file)
            if os.path.exists(file):  # 如果文件存在 就代表可以断定续传,打开这个文件，先记录一下末尾的tell
                print(file)
                with open(file, 'rb') as f:
                    f.seek(0, 2)
                    sek = f.tell()
                    print("文件的sek%s" % sek)

                if head_data["data_size"] ==sek:  #如果末尾的位置 和文件的大小 相等 就代表已经存在了 无需上传
                    self.request.send(struct.pack('i',sek))
                    print("上传的文件已经完成。")


                else:                               #如果文件不完整，就代表断点续传
                    self.request.send(struct.pack('i',sek))
                    with open(file, 'wb') as f:
                        f.seek(sek)
                        recv_size = 0
                        while recv_size < data_size:  # 开写数据
                            data = self.request.recv(1024)
                            f.write(data)
                            recv_size += len(data)


            else:                                   # 如果文件不存在，从头开始写
                self.request.send(struct.pack('i', 0))
                with open(file, 'wb') as f:
                    recv_size = 0
                    while recv_size < data_size:  # 开写数据
                        data = self.request.recv(1024)
                        f.write(data)
                        recv_size += len(data)
                self.request.send("上传完成".encode("utf-8"))
                time.sleep(1)
        else: #如果用户目录不存在
            os.makedirs(file_path)
            os.chdir(file_path)
            self.request.send(struct.pack('i',0))
            with open(file, 'wb') as f:
                recv_size = 0
                while recv_size < data_size:  # 开写数据
                    data = self.request.recv(1024)
                    f.write(data)
                    recv_size += len(data)
            self.request.send("上传完成".encode("utf-8"))
            time.sleep(1)

    def get(self,cmd,file,head_data):  #下载方法
        filesize=os.path.getsize(file)
        d3={"name":file,"data_size":filesize}
        bytes_d1 = json.dumps(d3).encode("utf-8")
        len_d1 = len(bytes_d1)
        struct_len = struct.pack("i",len_d1)
        self.request.send(struct_len)
        self.request.send(bytes_d1)
        with open(file,'rb') as f:
            for i in f:
                self.request.send(i)
            else:f.close()
        time.sleep(2)
        self.request.send("接收完毕".encode("utf-8"))

    def login(self,recv_head_data):#{'file_path': 'alex\123', 'cmd': 'login', 'file_name': 'c'}

        file_path=os.path.normpath(os.path.join(r"E:full_stackday38"
                                      'put',
                                      recv_head_data["name"],
                                      recv_head_data['pwd']))
        os.chdir(file_path)
        cmd = recv_head_data['cmd']
        print(cmd)
        act_res = subprocess.Popen(cmd, shell=True,
                                   stdout=subprocess.PIPE,
                                   stdin=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
        act_err = act_res.stderr.read()
        if act_err:
            ret = act_err
        else:
            ret = act_res.stdout.read()
        bytes_len = len(ret)
        self.request.send(struct.pack("i",bytes_len))
        self.request.send(ret)


if __name__ == '__main__':
    obj=socketserver.ThreadingTCPServer(("127.0.0.1",8080),Ftp_server)
    obj.serve_forever()

客户端

import socket
import struct
import json
import os
import mode
flag="FBI"
user_dict={"alex":'123','egon':'456'}     #DB

l=["put 文件名", 'get 文件名', "login 登录" ]

#类的 __init__方法在对象实例化时自动执行，所以实例化之后对象就执行了__init__中定义的东西
class Client():
    def __init__(self,Addr_server):
        self.addr_server=Addr_server
        self.socket = socket.socket()
        self.client_connect()

    def client_connect(self):
        self.socket.connect(self.addr_server)

    def run(self):
        while True:
            name_inpu = input("请输入用户名: ")
            psw_inpu = input("请输入密码:").strip()
            if user_dict.get(name_inpu) == psw_inpu:
                    for i in l:
                        print(i.center(50))
            else:
                print("用户名或者密码错误!".center(50))
                continue

            flie_inpu = input("请输入FTP操作:  ").strip()
            if flie_inpu=="login":
                self.login(name_inpu,psw_inpu)
            else:
                cmd, file = flie_inpu.split()
                print(cmd,file)
                if hasattr(mode, cmd):  # 根据不同的请求，设置不同的报头的格式。
                    func = getattr(mode, cmd)
                    struct_len,bytes_d1,d1 = func(name_inpu,psw_inpu,cmd,file)
                else:
                    continue
                self.socket.send(struct_len) #
                self.socket.send(bytes_d1)
                if hasattr(self, cmd): #根据不同的报头格式，执行不同的方法
                    func = getattr(self, cmd)
                    func(d1)
                else:
                    continue

    def get(self,d1): #下载操作
        server_head_len=struct.unpack("i",self.socket.recv(4))[0]   #接收 服务端报头的长度
        server_heaa_data=json.loads(self.socket.recv(server_head_len))#接收服务端报头信息
        print(server_heaa_data)
        server_data_size=server_heaa_data['data_size']
        server_data_name=server_heaa_data['name']
        with open(server_data_name,'wb') as f:
            recv_size=0
            while recv_size < server_data_size:  # 开下载数据
                        data = self.socket.recv(1024)
                        f.write(data)
                        recv_size += len(data)
            else:
                print(self.socket.recv(1024).decode("utf-8"))

    def put(self,d1):  #上传操作
        print(type(d1))
        struct_sek=self.socket.recv(4)
        sek=struct.unpack('i',struct_sek)[0]
        print("传来的sek%s"% sek)
        print(d1[ 'data_size'])
        if sek==d1[ 'data_size']:
            print("已经上传")
        else:
            with open(d1["file_name"],'rb') as f:  # 上传
                f.seek(sek)
                for i in f:
                    self.socket.send(i)

    def login(self,name,pwd):               # 登录
        while True:                       #循环发送报头给服务端，让服务端做判断，返回执行结果；
            cmd=input('请输入命令-------->').strip()
            d1={"name": name, "pwd": pwd,"cmd":cmd,"flag":flag}
            bytes_d1 = json.dumps(d1).encode("utf-8")
            len_dl = len(bytes_d1)
            struct_len = struct.pack("i", len_dl)
            self.socket.send(struct_len)
            self.socket.send(bytes_d1)
            data_len=struct.unpack("i",self.socket.recv(4))[0]
            res=self.socket.recv(data_len).decode("gbk")
            print(res)













c=Client(("127.0.0.1",8080))
c.run()