python笔记 socket编程

目录

一、什么是socket

 

Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

所以，我们无需深入理解tcp/udp协议，socket已经为我们封装好了，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

二、套接字的发展史及分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。 

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

三、套接字工作流程

 

 

 先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束

import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。

获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就
把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。
例如tcpSock = socket(AF_INET, SOCK_STREAM)

服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数
s.connect()     主动初始化TCP服务器连接
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall()         发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

面向锁的套接字方法
s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间
s.gettimeout()      得到阻塞套接字操作的超时时间

面向文件的套接字的函数
s.fileno()          套接字的文件描述符
s.makefile()        创建一个与该套接字相关的文

四、基于TCP的套接字

 服务端

import socket  #导入socket模块
ip_port = ('127.0.0.1', 80) #设置服务器IP地址，端口号
back_log = 5 #半连接池数量
buf_size = 1024 #从自己缓冲区接收数据的长度
server_dri = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #设置套接字家族，设置为TCP协议
server_dri.bind(ip_port) #绑定地址
server_dri.listen(back_log) #设置半连接池

while True:  #第一个循环，循环创建链接
    print('服务器等待连接...')
    con, add = server_dri.accept()  #阻塞监听客户端连接
    print('客户端已连接，会话线路%s，客户端地址%s'%(con, add))
    while True: #第二个循环，循环收发消息
        try: #异常处理，防止客户端异常关闭链接
            data = con.recv(buf_size) #接收消息，设置长度
            if not data:break #防止客户端关闭链接，服务端不断收空消息
            con.send(data.upper())  #发送消息，转换为大写 
            print('收到客户端消息',data.decode('utf-8'))
        except Exception as e:  #捕捉异常错误，退出链接
            print(e)
            break
    con.close()

客户端

from socket import * #因为soket中有很多方法要用，所以这样全部导入
ip_port = ('127.0.0.1', 80)
back_log = 5
buf_size = 1024
client_dri = socket(AF_INET, SOCK_STREAM)
client_dri.connect(ip_port) #跟服务端建立连接
while True: #循环收发数据
    data = input('>>')
    if data == 'quit':
        break
    client_dri.send(data.encode('utf-8'))
    data1 = client_dri.recv(buf_size)

    print('收到服务器发来的消息', data1.decode('utf-8'))

client_dri.close()

问题：

重启服务端时可能会遇到

 

 

 这个是由于你的服务端仍然存在四次挥手的time_wait状态在占用地址（如果不懂，请深入研究1.tcp三次握手，四次挥手 2.syn洪水攻击 3.服务器高并发情况下会有大量的time_wait状态的优化方法）

解决方法1

#加入一条socket配置，重用ip和端口

phone=socket(AF_INET,SOCK_STREAM)
phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
phone.bind(('127.0.0.1',8080))

解决方法2

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf

编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
 
然后执行 /sbin/sysctl -p 让参数生效。
 
net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；

net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；

net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。

net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

五、基于UDP的套接字

服务端

from socket import *
ip_port = ('127.0.0.1', 80)
buffer_size = 1024
server_dri = socket(AF_INET, SOCK_DGRAM) #设置套接字族，网络协议类型
server_dri.bind(ip_port)

while True:
    print('服务器等待消息：')
    con,addr = server_dri.recvfrom(buffer_size) #与TCP不同，收到的是一个元组消息
    print('收到客户端消息',con.decode('utf-8'),addr) #元组第一部分是数据，第二部分是客户端ip端口
    server_dri.sendto(con.upper(),addr) #发送消息也是以元组方式发送，要加上接收端的IP和端口

客户端

from socket import *  #导入模块
ip_port = ('127.0.0.1', 80)
buffer_size = 1024

server_dri = socket(AF_INET, SOCK_DGRAM)
while True:
    msg = input('>>:')
    server_dri.sendto(msg.encode('utf-8'),ip_port)
    con,addr = server_dri.recvfrom(buffer_size)
    print('收到服务端发来消息',con.decode('utf-8'))

 

 六、粘包

