day27 粘包及粘包的解决方案

1.   粘包现象

  先了解一个词MTU

MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500个字节,
也就是1500B。如果本机一次需要发送的数据比网关的MTU大,大的数据包就会被拆开来传送,这样会产生很多数据包碎片,增加丢包率,降低网络速度

  超出缓冲区大小会报下面的错误,或者udp协议的时候,你的一个数据包的大小超过了你一次recv能接受的大小,也会报下面的错误,tcp不会,但是超出缓存区大小的时候,肯定会报这个错误。

  day27 粘包及粘包的解决方案

2.   模拟粘包现象

产生粘包的两种情况:

发送端需要等缓冲区满才发送出去,造成粘包(发送数据时间间隔很短,数据了很小,会合到一起,产生粘包)

发送方的缓存机制

接收方不及时接收缓冲区的包,造成多个包接收(客户端发送了一段数据,服务端只收了一小部分,服务端下次再收的时候还是从缓冲区拿上次遗留的数据,产生粘包) 

接收方的缓存机制

会产生粘包现象就是因为,接收方不知到发过来的数据长度,从那边是开始,那边是长度,以及接收方和发送方的缓存及优化机制,这是tcp socket类型才会出现的,因为tcp是面向流式数据,而udp 不会,

因为udp是面向包的数据形式,消息有边界,就算你发的是空消息(回车),也能发送,而tcp是不能发送回车的,如果数据长度大于udp 一次性能够发送的,他就会报错,直接弃包

下面,模拟一下产生粘包

import socket
import subprocess
server=socket.socket()
ip_port=("127.0.0.1",8099)
server.bind(ip_port)
server.listen() conn,addr=server.accept()
while 1:
from_client_cmd=conn.recv(1024).decode("utf-8") #接收客户端发来的指令 sub_obj=subprocess.Popen(
from_client_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
#四个参数,输入指令,显示窗口,标准化输出,错误显示
#subprocess read()之后得到的是bytes类型
cmd_ret=sub_obj.stdout.read() #指令执行的结果
print("结果长度",len(cmd_ret))
conn.send(cmd_ret) #把结果发送给客户端
import socket

client=socket.socket()
server_ip_port=("127.0.0.1",8099)
client.connect(server_ip_port) while 1:
client_cmd=input("请输入系统指令:") #向服务端发送指令
client.send(client_cmd.encode("utf-8")) from_server_msg=client.recv(1024).decode("gbk") #服务端执行指令之后返回的内容
print(from_server_msg) #打印出来发现和实际上的不一样(内容不全)

3.    粘包的解决方案一

利用的原理是把数据长度先告接收方,接收方接到长度产生应答,服务端确认接收方接到消息长度之后再发送数据

import socket
import subprocess server=socket.socket()
ip_port = ('127.0.0.1',8001)
server.bind(ip_port) server.listen()
conn,addr=server.accept()
while 1:
from_client_cmd=conn.recv(1024).decode("utf-8") #接收客户端发来的指令 sub_obj=subprocess.Popen(
from_client_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
) sub_ret=sub_obj.stdout.read() #执行指令得到结果
a=str(len(sub_ret)).encode("utf-8") #把指令内容的长度转换成字符串发给客户端
print(a)
conn.send(a) a=conn.recv(1024).decode("utf-8") #确认客户端接收到了返回内容的长度
if a=="ok":
conn.send(sub_ret) #发送指令的结果
else:
print("客户端没有收到消息")
import socket

client = socket.socket()
server_ip_port = ('127.0.0.1',8001)
client.connect(server_ip_port) while 1:
cmd=input("请输入指令")
client.send(cmd.encode("utf-8")) from_server_leng=client.recv(1024).decode('utf-8')
client.send(b"ok") from_server_msg=client.recv(int(from_server_leng)).decode("gbk")
print(from_server_msg)

4.    粘包解决方案二

和方案一大致类似,就是针对数据比较大的,切片进行

import socket

client = socket.socket()
server_ip_port = ('127.0.0.1',8001)
client.connect(server_ip_port) while 1:
cmd=input("请输入指令")
client.send(cmd.encode("utf-8")) from_server_leng=client.recv(1024).decode('utf-8')
client.send(b"ok") from_server_msg=client.recv(int(from_server_leng)).decode("gbk")
print(from_server_msg)

大数据解决方案 服务端

import subprocess
import socket server_ip_port=("127.0.0.1",8009)
client=socket.socket()
client.connect(server_ip_port) all_recv_len = 0 #接到的数据长度
all_data_byte = b'' #接到的数据 while 1:
cmd=input("请输入你的指令")
client.send(cmd.encode("utf-8")) data_len=client.recv(1024).decode("utf-8")#接到字符串的长度,解码
print(data_len)
data_real_len=int(data_len) #转换成整形 client.send(b"ok") #根服务端说接到了数据长度 while all_recv_len < data_real_len:
ever_rec_msg=client.recv(1024) #每次接收一段的信息
ever_rec_len=len(ever_rec_msg) #每接一段的长度
all_recv_len+=ever_rec_len #所接收总长度的累计
all_data_byte+=ever_rec_msg #接收的总信息 print(all_data_byte.decode("gbk"))

