socket粘包

1 什么是粘包

须知：只有TCP有粘包现象，UDP永远不会粘包，首先需要掌握一个socket收发消息的原理，

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。

TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

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

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

1.TCP（传输控制协议）是面向连接的，面向流的，提供高可靠性服务，收发两端（客户端和服务端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来，必须提供科学的拆包机制，即面向流的通信是无消息保护边界的。

2.tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，放置程序卡主。

Tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容，数据是可靠的，但是会粘包。

两种情况下会发生粘包：

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

#服务端

import socket,subprocess

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.bind(("127.0.0.1",8000))

s.listen(5)

conn,addr=s.accept()

data1=conn.recv(1024)

data2=conn.recv(1024)

print("第一个包",data1)

print("第二个包",data2)

conn.close()

s.close()

执行结果

第一个包 b'helloworldSB'

第二个包 b''

#客户端

import socket,subprocess

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect(("127.0.0.1",8000))

s.send("helloworld".encode("utf-8"))

s.send("SB".encode("utf-8"))

s.close()

解决粘包问题1：low..low方法在客户端加个时间延迟，暂且可以解决问题。

#服务端

import socket,subprocess

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.bind(("127.0.0.1",8000))

s.listen(5)

conn,addr=s.accept()

data1=conn.recv(1024)

data2=conn.recv(1024)

print("第一个包",data1)

print("第二个包",data2)

conn.close()

s.close()

执行结果

第一个包 b'helloworld'

第二个包 b'SB'

#客户端

import socket,subprocess,time

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect(("127.0.0.1",8000))

s.send("helloworld".encode("utf-8"))

time.sleep(3)

s.send("SB".encode("utf-8"))

s.close()

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

#服务端

import socket,subprocess,time

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.bind(("127.0.0.1",8000))

s.listen(5)

conn,addr=s.accept()

data1=conn.recv(1)   #第一次收了个"h"

# time.sleep(5)

data2=conn.recv(1024) #第二次收了"elloworld"

print("第一个包",data1)

print("第二个包",data2)

conn.close()

s.close()

#客户端

import socket,subprocess,time

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect(("127.0.0.1",8000))

s.send("helloworld".encode("utf-8"))

time.sleep(3)

s.send("SB".encode("utf-8"))

s.close()

解决粘包问题2：比方法1要减少一个low　

问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据

low版本的解决方法　

模拟以太网协议封装报头：

报头特点:固定长度

包含对将要发送数据的描述信息

#服务端

import socket,subprocess,struct

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.bind(("127.0.0.1",8000))

s.listen(5)

while True:

    conn,addr=s.accept()

    while True:

        try:

            msg=conn.recv(1024)

            res=subprocess.Popen(msg.decode("utf-8"),

                                 shell=True,

                                 stdout=subprocess.PIPE,

                                 stderr=subprocess.PIPE)

            out_res=res.stdout.read()

            err_res=res.stderr.read()

            data_size=(len(out_res)+len(err_res))

            #发送报头

            conn.send(struct.pack("i",data_size))

            #发送真实数据部分

            conn.send(out_res)

            conn.send(err_res)

        except Exception:

            break

    conn.close()

s.close()

#客户端

#粘包 自己封装报头

import socket,struct

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect(("127.0.0.1",8000))

while True:

    msg=input("请输入命令:").strip()

    if not msg:continue

    s.send(bytes(msg,encoding="utf-8"))

    #收报头

    baotou=s.recv(4)

    data_size=struct.unpack("i",baotou)[0]

    #收收据

    recv_size=0

    recv_data=b""

    while recv_size <data_size:

        data=s.recv(1024)

        recv_size+=len(data)

        recv_data+=data

    print(recv_data.decode("gbk"))

s.close()

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

3.struct模块

该模块可以把一个类型，如数字，转成固定长度的bytes

>>> res=struct.pack('i',1111111111111) #打包成固定长度的bytes

>>> struct.unpack(“I”,res) #解包

2 大神解决粘包的方法

我们可以把报头做成字典，字典里包含将要发送的真实数据的详细信息，然后json序列化，然后用struck将序列化后的数据长度打包成4个字节（4个自己足够用了）

发送时：

先发报头长度

再编码报头内容然后发送

最后发真实内容

接收时：

先手报头长度，用struct取出来

根据取出的长度收取报头内容，然后解码，反序列化

从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

#服务端

import socket,subprocess,struct,json

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.bind(("127.0.0.1",8000))

s.listen(5)

while True:

    conn,addr=s.accept()

    while True:

        try:

            msg=conn.recv(1024)

            res=subprocess.Popen(msg.decode("utf-8"),

                                 shell=True,

                                 stdout=subprocess.PIPE,

                                 stderr=subprocess.PIPE)

            out_res=res.stdout.read()

            err_res=res.stderr.read()

            data_size=len(out_res)+len(err_res)

            head_dic={"data_size":data_size}

            head_json=json.dumps(head_dic)

            head_bytes=head_json.encode("utf-8")#报头

            #part1:先发报头的长度

            head_len=len(head_bytes)

            conn.send(struct.pack("i",head_len))

            #part2：再发送报头

            conn.send(head_bytes)

            #part3:最后发送数据真实部分

            conn.send(err_res)

            conn.send(out_res)

        except Exception:

             break

    conn.close()

s.close()

#客户端

import socket,struct,json

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

s.connect(("127.0.0.1",8000))

while True:

    msg=input("请输入命令:").strip()

    if not msg:continue

    s.send(bytes(msg,encoding="utf-8"))

    #part1:先收报头的长度

    head_struct=s.recv(4)

    head_len=struct.unpack("i",head_struct)[0]

    #part2:再收报头

    head_bytes=s.recv(head_len)

    head_json=head_bytes.decode("utf-8")

    head_dic=json.loads(head_json)

    data_size=head_dic["data_size"]

    #part3:收数据

    recv_size=0

    recv_data=b""

    while recv_size < data_size:

        data=s.recv(1024)

        recv_size+=len(data)

        recv_data+=data

    print(recv_data.decode("gbk"))

s.close()

巴特西

python--socket粘包

socket粘包

1 什么是粘包

2 大神解决粘包的方法

最新文章

热门文章