只有TCP有粘包现象，UDP永远不会粘包

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

1. TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
2. UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
3. tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住(四 TCP中有解释)，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头，报头是元组格式包含ip地址和端口号

udp的recvfrom是阻塞的，一个recvfrom(recvsize)必须对唯一一个sendinto(sendsize),收完了recvsize个字节的数据就算完成,若是sendsize>recvsize数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

拆包的发生情况

当发送端缓冲区的长度大于网卡的MTU时，tcp会将这次发送的数据拆成几个数据包发送出去。

补充问题一：为何tcp是可靠传输，udp是不可靠传输

tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的

而udp发送数据，对端是不会返回确认信息的，发送发不管对方是否收到，只管发送，因此不可靠

七、解决粘包的办法

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）

发送时：

先发报头长度

再编码报头内容然后发送

最后发真实内容

 

接收时：

先手报头长度，用struct取出来

根据取出的长度收取报头内容，然后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

 

TCP服务端

from socket import *
import subprocess
import struct
import hashlib
import json

ip_port = ('127.0.0.1', 8080)
black_log = 5
buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(black_log)

while True:
    print('服务已启动，等待客户连接......')
    con, add = tcp_server.accept()
    print('已连接客户端', add)
    while True:
        try:
            cmd = con.recv(buffer_size)
            if not cmd:break
            print('收到客户端消息:', cmd.decode('utf-8'))
            #接收客户端指令，并通过shell执行命令，得到结果放入PIPE管道中，管道中数据只能取一次
            res = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE,stdin=subprocess.PIPE, stderr=subprocess.PIPE)
            #读取管道信息
            err = res.stderr.read()
            if err:
                ret = err
            else:
                ret = res.stdout.read()
            #计算hash值
            hash_md5 = hashlib.md5(ret)
            #将MD5值转换成16进制格式
            md5 = hash_md5.hexdigest()
            #设置头部信息字典
            head_file = {'length':len(ret), 'md5':md5}
            # 为了该报头能传送,需要序列化
            head_json = json.dumps(head_file)
            # 为了该报头能传送转为bytes
            head_json_byte = bytes(head_json, encoding='utf-8')
            # 为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
            length = struct.pack('i', len(head_json_byte))#这4个字节里只包含了一个数字,该数字是报头的长度
            #先发报头长度
            con.send(length)
            #再发报头
            con.send(head_json_byte)
            #最后发真实数据
            con.sendall(ret)
        except Exception as e:
            print(e)
            break

 

TCP客户端

from socket import *
import struct
import json
import hashlib


ip_port = ('127.0.0.1', 8080)
black_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    cmd = input('>>').strip()
    if not cmd:continue
    tcp_client.send(cmd.encode('utf-8'))
    #接收固定4个字节的报头信息
    head_len = tcp_client.recv(4)
    #利用struct将报头长度解压出来，是元组形式，取0位置数据
    head_json_len = struct.unpack('i',head_len)[0]
    #通过长度接收报头信息，并反序列化为标准格式
    head_file = json.loads(tcp_client.recv(head_json_len).decode('utf-8'))
    data_size = head_file['length']
    data_md5 = head_file['md5']
    data = b''
    while len(data) < data_size:
        data_res = tcp_client.recv(buffer_size)
        data += data_res
    hash_md5 = hashlib.md5(data)
    md5 = hash_md5.hexdigest()
    if md5 != data_md5:
        print('收到信息与服务端发送的不一致！！,请重试！！')
        continue
    else:
        print(data.decode('GBK'))

 

八、socketserver实现并发

前面的tcp实验都只能一对一，不能实现并发，所以要用到socketserver模块实现一个多线程服务

基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环

socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）

 

多线程

 

 

 

多进程

 

 

 

 

 

soketserver几个关键点

1、第一新建一个类，继承socketserver.BaseRequestHandler

2、类中必须有一个方法 def handle(self)  通信相关的命令在这个方法下面执行， self.request相当于conn ，self.client_address相当于address

