day27 粘包及粘包的解决方案

2021-07-23 21:59:05

1. 粘包现象

　　先了解一个词MTU

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

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

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)

码农公寓

总结

相关文章