大数据解决方案 客户端

5.    粘包解决方案三

原理是:利用struct模块把消息长度的转换成四个字节,并发在消息前,接收方先接四个字节的内容,通过转换的到消息的长度,再根据接收到的长度去接收内容

import subprocess
import socket server_ip_port=("127.0.0.1",8009)
client=socket.socket()
client.connect(server_ip_port) all_recv_len = 0 #接到的数据长度
all_data_byte = b'' #接到的数据 while 1:
cmd=input("请输入你的指令")
client.send(cmd.encode("utf-8")) data_len=client.recv(1024).decode("utf-8")#接到字符串的长度,解码
print(data_len)
data_real_len=int(data_len) #转换成整形 client.send(b"ok") #根服务端说接到了数据长度 while all_recv_len < data_real_len:
ever_rec_msg=client.recv(1024) #每次接收一段的信息
ever_rec_len=len(ever_rec_msg) #每接一段的长度
all_recv_len+=ever_rec_len #所接收总长度的累计
all_data_byte+=ever_rec_msg #接收的总信息 print(all_data_byte.decode("gbk"))

struct 客户端

import socket
import subprocess
import struct server=socket.socket()
ip_port=("127.0.0.1",9000)
server.bind(ip_port) server.listen() conn,sddr=server.accept()
while 1:
c_cmd=conn.recv(1024).decode("utf-8") #接收指令 sub_obj=subprocess.Popen(
c_cmd,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
)
ret_cmd=sub_obj.stdout.read() #指令返回结果
data_len=len(ret_cmd) #得到结果长度 a=struct.pack("i",data_len) #把结果长度打包成4个字节 conn.send(a+ret_cmd) #把结果长度以前四个字节和真实内容拼接

struct 服务端

注:以上三种方案,其实就是先告诉消息的头和尾,让节后送方知道哪里是起始,哪里是结束

总结一下:粘包成因

TCP(transport control protocol,传输控制协议)是面向连接的,面向流的,提供高可靠性服务。
收发两端(客户端和服务器端)都要有一一成对的socket,因此,发送端为了将多个发往接收端的包,更有效的发到对方,使用了优化方法(Nagle算法),将多次间隔较小且数据量小的数据,合并成一个大的数据块,然后进行封包。
这样,接收端,就难于分辨出来了,必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
对于空消息:tcp是基于数据流的,于是收发的消息不能为空,这就需要在客户端和服务端都添加空消息的处理机制,防止程序卡住,而udp是基于数据报的,即便是你输入的是空内容(直接回车),也可以被发送,udp协议会帮你封装上消息头发送过去。
可靠黏包的tcp协议:tcp的协议数据不会丢,没有收完包,下次接收,会继续上次继续接收,己端总是在收到ack时才会清除缓冲区内容。数据是可靠的,但是会粘包。

tcp 的拆包机制:

当发送端缓冲区的长度大于网卡的MTU时,tcp会将这次发送的数据拆成几个数据包发送出去。
MTU是Maximum Transmission Unit的缩写。意思是网络上传送的最大数据包。MTU的单位是字节。 大部分网络设备的MTU都是1500。如果本机的MTU比网关的MTU大,大的数据包就会被拆开来传送,这样会产生很多数据包碎片,增加丢包率,降低网络速度。

socket数据传输过程中的用户态与内核态说明

发送端可以是一K一K地发送数据,而接收端的应用程序可以两K两K地提走数据,当然也有可能一次提走3K或6K数据,或者一次只提走几个字节的数据。
也就是说,应用程序所看到的数据是一个整体,或说是一个流(stream),一条消息有多少字节对应用程序是不可见的,因此TCP协议是面向流的协议,这也是容易出现粘包问题的原因。
而UDP是面向消息的协议,每个UDP段都是一条消息,应用程序必须以消息为单位提取数据,不能一次提取任意字节的数据,这一点和TCP是很不同的。
怎样定义消息呢?可以认为对方一次性write/send的数据为一个消息,需要明白的是当对方send一条信息的时候,无论底层怎样分段分片,TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件,发送时文件内容是按照一段一段的字节流发送的,在接收方看了,根本不知道该文件的字节流从何处开始,在何处结束

此外,发送方引起的粘包是由TCP协议本身造成的,TCP为提高传输效率,发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少,通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去,这样接收方就收到了粘包数据。

6.udp为什么不会产生粘包

