TCP 协议中的粘包问题
1. 粘包现象
基于 TCP 实现一个简易远程 cmd 功能
- # 服务端
- import socket
- import subprocess
- sever = socket.socket()
- sever.bind(('127.0.0.1', 33521))
- sever.listen()
- while True:
- client, address = sever.accept()
- while True:
- try:
- cmd = client.recv(1024).decode('utf-8')
- p1 = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr= subprocess.PIPE)
- data = p1.stdout.read()
- err_data = p1.stderr.read()
- client.send(data)
- client.send(err_data)
- except ConnectionResetError:
- print('connect broken')
- client.close()
- break
- sever.close()
- # 客户端
- import socket
- client = socket.socket()
- client.connect(('127.0.0.1', 33521))
- while True:
- cmd = input('请输入指令 (Q\q 退出)>>:').strip().lower()
- if cmd == 'q':
- break
- client.send(cmd.encode('utf-8'))
- data = client.recv(1024)
- print(data.decode('gbk'))
- client.close()
上述是基于 TCP 协议的远程 cmd 简单功能, 在运行时会发生粘包.
2, 什么是粘包?
只有 TCP 会发生粘包现象, UDP 协议永远不会发生粘包;
TCP:(transport control protocol, 传输控制协议) 流式协议. 在 socket 中 TCP 协议是按照字节数进行数据的收发, 数据的发送方发出的数据往往接收方不知道数据到底长度是多长, 而 TCP 协议由于本身为了提高传输的效率, 发送方往往需要收集到足够的数据才会进行发送. 使用了优化方法 (Nagle 算法), 将多次间隔较小且数据量小的数据, 合并成一个大的数据块, 然后进行封包. 这样, 接收端, 就难于分辨出来了, 必须提供科学的拆包机制. 即面向流的通信是无消息保护边界的.
UDP:(user datagram protocol, 用户数据报协议) 数据报协议. 在 socket 中 udp 协议收发数据是以数据报为单位, 服务端和客户端收发数据是以一个单位, 所以不会使用块的合并优化算法,, 由于 UDP 支持的是一对多的模式, 所以接收端的 skbuff(套接字缓冲区) 采用了链式结构来记录每一个到达的 UDP 包, 在每个 UDP 包中就有了消息头 (消息来源地址, 端口等信息), 这样, 对于接收端来说, 就容易进行区分处理了. 即面向消息的通信是有消息保护边界的.
TCP 协议不会丢失数据, UDP 协议会丢失数据.
udp 的 recvfrom 是阻塞的, 一个 recvfrom(x) 必须对唯一一个 sendinto(y), 收完了 x 个字节的数据就算完成, 若是 y>x 数据就丢失, 这意味着 udp 根本不会粘包, 但是会丢数据, 不可靠.
tcp 的协议数据不会丢, 没有收完包, 下次接收, 会继续上次继续接收, 己端总是在收到 ack 时才会清除缓冲区内容. 数据是可靠的, 但是会粘包.
3, 什么情况下会发生粘包?
1. 由于 TCP 协议的优化算法, 当单个数据包较小的时候, 会等到缓冲区满才会发生数据包前后数据叠加在一起的情况. 然后取的时候就分不清了到底是哪段数据, 这是第一种粘包.
2. 当发送的单个数据包较大超过缓冲区时, 收数据方一次就只能取一部分的数据, 下次再收数据方再收数据将会延续上次为接收数据. 这是第二种粘包.
粘包的本质问题就是接收方不知道发送数据方一次到底发送了多少数据, 解决问题的方向也是从控制数据长度着手, 也就是如何设置缓冲区的问题
4, 如何解决粘包问题?
解决问题思路: 上述已经明确粘包的产生是因为接收数据时不知道数据的具体长度. 所以我们应该先发送一段数据表明我们发送的数据长度, 那么就不会产生数据没有发送或者没有收取完全的情况.
1.struct 模块 (结构体)
struct 模块的功能可以将 python 中的数据类型转换成 C 语言中的结构体 (bytes 类型)
- import struct
- s = 123456789
- res = struct.pack('i', s)
- print(res)
- res2 = struct.unpack('i', res)
- print(res2)
- print(res2[0])
2. 粘包的解决方案基本版
既然我们拿到了一个可以固定长度的办法, 那么应用 struct 模块, 可以固定长度了.
为字节流加上自定义固定长度报头, 报头中包含字节流长度, 然后一次 send 到对端, 对端在接收时, 先从缓存中取出定长的报头, 然后再取真实数据
- # 服务器端
- import socket
- import subprocess
- import struct
- sever = socket.socket()
- sever.bind(('127.0.0.1', 33520))
- sever.listen()
- while True:
- client, address = sever.accept()
- while True:
- try:
- cmd = client.recv(1024).decode('utf-8')
- #利用子进程模块启动程序
- p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- #管道输出的信息有正确和错误的
- data = p.stdout.read()
- err_data = p.stderr.read()
- #先将数据的长度发送给客户端
- length = len(data)+len(err_data)
- #利用 struct 模块将数据的长度信息转化成固定的字节
- len_data = struct.pack('i', length)
- #以下将信息传输给客户端
- #1. 数据的长度
- client.send(len_data)
- #2. 正确的数据
- client.send(data)
- #2. 错误管道的数据
- client.send(err_data)
- except Exception as e:
- client.close()
- print('连接中断....')
- break
- # 客户端
- import socket
- import struct
- client = socket.socket()
- client.connect(('127.0.0.1', 33520))
- while True:
- cmd = input('请输入指令 >>:').strip().encode('utf-8')
- client.send(cmd)
- #1. 先接收传过来数据的长度是多少, 我们通过 struct 模块固定了字节长度为 4
- length = client.recv(4)
- #将 struct 的字节再转回去整型数字
- len_data = struct.unpack('i', length)
- print(len_data)
- len_data = len_data[0]
- print('数据长度为 %s:' % len_data)
- all_data = b''
- recv_size = 0
- #2. 接收真实的数据
- #循环接收直到接收到数据的长度等于数据的真实长度 (总长度)
- while recv_size <len_data:
- data = client.recv(1024)
- recv_size += len(data)
- all_data += data
- print('接收长度 %s' % recv_size)
- print(all_data.decode('gbk'))
- # 总结:
服务器端:
1. 在服务器端先收到命令, 打开子进程, 然后计算返回的数据的长度
2. 先利用 struct 模块将数据长度转成固定 4 个字节传给客户端
3. 再向客户端发送真实的数据.
客户端 (两次接收):
1. 第一次只接受 4 个字节, 因为长度数据就是 4 个字节. 这样防止了数据粘包. 解码得到长度数据
2. 第二次循环接收真实数据, 拼接真实数据完成解码读取数据.
很显然, 如果仅仅只是这样肯定无法满足在实际生产中一些需求. 那么该怎么修改?
我们可以把报头做成字典, 字典里包含将要发送的真实数据的详细信息, 然后 JSON 序列化, 然后用 struck 将序列化后的数据长度打包成 4 个字节 (4 个字节足够用了)
我们可以将自定义的报头设置成这种这种格式.
发送时:
1 先发报头长度
2 再编码报头内容然后发送
3 最后发真实内容
接收时:
1 先收报头长度, 用 struct 取出来
2 根据取出的长度收取报头内容, 然后解码, 反序列化
3 从反序列化的结果中取出待取数据的详细信息, 然后去取真实的数据内容
- # 服务器端
- import socket
- import subprocess
- import datetime
- import JSON
- import struct
- sever = socket.socket()
- sever.bind(('127.0.0.1', 33520))
- sever.listen()
- while True:
- client, address = sever.accept()
- while True:
- try:
- cmd = client.recv(1024).decode('utf-8')
- #启动子进程
- p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- #得到子进程运行的数据
- data = p.stdout.read() #子进程运行正确的输出管道数据, 数据读出来后是字节
- err_data = p.stderr.read() #子进程运行错误的输出管道数据
- #计算数据的总长度
- length = len(data) + len(err_data)
- print('数据总长度:%s' % length)
- #先需要发送报头信息, 以下为创建报头信息 (至第一次发送)
- #需要添加时间信息
- time_info = datetime.datetime.now()
- #设置一个字典将一些额外的信息和长度信息放进去然后 JSON 序列化, 报头字典
- masthead = {}
- #将时间数据放入报头字典中
- masthead['time'] = str(time_info) #时间格式不能被 JSON 序列化, 所以将其转化为字符串形式
- masthead['length'] = length
- #将报头字典 JSON 序列化
- json_masthead = JSON.dumps(masthead) #得到 JSON 格式的报头
- # 将 JSON 格式的报头编码成字节形式
- masthead_data = json_masthead.encode('utf-8')
- #利用 struct 将报头编码的字节的长度转成固定的字节 (4 个字节)
- masthead_length = struct.pack('i', len(masthead_data))
- #1. 发送报头的长度 (第一次发送)
- client.send(masthead_length)
- #2. 发送报头信息 (第二次发送)
- client.send(masthead_data)
- #3. 发送真实数据 (第三次发送)
- client.send(data)
- client.send(err_data)
- except ConnectionResetError:
- print('客户端断开连接...')
- client.close()
- break
- # 客户端
- import socket
- import struct
- import JSON
- client = socket.socket()
- client.connect(('127.0.0.1', 33520))
- while True:
- cmd = input('请输入 cmd 指令 (Q\q 退出)>>:').strip()
- if cmd == 'q':
- break
- #发送 CMD 指令至服务器
- client.send(cmd.encode('utf-8'))
- #1. 第一次接收, 接收报头信息的长度, 由于 struct 模块固定长度为 4 字节, 括号内直接填 4
- len_masthead = client.recv(4)
- #利用 struct 反解报头长度, 由于是元组形式, 取值得到整型数字 masthead_length
- masthead_length = struct.unpack('i', len_masthead)[0]
- #2. 第二次接收, 接收报头信息, 接收长度为报头长度 masthead_length 被编码成字节形式的 JSON 格式的字典,
- # 解字符编码得到 JSON 格式的字典 masthead_data
- masthead_data = client.recv(masthead_length).decode('utf-8')
- #得到报头字典 masthead
- masthead = JSON.loads(masthead_data)
- print('执行时间 %s' % masthead['time'])
- #通过报头字典得到数据长度
- data_length = masthead['length']
- #3. 第三次接收, 接收真实数据, 真实数据长度为 data_length
- # data = client.recv(data_length) #有可能真实数据长度太大会撑爆内存.
- #所以循环读取数据
- all_data = b''
- length = 0
- #循环直到长度大于等于数据长度
- while length < data_length:
- data = client.recv(1024)
- length += len(data)
- all_data += data
- print('数据的总长度:%s' % data_length)
- #我的电脑是 Windows 系统, 所以用 gbk 解码系统发出的信息
- print(all_data.decode('gbk'))
总结:
1.TCP 协议中, 会产生粘包现象. 粘包现象产生本质就是读取数据长度未知.
2. 解决粘包现象本质就是处理读取数据长度.
3. 报头的作用就是解决数据传输过程中数据长度怎么计算传达和传输其他额外信息的.
来源: https://www.cnblogs.com/5j421/p/10574390.html