粘包 系统缓冲区 产生粘包的原因 解决粘包(recv的工作原理)
一丶粘包
只有TCP有粘包现象,UDP永远不会粘包
什么是粘包
存在于客户端接收数据时,不能一次性收取全部缓冲区中的数据.当下一次再有数据来时,缓冲区中剩余的数据会和新的数据'粘连'在一起.这就是粘包现象
简单代码,产生粘包现象:👇
### 客户端
# -*-coding:utf-8-*-
# Author:Ds
import socket
client=socket.socket()
client.connect(('127.0.0.1',7777))
while 1:
ui=input('请输入有命令:>>').strip()
client.send(ui.encode('utf-8')) # 向服务端发送指令
###***重点
# 客户端 send完之后, 就会执行recv() 等待接收数据
# 第一次 输入:dir指令 能够一次性接收完服务端返回的数据
# 第二次 输入:ipconfig指令 不能一次性接收完服务端返回的数据,部分残余数据放在缓冲区中
# 第三次 输入:dir指令时 由于上一次的返回的数据还没全部取完,新的指令数据还未到达缓冲区. # 总结: 如果缓冲区承载的数据过大时,每次只接收1024字节,当新的指令执行完,返回回来的数据会'怼'到缓冲区,造成数据粘连现象. 这就是粘包
ser_data=client.recv(1024) # 接收到服务端发送的字节码
print(ser_data.decode('utf-8')) # 解码 输出
client.close()
### 服务端
# -*-coding:utf-8-*-
# Author:Ds
import socket
import subprocess # 执行 系统cmd指令
server=socket.socket()
server.bind(("127.0.0.1",7777)) # 绑定IP和端口
server.listen(5)
while 1:
conn , addr=server.accept() # 等待接收连接
print(conn,addr)
while 1:
try:
cmd=conn.recv(1024) # 接收客户端发送过来的数据
cmd=cmd.decode('utf-8') # 将客户端发送过来的字节进行解码
# 执行客户端发来的系统命令
obj=subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
# 这是执行系统命令之后产生正确结果或错误结果,
# 字节形式
result=(obj.stdout.read()+obj.stderr.read()).decode('gbk')
conn.send(result.encode('utf-8') ) # 向客户端发送结果,字节形式
except Exception :
break
conn.close()
server.close()
二丶系统缓冲区
socket缓冲区
如下图:👇
1.每个socket被创建后,都会分配两个缓冲区,输入缓冲区(recv)和输出缓冲区(send)
2.send和recv都不是直接从网络中直接读取数据,而是从各自缓冲区读入和输出数据.
3.数据有可能刚被写入缓冲区就发送到网络,也可能在缓冲区中不断积压,多次写入的数据被一次性发送到网络,这取决于当时的网络情况、当前线程是否空闲等诸多因素,不由程序员控制
I/O缓存区特性
# 1.I/O缓冲区在每个TCP套接字中单独存在;
# 2.I/O缓冲区在创建套接字时自动生成;
# 3.即使关闭套接字也会继续传送输出缓冲区中遗留的数据;
# 4.关闭套接字将丢失输入缓冲区中的数据。
利用socket查看系统缓冲区的大小(8K)
# -*-coding:utf-8-*-
# Author:Ds
import socket
server = socket.socket()
server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) # 重用ip地址和端口
server.bind(('127.0.0.1',8010))
server.listen(3)
print(server.getsockopt(socket.SOL_SOCKET,socket.SO_SNDBUF)) # 输出缓冲区大小
print(server.getsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF)) # 输入缓冲区大小
# 65536 1K=1024B 1B=8bit
三丶产生粘包的原因
两种原因:
一:客户端(recv)不能一次性读取缓冲区中的数据.服务端发送的数据大于客户端能够接受的数据量,客户端下次接收的时候先去接收上次遗留在缓冲区中的数据.造成粘包
代码如下:👇
### 服务端
# -*-coding:utf-8-*-
# Author:Ds
import socket
import subprocess
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.bind(('127.0.0.1', 8080))
phone.listen(5)
while 1: # 循环连接客户端
conn, client_addr = phone.accept()
print(client_addr)
while 1:
try:
cmd = conn.recv(1024)
ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
correct_msg = ret.stdout.read()
error_msg = ret.stderr.read()
conn.send(correct_msg + error_msg)
except ConnectionResetError:
break
conn.close()
phone.close()
#### 客户端
# -*-coding:utf-8-*-
# Author:Ds
import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 买电话
phone.connect(('127.0.0.1',8080)) # 与客户端建立连接, 拨号
while 1:
cmd = input('>>>')
phone.send(cmd.encode('utf-8'))
from_server_data = phone.recv(1024)
print(from_server_data.decode('gbk'))
phone.close()
# 由于客户端发的命令获取的结果大小已经超过1024,那么下次在输入命令,会继续取上次残留到缓存区的数据
二:客户端(send)向服务端发送数据的时候,发送多条少量数据. 由于缓冲区的没有存满,缓冲区会把这些数据聚集在一起发送个服务端.造成粘包
代码如下:👇
### 服务端
# -*-coding:utf-8-*-
# Author:Ds
import socket
server=socket.socket()
server.bind(('127.0.0.1',7878))
server.listen(5)
conn ,addr = server.accept()
print(conn,addr)
data1=conn.recv(1024)
data2=conn.recv(1024)
data=data1+data2
print(data.decode('utf-8'))
conn.close()
server.close()
#### 客户端
# -*-coding:utf-8-*-
# Author:Ds
import socket
client=socket.socket()
client.connect(('127.0.0.1',7878))
client.send('123'.encode('utf-8'))
client.send('abc'.encode('utf-8'))
client.close()
## 两次返送信息时间间隔太短,数据小,造成服务端一次收取
四丶解决粘包(recv的工作原理)
简易版解决粘包
### 客户端
# -*-coding:utf-8-*-
# Author:Ds
import socket
client=socket.socket()
client.connect(('127.0.0.1',9989))
while 1:
ui=input('请输入指令:>>>').strip()
if len(ui)<0:continue
if ui.upper()=='Q':break
client.send(ui.encode('utf-8'))
message_size=int(client.recv(1024).decode('utf-8'))
client.send(b'recv_ready')
recv_size=0
data=b''
while recv_size<message_size:
data+=client.recv(1024)
recv_size+=len(data)
print(data.decode('utf-8'))
### 服务端
# -*-coding:utf-8-*-
# Author:Ds
import socket
import subprocess
server=socket.socket()
server.bind(('127.0.0.1',9989))
server.listen(5)
while 1:
conn,addr=server.accept()
print(conn,addr)
while 1:
cmd=conn.recv(1024).decode('utf-8')
obj=subprocess.Popen(cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
result=(obj.stdout.read()+obj.stderr.read()).decode('gbk').encode('utf-8')
conn.send(str(len(result)).encode('utf-8'))
data=conn.recv(1024).decode('utf-8')
if data=='recv_ready':
conn.sendall(result)
conn.close()
server.close()
使用struct模块
将一串数字转换成等长的字节.
格式多种: 常用 i
代码如下:👇
# -*-coding:utf-8-*-
# Author:Ds
import struct
# 'i' 的取值范围 -2147483648 <= number <= 2147483647
# i 模式 等长四位 , 将一个数字转化成等长度的bytes类型。
res=struct.pack('i',123456)
print(res,len(res))
### 通过unpack反解回来
data=struct.unpack('i',res)
print(data)
### 但是通过struct 处理不能处理太大
ret = struct.pack('q', 4323241232132324)
print(ret, type(ret), len(ret)) # 报错
low版本解决粘包
### 服务端 import socket import subprocess import struct phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) phone.bind(('127.0.0.1', 8080)) phone.listen(5) while 1: conn, client_addr = phone.accept() print(client_addr) while 1: try: cmd = conn.recv(1024) ret = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) correct_msg = ret.stdout.read() error_msg = ret.stderr.read() # 1 制作固定报头 total_size = len(correct_msg) + len(error_msg) header = struct.pack('i', total_size) # 2 发送报头 conn.send(header) # 发送真实数据: conn.send(correct_msg) conn.send(error_msg) except ConnectionResetError: break conn.close() phone.close() # 但是low版本有问题: # 1,报头不只有总数据大小,而是还应该有MD5数据,文件名等等一些数据。 # 2,通过struct模块直接数据处理,不能处理太大。
### 客户端 import socket import struct phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM) phone.connect(('127.0.0.1',8080)) while 1: cmd = input('>>>').strip() if not cmd: continue phone.send(cmd.encode('utf-8')) # 1,接收固定报头 header = phone.recv(4) # 2,解析报头 print(struct.unpack('i', header)) # 这是一个元组 (xxx,) total_size = struct.unpack('i', header)[0] # 取第一个元素 # 3,根据报头信息,接收真实数据 recv_size = 0 res = b'' while recv_size < total_size: recv_data = phone.recv(1024) res += recv_data recv_size += len(recv_data) print(res.decode('gbk')) phone.close()
旗舰版解决粘包
### 步骤解释 # 报头做成字典,字典里包含将要发送的真实数据的详细信息,然后json序列化,然后用struck将序列化后的数据长度打包成4个字节 #发送时: 1.先发报头长度 2.再编码报头内容然后发送 3.最后发真实内容 #接收时: 1.先手报头长度,用struct取出来 2.根据取出的长度收取报头内容,然后解码,反序列化 3.从反序列化的结果中取出待取数据的详细信息,然后去取真实的数据内容
案例代码,如下👇:
### 客户端 # -*-coding:utf-8-*- # Author:Ds import socket import struct import json client = socket.socket() # 实例化 socket对象 client.connect(('127.0.0.1', 8898)) # socket 连接IP和端口 while 1: ui = input('请输入指令:>>').strip() # 1. 发送 用户输入 指令 client.send(ui.encode('utf-8')) #2. 接收 struct 封装的头 字节形式 , 接收4个字节 head head = client.recv(4) # 3. struct反解 ,获得自定义报头的长度 dic_length = struct.unpack('i', head)[0] #4. 接收自定义字典报头内容 字节形式 head_dic = client.recv(int(dic_length)) #5. 反序列化自定义字典,先解码在反序列化 dic = json.loads(head_dic.decode('utf-8')) #6. 得到 真实内容的长度 content_length = dic['size'] # 7 设置一个字节变量 用于接收真实数据 content = b'' # 8 设置一个客户端接收长度 recv_size = 0 # 9 当客户端接收长度 小于 源数据长度,一直接收 while recv_size < content_length: # 累加 真实数据,以字节形式 content += client.recv(1024) # 累加 客户端接收的长度 recv_size += len(content) # 接收完毕,解码内容 print(content.decode('utf-8')) client.close()
### 服务端 # -*-coding:utf-8-*- # Author:Ds import socket import struct import json import time import subprocess server = socket.socket() # 实例化 socket对象 server.bind(('127.0.0.1', 8898)) # 绑定ip和端口 server.listen(5) # 邦迪监听连接 while 1: conn, addr = server.accept() # 等待连接 print(conn, addr) # 打印连接,和连接ip while 1: try: # 1. 接收客户端发送的 指令 ,字节形式 cmd = conn.recv(1024) # 2. 执行指令,得到结果 , 指令是字符形式(需要解码) obj = subprocess.Popen(cmd.decode('utf-8'), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE) #3.得到结果字节 ,转换成utf-8的字节格式 result = (obj.stdout.read() + obj.stderr.read()).decode('gbk').encode('utf-8') #4. 获得真实数据的字节长度 total_res_bytes = len(result) #5. 自定制字典报头 head_dic = { 'time': time.localtime(time.time()), 'size': total_res_bytes, # 字节长度 'MD5': 'XXXXX', 'file_name': '婚前视频', } # 6. 序列化字典 ,并将其转换成字节形式 head_dic_bytes = json.dumps(head_dic).encode('utf-8') #7. 使用 struct 封装报头字典head_dic_bytes ,固定长度(4个字节) # 封装成字节,发送给客户端,还是按照字节取出来. head = struct.pack('i', len(head_dic_bytes)) # 8 , 先将固定头发送给客户端 conn.send(head) # 9 . 再将自定制报头发送给客户端 conn.send(head_dic_bytes) # 10. 最后将真实结果发送给客户端 conn.send(result) ### 这里就是拼接字节 # 格式: 固定头 + 自定义报头 +真实数据 except Exception: break conn.close() server.close()