UDP(user datagram protocol,用户数据报协议)是无连接的,面向消息的,提供高效率服务。
不会使用块的合并优化算法,, 由于UDP支持的是一对多的模式,所以接收端的skbuff(套接字缓冲区)采用了链式结构来记录每一个到达的UDP包,在每个UDP包中就有了消息头(消息来源地址,端口等信息),这样,对于接收端来说,就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。
对于空消息:tcp是基于数据流的,于是收发的消息不能为空,这就需要在客户端和服务端都添加空消息的处理机制,防止程序卡住,而udp是基于数据报的,即便是你输入的是空内容(直接回车),也可以被发送,udp协议会帮你封装上消息头发送过去。
不可靠不黏包的udp协议:udp的recvfrom是阻塞的,一个recvfrom(x)必须对唯一一个sendinto(y),收完了x个字节的数据就算完成,若是y;x数据就丢失,这意味着udp根本不会粘包,但是会丢数据,不可靠。
 用UDP协议发送时,用sendto函数最大能发送数据的长度为:65535- IP头(20) – UDP头(8)=65507字节。用sendto函数发送数据时,如果发送数据长度大于该值,则函数会返回错误。(丢弃这个包,不进行发送) 

    用TCP协议发送时,由于TCP是数据流协议,因此不存在包大小的限制(暂不考虑缓冲区的大小),这是指在用send函数时,数据长度参数不受限制。而实际上,所指定的这段数据并不一定会一次性发送出去,如果这段数据比较长,会被分段发送,如果比较短,可能会等待和下一次数据一起发送。

总结

黏包现象只发生在tcp协议中:

1.从表面上看,黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

2.实际上,主要还是因为接收方不知道消息之间的界限,不知道一次性提取多少字节的数据所造成的

7   .关于struct

import struct

num=123131
num_str=struct.pack("i",num)
print(num_str) #b'\xfb\xe0\x01\x00'
print(len(num_str)) a=struct.unpack("i",num_str)[0]
print(a) # (123131,) 返回的是元组

8    .关于获取shcket缓冲区的方法

import socket
from socket import SOL_SOCKET,SO_REUSEADDR,SO_SNDBUF,SO_RCVBUF
# from socket import SOL_SOCKET,SO_REUSEADDR,SO_SNDBUF,SO_RCVBUF
sk=socket.socket(type=socket.SOCK_DGRAM) sk.bind(("127.0.0.1",8090))
print('>>>>', (sk.getsockopt(SOL_SOCKET, SO_SNDBUF))/1024)
print(sk.getsockopt(SOL_SOCKET,SO_SNDBUF))
#>>>> 8.0
#

9    .验证连接的合法性

#_*_coding:utf-8_*_
from socket import *
import hmac,os secret_key=b'linhaifeng bang bang bang'
def conn_auth(conn):
'''
认证客户端链接
:param conn:
:return:
'''
print('开始验证新链接的合法性')
msg=os.urandom(32)
conn.sendall(msg)
h=hmac.new(secret_key,msg)
digest=h.digest()
respone=conn.recv(len(digest))
return hmac.compare_digest(respone,digest) def data_handler(conn,bufsize=1024):
if not conn_auth(conn):
print('该链接不合法,关闭')
conn.close()
return
print('链接合法,开始通信')
while True:
data=conn.recv(bufsize)
if not data:break
conn.sendall(data.upper()) def server_handler(ip_port,bufsize,backlog=5):
'''
只处理链接
:param ip_port:
:return:
'''
tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(backlog)
while True:
conn,addr=tcp_socket_server.accept()
print('新连接[%s:%s]' %(addr[0],addr[1]))
data_handler(conn,bufsize) if __name__ == '__main__':
ip_port=('127.0.0.1',9999)
bufsize=1024
server_handler(ip_port,bufsize) 服务端

服务端

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import * def client_handler(ip_port,bufsize=1024):
tcp_socket_client=socket(AF_INET,SOCK_STREAM)
tcp_socket_client.connect(ip_port) while True:
data=input('>>: ').strip()
if not data:continue
if data == 'quit':break tcp_socket_client.sendall(data.encode('utf-8'))
respone=tcp_socket_client.recv(bufsize)
print(respone.decode('utf-8'))
tcp_socket_client.close() if __name__ == '__main__':
ip_port=('127.0.0.1',9999)
bufsize=1024
client_handler(ip_port,bufsize) 客户端(非法:不知道加密方式)

客户单(非法 不知道加密方式)

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
from socket import *
import hmac,os secret_key=b'linhaifeng bang bang bang1111'
def conn_auth(conn):
'''
验证客户端到服务器的链接
:param conn:
:return:
'''
msg=conn.recv(32)
h=hmac.new(secret_key,msg)
digest=h.digest()
conn.sendall(digest) def client_handler(ip_port,bufsize=1024):
tcp_socket_client=socket(AF_INET,SOCK_STREAM)
tcp_socket_client.connect(ip_port) conn_auth(tcp_socket_client) while True:
data=input('>>: ').strip()
if not data:continue
if data == 'quit':break tcp_socket_client.sendall(data.encode('utf-8'))
respone=tcp_socket_client.recv(bufsize)
print(respone.decode('utf-8'))
tcp_socket_client.close() if __name__ == '__main__':
ip_port=('127.0.0.1',9999)
bufsize=1024
client_handler(ip_port,bufsize)

客户端非法:不知道secret_key)

上一篇:读书笔记_Effective_C++_条款二十四: 若所有参数皆需类型转换,请为此采用non-member函数


下一篇:unittest中的Empty suite错误