3、通过ThreadingTCPServer多线程实现链接循环，重复接收连接，并实例化给固定对象ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)

4、对象执行server_forever最终会调用BaseRequestHandler的handle方法，所以第二部必须写，ftpserver.serve_forever()

 

class MyTcpServer(socketserver.BaseRequestHandler):
    def handle(self):



s = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyTcpServer)
    s.serve_forever()

 上图原文件http://assets.processon.com/chart_image/5dea10d5e4b03c8e4933dc12.png

以下述代码为例，分析socketserver源码：

ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
ftpserver.serve_forever()

查找属性的顺序：ThreadingTCPServer->ThreadingMixIn->TCPServer->BaseServer

1. 实例化得到ftpserver，先找类ThreadingTCPServer的__init__,在TCPServer中找到，进而执行server_bind,server_active
2. 找ftpserver下的serve_forever,在BaseServer中找到，进而执行self._handle_request_noblock()，该方法同样是在BaseServer中
3. 执行self._handle_request_noblock()进而执行request, client_address = self.get_request()（就是TCPServer中的self.socket.accept()），然后执行self.process_request(request, client_address)
4. 在ThreadingMixIn中找到process_request，开启多线程应对并发，进而执行process_request_thread，执行self.finish_request(request, client_address)
5. 上述四部分完成了链接循环，本部分开始进入处理通讯部分，在BaseServer中找到finish_request,触发我们自己定义的类的实例化，去找__init__方法，而我们自己定义的类没有该方法，则去它的父类也就是BaseRequestHandler中找....

源码分析总结：

基于tcp的socketserver我们自己定义的类中的

1. 　　self.server即套接字对象
2. 　　self.request即一个链接
3. 　　self.client_address即客户端地址

基于udp的socketserver我们自己定义的类中的

1. 　　self.request是一个元组（第一个元素是客户端发来的数据，第二部分是服务端的udp套接字对象），如(b'adsf', <socket.socket fd=200, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
2. 　　self.client_address即客户端地址

八、并发的FTP作业

 

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

import socketserver
import json
import struct
import hashlib
import os
import sys
import subprocess

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)

