python socket粘包问题的解决
什么是粘包?
须知:只有TCP有粘包现象,UDP永远不会粘包,为何,且听我娓娓道来
首先需要掌握一个socket收发消息的原理
发送端可以是一K一K地发送数据,而接收端的应用程序可以两K两K地提走数据,当然也有可能一次提走3K或6K数据,或者一次只提走几个字节的数据,也就是说,应用程序所看到的数据是一个整体,或说是一个流(stream),一条消息有多少字节对应用程序是不可见的,因此TCP协议是面向流的协议,这也是容易出现粘包问题的原因。而UDP是面向消息的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提取数据,不能一次提取任意字节的数据,这一点和TCP是很不同的。怎样定义消息呢?可以认为对方一次性write/send的数据为一个消息,需要明白的是当对方send一条信息的时候,无论底层怎样分段分片,TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。
例如基于tcp的套接字客户端往服务端上传文件,发送时文件内容是按照一段一段的字节流发送的,在接收方看了,根本不知道该文件的字节流从何处开始,在何处结束
所谓粘包问题主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的。
此外,发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去,这样接收方就收到了粘包数据。
此外,发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去,这样接收方就收到了粘包数据。
- TCP(transport control protocol,传输控制协议)是面向连接的,面向流的,提供高可靠性服务。收发两端(客户端和服务器端)都要有一一成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包。这样,接收端,就难于分辨出来了,必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
- UDP(user datagram protocol,用户数据报协议)是无连接的,面向消息的,提供高效率服务。不会使用块的合并优化算法,, 由于UDP支持的是一对多的模式,所以接收端的skbuff(套接字缓冲区)采用了链式结构来记录每一个到达的UDP包,在每个UDP包中就有了消息头(消息来源地址,端口等信息),这样,对于接收端来说,就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
- tcp是基于数据流的,于是收发的消息不能为空,这就需要在客户端和服务端都添加空消息的处理机制,防止程序卡住,而udp是基于数据报的,即便是你输入的是空内容(直接回车),那也不是空消息,udp协议会帮你封装上消息头,实验略
udp的recvfrom是阻塞的,一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失,这意味着udp根本不会粘包,但是会丢数据,不可靠
tcp的协议数据不会丢,没有收完包,下次接收,会继续上次继续接收,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会粘包。
两种情况下会发生粘包。
1、发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据了很小,会合到一起,产生粘包)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
from socket import * ip_port=('127.0.0.1',8080) tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5) conn,addr=tcp_socket_server.accept() data1=conn.recv(10) data2=conn.recv(10) print('----->',data1.decode('utf-8')) print('----->',data2.decode('utf-8')) conn.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket BUFSIZE=1024 ip_port=('127.0.0.1',8080) s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(ip_port) s.send('hello'.encode('utf-8')) s.send('feng'.encode('utf-8'))
2、接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
from socket import * ip_port=('127.0.0.1',8080) tcp_socket_server=socket(AF_INET,SOCK_STREAM) tcp_socket_server.bind(ip_port) tcp_socket_server.listen(5) conn,addr=tcp_socket_server.accept() data1=conn.recv(2) #一次没有收完整 data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的 print('----->',data1.decode('utf-8')) print('----->',data2.decode('utf-8')) conn.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket BUFSIZE=1024 ip_port=('127.0.0.1',8080) s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(ip_port) s.send('hello feng'.encode('utf-8'))
拆包的发生情况
当发送端缓冲区的长度大于网卡的MTU时,tcp会将这次发送的数据拆成几个数据包发送出去。
UDP没有粘包问题:(linux上执行)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#usr/bin/env python3 #encoding:utf-8 import socket server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) server.bind(('127.0.0.1',8080)) res1=server.recvfrom(2) # b"hello" print(res1) res2=server.recvfrom(3) # b"world" print(res2) server.close() ''' (b'he', ('127.0.0.1', 54085)) (b'wor', ('127.0.0.1', 54085)) '''
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
#usr/bin/env python3 #encoding:utf-8 import socket client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) client.sendto(b'hello',('127.0.0.1',8080)) client.sendto(b'world',('127.0.0.1',8080)) client.close()
解决粘包问题的方法:(以远程执行命令为例子)
一、比较low的解决办法:
#服务端进行了判断命令执行状态
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.bind(("127.0.0.1",9000)) phone.listen(5) #循环连接 while True: conn,addr=phone.accept() print("接到来自:{}的连接".format(addr[0])) #循环通信 while True: try: cmd=conn.recv(1024) if not cmd: print("客户端:{} 已经断开连接".format(addr[0])) break print("命令名称:%s" %cmd.decode("utf-8"),) obj = subprocess.Popen(cmd.decode("utf-8"), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) obj.wait() cmd_stat=subprocess.Popen.poll(obj) # print(cmd_stat) if not cmd_stat: cmd_data = obj.stdout.read() if not cmd_data: conn.send("命令:{} 执行成功".format(cmd.decode("utf-8")).encode("gbk")) continue # print(cmd_data.decode("gbk")) cmd_data_size=len(cmd_data) conn.send(str(cmd_data_size).encode("utf-8")) ack=conn.recv(1024) conn.send(cmd_data) print("send end") else: err_data = obj.stderr.read() conn.send(err_data) except Exception: print("客户端:{} 非正常退出".format(addr[0])) break conn.close() phone.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(("127.0.0.1",9000)) #循环通信 while True: cmd=input("请输入命令:>>>").strip() if not cmd:continue if cmd == "exit()": phone.close() break phone.send(cmd.encode("utf-8")) cmd_datasize = int((phone.recv(1024).decode("utf-8"))) phone.send("ok".encode("utf-8")) recv_size=0 cmd_res=b"" while recv_size<cmd_datasize: all_size=cmd_datasize-recv_size if all_size > 1024: cmd_data=phone.recv(1024) recv_size+=1024 cmd_res+=cmd_data else: cmd_data=phone.recv(all_size) recv_size+=all_size cmd_res+=cmd_data print(cmd_res.decode("gbk")) phone.close()
#服务端也可以不判断,直接将标准输出和错误输出都发给客户端(只是这样像mkdir这样的没有输出的命令执行时就会阻塞)
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket,subprocess ip_port=('127.0.0.1',8080) s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.bind(ip_port) s.listen(5) while True: conn,addr=s.accept() print('客户端',addr) while True: msg=conn.recv(1024) if not msg:break res=subprocess.Popen(msg.decode('utf-8'),shell=True,\ stdin=subprocess.PIPE,\ stderr=subprocess.PIPE,\ stdout=subprocess.PIPE) err=res.stderr.read() if err: ret=err else: ret=res.stdout.read() data_length=len(ret) conn.send(str(data_length).encode('utf-8')) data=conn.recv(1024).decode('utf-8') if data == 'recv_ready': conn.sendall(ret) conn.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket,time s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) res=s.connect_ex(('127.0.0.1',8080)) while True: msg=input('>>: ').strip() if len(msg) == 0:continue if msg == 'quit':break s.send(msg.encode('utf-8')) length=int(s.recv(1024).decode('utf-8')) s.send('recv_ready'.encode('utf-8')) send_size=0 recv_size=0 data=b'' while recv_size < length: data+=s.recv(1024) recv_size+=len(data) print(data.decode('utf-8'))
为何low:
程序的运行速度远快于网络传输速度,所以在发送一段字节前,先用send去发送该字节流长度,这种方式会放大网络延迟带来的性能损耗
二、优秀的解决姿势(使用自定义报头)
为字节流加上自定义固定长度报头,报头中包含字节流长度,然后一次send到对端,对端在接收时,先从缓存中取出定长的报头,然后再取真实数据
struct模块
该模块可以把一个类型,如数字,转成固定长度的bytes
>>> struct.pack('i',1111111111111)
。。。。。。。。。
struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围
使用演示:
import struct header=struct.pack('i',1234567812) print(header) #得到的是二进制类型,长度为4 total_size=struct.unpack("i",header) print(total_size,total_size[0],type(total_size[0])) ''' b'\x84\x02\x96I' (1234567812,) 1234567812 <class 'int'> '''
参数除了i还有:
示例:远程执行命令
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import subprocess import struct from socket import * server=socket(AF_INET,SOCK_STREAM) server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加 server.bind(('127.0.0.1',8083)) server.listen(5) # 服务端应该做两件事 # 第一件事:循环地从板连接池中取出链接请求与其建立双向链接,拿到链接对象 while True: conn,client_addr=server.accept() print("接到来自:{}的连接".format(client_addr[0])) # 第二件事:拿到链接对象,与其进行通信循环 while True: try: cmd=conn.recv(1024) if len(cmd) == 0:break obj=subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE ) stdout_res=obj.stdout.read() stderr_res=obj.stderr.read() total_size=len(stdout_res)+len(stderr_res) # 1、先发头信息(固定长度的bytes):对数据描述信息 # int->固定长度的bytes header=struct.pack('i',total_size) conn.send(header) # 2、再发真实的数据 conn.send(stdout_res) conn.send(stderr_res) except Exception: break conn.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import struct from socket import * client=socket(AF_INET,SOCK_STREAM) client.connect(('127.0.0.1',8083)) while True: cmd=input('请输入命令>>:').strip() if len(cmd) == 0:continue client.send(cmd.encode('utf-8')) # 解决粘包问题思路: # 一、先收固定长度的头:解析出数据的描述信息,包括数据的总大小total_size header=client.recv(4) total_size=struct.unpack('i',header)[0] # 二、根据解析出的描述信息,接收真实的数据 # 2、recv_size=0,循环接收,每接收一次,recv_size+=接收的长度 # 3、直到recv_size=total_size,结束循环 recv_size = 0 while recv_size < total_size: recv_data=client.recv(1024) #循环显示 recv_size+=len(recv_data) print(recv_data.decode('gbk'),end='') else: print("命令执行结束.") # 粘包问题出现的原因 # 1、tcp是流式协议,数据像水流一样粘在一起,没有任何边界区分 # 2、收数据没收干净,有残留,就会下一次结果混淆在一起 # 解决的核心法门就是:每次都收干净,不要任何残留
我们可以把报头做成字典,字典里包含将要发送的真实数据的详细信息,然后json序列化,然后用struck将序列化后的数据长度打包成4个字节(4个自己足够用了)
发送时:
先发报头长度
再编码报头内容然后发送
最后发真实内容
接收时:
先手报头长度,用struct取出来
根据取出的长度收取报头内容,然后解码,反序列化
从反序列化的结果中取出待取数据的详细信息,然后去取真实的数据内容
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
import socket,struct,json import subprocess phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它,在bind前加 phone.bind(('127.0.0.1',8080)) phone.listen(5) while True: conn,addr=phone.accept() while True: cmd=conn.recv(1024) if not cmd:break print('cmd: %s' %cmd) res=subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) err=res.stderr.read() print(err) if err: back_msg=err else: back_msg=res.stdout.read() headers={'data_size':len(back_msg)} head_json=json.dumps(headers) head_json_bytes=bytes(head_json,encoding='utf-8') conn.send(struct.pack('i',len(head_json_bytes))) #先发报头的长度 conn.send(head_json_bytes) #再发报头 conn.sendall(back_msg) #在发真实的内容 conn.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
from socket import * import struct,json ip_port=('127.0.0.1',8080) client=socket(AF_INET,SOCK_STREAM) client.connect(ip_port) while True: cmd=input('>>: ') if not cmd:continue client.send(bytes(cmd,encoding='utf-8')) head=client.recv(4) head_json_len=struct.unpack('i',head)[0] head_json=json.loads(client.recv(head_json_len).decode('utf-8')) data_len=head_json['data_size'] recv_size=0 recv_data=b'' while recv_size < data_len: recv_data+=client.recv(1024) recv_size+=len(recv_data) print(recv_data.decode('utf-8')) #print(recv_data.decode('gbk')) #windows默认gbk编码
上传文件下载文件思路:
import json,struct #假设通过客户端上传1T:1073741824000的文件a.txt #为避免粘包,必须自定制报头 header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值 #为了该报头能传送,需要序列化并且转为bytes head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输 #为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节 head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度 #客户端开始发送 conn.send(head_len_bytes) #先发报头的长度,4个bytes conn.send(head_bytes) #再发报头的字节格式 conn.sendall(文件内容) #然后发真实内容的字节格式 #服务端开始接收 head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式 x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度 head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式 header=json.loads(json.dumps(header)) #提取报头 #最后根据报头的内容提取真实的数据,比如 real_data_len=s.recv(header['file_size']) s.recv(real_data_len)