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
#struct模块中的函数pack的作用是将python的数据转成bytes,第一个参数通常是i(返回值为4位bytes,表示C语言中的int型数据,),如果超界限了可以用q(返回值为8位bytes,表示C语言中的long long型)
res = struct.pack('i', s)
print(res)

#unpack是将字节转回整型,结果是一个元组
res2 = struct.unpack('i', res)
print(res2)
#取元组中的值
print(res2[0])

###
b'\x15\xcd[\x07' #四位bytes
(123456789,) #元组
123456789 #初始整型数据

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.报头的作用就是解决数据传输过程中数据长度怎么计算传达和传输其他额外信息的。

python中TCP粘包问题解决方案的更多相关文章

  1. TCP 粘包及其解决方案(zz)

    首先,我们回顾一下 TCP 和 UDP 的头部信息: 具体说明看:http://www.cnblogs.com/aomi/p/7776582.html 我们知道,TCP 和 UDP 是 TCP/IP ...

  2. Netty4实战 - TCP粘包&拆包解决方案

    Netty是目前业界最流行的NIO框架之一,它的健壮性.高性能.可定制和可扩展性在同类框架中都是首屈一指.它已经得到了成百上千的商业项目的验证,例如Hadoop的RPC框架Avro就使用了Netty作 ...

  3. 剖析和解决Python中网络粘包的正确姿势

    目录 1.粘包及其成因 1.1.粘包产生 1.2.粘包产生的原因 2.尝试解决粘包 2.1.指定数据包的长度 2.2.固定数据包的长度 2.3.用函数实现多次调用发送数据 3.解决粘包问题的正确姿势 ...

  4. Python中Socket粘包问题的解决

    服务器端 import socket import subprocess import struct server = socket.socket() ip_port = ("192.168 ...

  5. python中TCP协议中的粘包问题

    TCP协议中的粘包问题 1.粘包现象 基于TCP实现一个简易远程cmd功能 #服务端 import socket import subprocess sever = socket.socket() s ...

  6. python socket的应用 以及tcp中的粘包现象

    1,socket套接字 一个接口模块,在tcp/udp协议之间的传输接口,将其影藏在socket之后,用户看到的是socket让其看到的. 在tcp中当做server和client的主要模块运用 #s ...

  7. Socket编程(4)TCP粘包问题及解决方案

    ① TCP是个流协议,它存在粘包问题 TCP是一个基于字节流的传输服务,"流"意味着TCP所传输的数据是没有边界的.这不同于UDP提供基于消息的传输服务,其传输的数据是有边界的.T ...

  8. python套接字解决tcp粘包问题

    python套接字解决tcp粘包问题 目录 什么是粘包 演示粘包现象 解决粘包 实际应用 什么是粘包 首先只有tcp有粘包现象,udp没有粘包 socket收发消息的原理 发送端可以是一K一K地发送数 ...

  9. TCP粘包问题及解决方案

    ① TCP是个流协议,它存在粘包问题 TCP是一个基于字节流的传输服务,"流"意味着TCP所传输的数据是没有边界的.这不同于UDP提供基于消息的传输服务,其传输的数据是有边界的.T ...

随机推荐

  1. query

  2. 【转载】 强化学习(十)Double DQN (DDQN)

    原文地址: https://www.cnblogs.com/pinard/p/9778063.html ------------------------------------------------ ...

  3. latex之插入向量、图片、编号

    1.向量 $\vec a$\qquad $\overleftarrow{AB}$\qquad $\overleftrightarrow{AB}$\qquad $\overrightarrow{AB}$ ...

  4. Python全栈之路----函数----内置方法

    Built-in Functions abs() dict() help() min() setattr() all() dir() hex() next() slice() any() divmod ...

  5. SQL-记录删除篇-007

    删除记录: delete * from table_name 解释:删除表中的所有数据 delete * from table_name where id<10 解释:删除表中id小于10的数据 ...

  6. 关于函数式编程(Functional Programming)

    初学函数式编程,相信很多程序员兄弟们对于这个名字熟悉又陌生.函数,对于程序员来说并不陌生,编程对于程序员来说也并不陌生,但是函数式编程语言(Functional Programming languag ...

  7. JDK 8 安装及配置

    1.配置java环境变量 注意:jdk文件夹名字取名不要用汉语取名. 1)鼠标右键点击我的电脑(计算机)选择属性栏 2)再点击左边高级系统设置 3)点击环境变量 4)在用户变量窗口新建变量名为JAVA ...

  8. LOJ 2991 「THUSC 2016」补退选——trie+线段树合并或vector

    题目:https://loj.ac/problem/2291 想了线段树合并的做法.就是用线段树维护 trie 的每个点在各种时间的操作. 然后线段树合并一番,线段树维护前缀最大值,就是维护最大子段和 ...

  9. ClassNotFoundException与NoClassDefFoundError异常

    方法 loadClass()抛出的是 java.lang.ClassNotFoundException异常(一般是jar冲突或者没有引入jar):方法 defineClass()抛出的是 java.l ...

  10. 实战 ant design pro 中的坑

    1.替换mock数据: 1.将:.roadhogrc.mock.js 中的代理模式替换 当不使用代理的时候就会将所有 /api/的链接换成 http://localhost:8080/ export ...