class MyTcpServer(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        print(self.client_address)
        head_json = self.recvhdic()  # 获取头信息字典
        while not self.userauth(head_json):
            head_json = self.recvhdic()
        self.homes = self.homepath(head_json)
        while True:
            try:
                head_data= self.recvhdic()
                cmd = head_data['cmd']
                if hasattr(self, cmd):
                    fuc = getattr(self, cmd)
                    fuc(head_data)
            except Exception as e:
                print(e)
                break

    #认证模块，判断用户是否存在
    def userauth(self, args):
        user_list = self.openfile(os.path.normpath(BASE_DIR + r'/conf/userinfo.txt') )
        for i in user_list:
            if args['user'] == i['user']:
                if args['password'] == i['password']:
                    self.request.send('True'.encode('utf-8'))
                    return True
                else:
                    self.request.send('账户不存在或密码错误'.encode('utf-8'))
                    return False
        else:
            self.request.send('账户不存在或密码错误'.encode('utf-8'))
            return False

    #打开文件模块
    def openfile(self, filename):
        with open(filename, 'r') as f:
            fllist = f.read()
            fllist = fllist.split('\n')
            fllist.remove('')
            new_fllist = []
            for i in fllist:
                i = eval(i)
                new_fllist.append(i)

        return new_fllist

    #创建用户家目录
    def homepath(self, args):
        user = args['user']
        BASEDIR = os.path.dirname(os.path.dirname(__file__))
        homes = os.path.normpath(os.path.join(BASEDIR, 'home', user))
        if not os.path.exists(homes):
            os.mkdir(homes)
        return homes

    #计算文件MD5值
    def md5(self, filepath):
        filemd5 = hashlib.md5()
        with open(filepath, 'rb') as f:
            for line in f:
                filemd5.update(line)
        filemd5 = filemd5.hexdigest()
        return filemd5

    #获取头信息字典
    def recvhdic(self):
        while True:
            try:
                head_len = self.request.recv(4)
                if not head_len: return False
                head_json_len = struct.unpack('i', head_len)[0]
                head_json = json.loads(self.request.recv(head_json_len), encoding='utf-8')
                if not head_json:break
                return head_json
            except  Exception as e:
                print(e)
                break

    #发送数据头信息字典
    def sendhead(self,args):
        head_json = json.dumps(args).encode('utf-8')
        head_struct = struct.pack('i', len(head_json))
        self.request.send(head_struct)
        self.request.send(head_json)

    #上传文件
    def put(self, args):
        print(self.client_address, '开始上传')
        file_name = args['filename']
        file_size = args['filesize']
        file_md5 = args['md5']
        file_path = os.path.normpath(os.path.join(self.homes, file_name))
        recv_size = 0
        with open(file_path, 'wb') as f:
            while recv_size < file_size:
                data = self.request.recv(8192)
                f.write(data)
                recv_size += len(data)
        recvmd5 = self.md5(file_path)
        if recvmd5 != file_md5:
            print('文件不完整，或者被改变')
            os.remove(file_path)
        else:
            print('文件接受成功,存储在{}'.format(file_path), recvmd5)

    #下载文件
    def download(self, args):
        print(self.client_address, '开始下载')
        filename = args['filename']
        filepath = os.path.normpath(os.path.join(self.homes, filename))
        if not os.path.isfile(filepath):
            self.request.send('False'.encode('utf-8'))
            return False
        else:
            self.request.send('True'.encode('utf-8'))
            filesize = os.path.getsize(filepath)
        send_size = 0
        filemd5 = self.md5(filepath)
        head_dic = {'filesize': filesize, 'md5': filemd5}
        self.sendhead(head_dic)
        with open(filepath, 'rb') as f:
            for line in f:
                self.request.sendall(line)
                send_size += len(line)
        print('download successful', self.client_address)

    #查看目录
    def dirpath(self, args):
        print('查看目录')
        win_cmd = 'dir ' + '\"' + self.homes + '\"'
        data = subprocess.Popen(win_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE )
        err = data.stderr.read().decode('gbk')
        if err:
            res = err.encode('utf-8')
        else:
            res = data.stdout.read().decode('gbk')
        cmd_list = res.split('\r\n')
        new_dir_dic = {}
        for line in cmd_list:
            if line.startswith('2'):
                i = line.rsplit(' ')
                file = i[-1]
                if file.startswith('.'):
                    continue
                else:
                    filepath = os.path.normpath(os.path.join(self.homes, file))
                    if os.path.isfile(filepath):
                        new_dir_dic[file] = '文  件'
                    else:
                        new_dir_dic[file] = '文件夹'
        res = json.dumps(new_dir_dic).encode('utf-8')
        self.request.sendall(res)

    #切换目录
    def cdpath(self,args):
        pass


if __name__ == '__main__':
    s = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyTcpServer)
    s.serve_forever()

#!/usr/bin/env python
# _*_ coding:utf-8 _*_

import socketserver
import json
import struct
import hashlib
import os
import sys
import subprocess

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
sys.path.append(BASE_DIR)

class MyTcpServer(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        print(self.client_address)
        head_json = self.recvhdic()  # 获取头信息字典
        while not self.userauth(head_json):
            head_json = self.recvhdic()
        self.homes = self.homepath(head_json)
        while True:
            try:
                head_data= self.recvhdic()
                cmd = head_data['cmd']
                if hasattr(self, cmd):
                    fuc = getattr(self, cmd)
                    fuc(head_data)
            except Exception as e:
                print(e)
                break

    #认证模块，判断用户是否存在
    def userauth(self, args):
        user_list = self.openfile(os.path.normpath(BASE_DIR + r'/conf/userinfo.txt') )
        for i in user_list:
            if args['user'] == i['user']:
                if args['password'] == i['password']:
                    self.request.send('True'.encode('utf-8'))
                    return True
                else:
                    self.request.send('账户不存在或密码错误'.encode('utf-8'))
                    return False
        else:
            self.request.send('账户不存在或密码错误'.encode('utf-8'))
            return False

    #打开文件模块
    def openfile(self, filename):
        with open(filename, 'r') as f:
            fllist = f.read()
            fllist = fllist.split('\n')
            fllist.remove('')
            new_fllist = []
            for i in fllist:
                i = eval(i)
                new_fllist.append(i)

        return new_fllist

    #创建用户家目录
    def homepath(self, args):
        user = args['user']
        BASEDIR = os.path.dirname(os.path.dirname(__file__))
        homes = os.path.normpath(os.path.join(BASEDIR, 'home', user))
        if not os.path.exists(homes):
            os.mkdir(homes)
        return homes

    #计算文件MD5值
    def md5(self, filepath):
        filemd5 = hashlib.md5()
        with open(filepath, 'rb') as f:
            for line in f:
                filemd5.update(line)
        filemd5 = filemd5.hexdigest()
        return filemd5

    #获取头信息字典
    def recvhdic(self):
        while True:
            try:
                head_len = self.request.recv(4)
                if not head_len: return False
                head_json_len = struct.unpack('i', head_len)[0]
                head_json = json.loads(self.request.recv(head_json_len), encoding='utf-8')
                if not head_json:break
                return head_json
            except  Exception as e:
                print(e)
                break

    #发送数据头信息字典
    def sendhead(self,args):
        head_json = json.dumps(args).encode('utf-8')
        head_struct = struct.pack('i', len(head_json))
        self.request.send(head_struct)
        self.request.send(head_json)

    #上传文件
    def put(self, args):
        print(self.client_address, '开始上传')
        file_name = args['filename']
        file_size = args['filesize']
        file_md5 = args['md5']
        file_path = os.path.normpath(os.path.join(self.homes, file_name))
        recv_size = 0
        with open(file_path, 'wb') as f:
            while recv_size < file_size:
                data = self.request.recv(8192)
                f.write(data)
                recv_size += len(data)
        recvmd5 = self.md5(file_path)
        if recvmd5 != file_md5:
            print('文件不完整，或者被改变')
            os.remove(file_path)
        else:
            print('文件接受成功,存储在{}'.format(file_path), recvmd5)

    #下载文件
    def download(self, args):
        print(self.client_address, '开始下载')
        filename = args['filename']
        filepath = os.path.normpath(os.path.join(self.homes, filename))
        if not os.path.isfile(filepath):
            self.request.send('False'.encode('utf-8'))
            return False
        else:
            self.request.send('True'.encode('utf-8'))
            filesize = os.path.getsize(filepath)
        send_size = 0
        filemd5 = self.md5(filepath)
        head_dic = {'filesize': filesize, 'md5': filemd5}
        self.sendhead(head_dic)
        with open(filepath, 'rb') as f:
            for line in f:
                self.request.sendall(line)
                send_size += len(line)
        print('download successful', self.client_address)

    #查看目录
    def dirpath(self, args):
        print('查看目录')
        win_cmd = 'dir ' + '\"' + self.homes + '\"'
        data = subprocess.Popen(win_cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE )
        err = data.stderr.read().decode('gbk')
        if err:
            res = err.encode('utf-8')
        else:
            res = data.stdout.read().decode('gbk')
        cmd_list = res.split('\r\n')
        new_dir_dic = {}
        for line in cmd_list:
            if line.startswith('2'):
                i = line.rsplit(' ')
                file = i[-1]
                if file.startswith('.'):
                    continue
                else:
                    filepath = os.path.normpath(os.path.join(self.homes, file))
                    if os.path.isfile(filepath):
                        new_dir_dic[file] = '文  件'
                    else:
                        new_dir_dic[file] = '文件夹'
        res = json.dumps(new_dir_dic).encode('utf-8')
        self.request.sendall(res)

    #切换目录
    def cdpath(self,args):
        pass


if __name__ == '__main__':
    s = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyTcpServer)
    s.serve_forever()