TCP黏包的解决方案

最新推荐文章于 2024-09-11 07:15:00 发布
最新推荐文章于 2024-09-11 07:15:00 发布
阅读量512 收藏 1
点赞数 2
分类专栏： Python网络编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39820671/article/details/102600187
版权

目录

一：解决方案一

（1）：原因分析

 （2）：代码实现

二：解决方案改进

（1）：struct模块

（2）：使用struct解决黏包 

（3）：自定义报头

预备知识：TCP协议的黏包现象

一：解决方案一

（1）：原因分析

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

 （2）：代码实现

server.py

import socket,subprocess
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    print('客户端',addr)
    while True:
        msg=conn.recv(1024)
        if not msg:break
        res=subprocess.Popen(msg.decode('utf-8'),shell=True,\
                            stdin=subprocess.PIPE,\
                         stderr=subprocess.PIPE,\
                         stdout=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            ret=err
        else:
            ret=res.stdout.read()
        data_length=len(ret)
        conn.send(str(data_length).encode('utf-8'))
        data=conn.recv(1024).decode('utf-8')
        if data == 'recv_ready':
            conn.sendall(ret)
    conn.close()

client.py

import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))
    length=int(s.recv(1024).decode('utf-8'))
    s.send('recv_ready'.encode('utf-8'))
    send_size=0
    recv_size=0
    data=b''
    while recv_size < length:
        data+=s.recv(1024)
        recv_size+=len(data)


    print(data.decode('utf-8'))

存在的问题：程序的运行速度远快于网络传输速度，所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗

二：解决方案改进

刚刚的方法，问题在于我们我们在发送！！！ 我们可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。

（1）：struct模块

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

Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> import struct
>>> struct.pack('i',1111111111111)
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    struct.pack('i',1111111111111)
struct.error: argument out of range
>>> struct.pack('i',214748364)
b'\xcc\xcc\xcc\x0c'
>>> 

注意：struct.error: 'i' format requires -2147483648 <= number <= 2147483647 #这个是范围

struct模块的用法：

import json,struct
#假设通过客户端上传1T:1073741824000的文件a.txt

#为避免粘包,必须自定制报头
header={'file_size':1073741824000,'file_name':'/a/b/c/d/e/a.txt','md5':'8f6fbf8347faa4924a76856701edb0f3'} #1T数据,文件路径和md5值

#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding='utf-8') #序列化并转成bytes,用于传输

#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack('i',len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度

#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式

#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack('i',head_len_bytes)[0] #提取报头的长度

head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头

#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header['file_size'])
s.recv(real_data_len)
#http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html
# struct的详细用法
__author__ = 'Linhaifeng'
import struct
import binascii
import ctypes

values1 = (1, 'abc'.encode('utf-8'), 2.7)
values2 = ('defg'.encode('utf-8'),101)
s1 = struct.Struct('I3sf')
s2 = struct.Struct('4sI')

print(s1.size,s2.size)
prebuffer=ctypes.create_string_buffer(s1.size+s2.size)
print('Before : ',binascii.hexlify(prebuffer))
# t=binascii.hexlify('asdfaf'.encode('utf-8'))
# print(t)


s1.pack_into(prebuffer,0,*values1)
s2.pack_into(prebuffer,s1.size,*values2)

print('After pack',binascii.hexlify(prebuffer))
print(s1.unpack_from(prebuffer,0))
print(s2.unpack_from(prebuffer,s1.size))

s3=struct.Struct('ii')
s3.pack_into(prebuffer,0,123,123)
print('After pack',binascii.hexlify(prebuffer))
print(s3.unpack_from(prebuffer,0))

（2）：使用struct解决黏包 

借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。

发送时接收时
先发送struct转换好的数据长度4字节先接受4个字节使用struct转换成数字来获取要接收的数据长度
再发送数据再按照长度接收数据

server.py

import socket,struct,json
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加

phone.bind(('127.0.0.1',8080))

phone.listen(5)

while True:
    conn,addr=phone.accept()
    while True:
        cmd=conn.recv(1024)
        if not cmd:break
        print('cmd: %s' %cmd)

        res=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        err=res.stderr.read()
        print(err)
        if err:
            back_msg=err
        else:
            back_msg=res.stdout.read()


        conn.send(struct.pack('i',len(back_msg))) #先发back_msg的长度
        conn.sendall(back_msg) #在发真实的内容

    conn.close()

client.py

#_*_coding:utf-8_*_
import socket,time,struct

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))



    l=s.recv(4)
    x=struct.unpack('i',l)[0]
    print(type(x),x)
    # print(struct.unpack('I',l))
    r_s=0
    data=b''
    while r_s < x:
        r_d=s.recv(1024)
        data+=r_d
        r_s+=len(r_d)

    # print(data.decode('utf-8'))
    print(data.decode('gbk')) #windows默认gbk编码

（3）：自定义报头

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

发送时接收时

先发报头长度

先收报头长度，用struct取出来
再编码报头内容然后发送根据取出的长度收取报头内容，然后解码，反序列化
最后发真实内容从反序列化的结果中取出待取数据的详细信息，然后去取真实的数据内容

server.py

import socket,struct,json
import subprocess
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加

phone.bind(('127.0.0.1',8080))

phone.listen(5)

while True:
    conn,addr=phone.accept()
    while True:
        cmd=conn.recv(1024)
        if not cmd:break
        print('cmd: %s' %cmd)

        res=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE)
        err=res.stderr.read()
        print(err)
        if err:
            back_msg=err
        else:
            back_msg=res.stdout.read()

        headers={'data_size':len(back_msg)}
        head_json=json.dumps(headers)
        head_json_bytes=bytes(head_json,encoding='utf-8')

        conn.send(struct.pack('i',len(head_json_bytes))) #先发报头的长度
        conn.send(head_json_bytes) #再发报头
        conn.sendall(back_msg) #在发真实的内容

    conn.close()

client.py

from socket import *
import struct,json

ip_port=('127.0.0.1',8080)
client=socket(AF_INET,SOCK_STREAM)
client.connect(ip_port)

while True:
    cmd=input('>>: ')
    if not cmd:continue
    client.send(bytes(cmd,encoding='utf-8'))

    head=client.recv(4)
    head_json_len=struct.unpack('i',head)[0]
    head_json=json.loads(client.recv(head_json_len).decode('utf-8'))
    data_len=head_json['data_size']

    recv_size=0
    recv_data=b''
    while recv_size < data_len:
        recv_data+=client.recv(1024)
        recv_size+=len(recv_data)

    print(recv_data.decode('utf-8'))
    #print(recv_data.decode('gbk')) #windows默认gbk编码

 

BlazarBruce
关注
专栏目录
TCP粘包分析与处理
weixin_33810006的博客
03-07 867
TCP粘包现象 TCP粘包通俗来讲，就是发送方发送的多个数据包，到接收方后粘连在一起，导致数据包不能完整的体现发送的数据。 TCP粘包原因分析 导致TCP粘包的原因，可能是发送方的原因，也有可能是接受方的原因。 发送方 由于TCP需要尽可能高效和可靠，所以TCP协议默认采用Nagle算法，以合并相连的小数据包，再一次性发送，以达到提升网络传输效率的目的。...
[netty]--最通用TCP黏包解决方案：LengthFieldBasedFrameDecoder和LengthFieldPrepender
热门推荐
惜暮
02-19 3万+
前面已经说过： TCP以流的方式进行数据传输，上层应用协议为了对消息进行区分，往往采用如下4种方式。 （1）消息长度固定：累计读取到固定长度为LENGTH之后就认为读取到了一个完整的消息。然后将计数器复位，重新开始读下一个数据报文。 （2）回车换行符作为消息结束符：在文本协议中应用比较广泛。 （3）将特殊的分隔符作为消息的结束标志，回车换行符就是一种特殊的结...
struct模块-黏包的解决方法
weixin_30252155的博客
01-29 186
黏包的解决方案 解决方案一 问题的根源在于，接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据。 #_*_coding:utf-8_*_import socket,subprocessip_port=('127.0.0.1',8080)s=socket.s...
什么是TCP的粘包、拆包问题？
最新发布
xycxycooo的博客
09-11 1101
作为一名编程博客专家，我深知程序员在日常工作中对网络通信的重视。TCP（传输控制协议）作为互联网的核心协议之一，其可靠性和有序性是其最大的优势。然而，TCP在数据传输过程中也会遇到一些问题，其中最常见的就是粘包（Sticky Packet）和拆包（Packet Fragmentation）问题。本文将深入探讨TCP的粘包、拆包问题，帮助你全面理解其工作原理及实际应用。TCP的粘包和拆包问题是网络通信中常见的问题，主要发生在发送方发送的数据包较小且频繁或较大且网络环境不稳定的情况下。
Linux tcp黏包解决方案
weixin_33924312的博客
11-14 177
tcpip协议使用"流式"（套接字）进行数据的传输，就是说它保证数据的可达以及数据抵达的顺序，但并不保证数据是否在你接收的时候就到达，特别是为了提高效率，充分利用带宽，底层会使用缓存技术，具体的说就是使用Nagle算法将小的数据包放到一起发送，但是这样也带来一个使用上的问题——黏包，黏包就是说一次将多个数据包发送出去，导致接收方不能进行正常的解析，示意图如下： 发生黏包一般有两种原因，一种是发送...
TCP粘包问题详解和解决方案【C语言】
qq_42037383的博客
07-20 4229
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输协议，它保证了数据的可靠性和顺序性。然而，由于TCP是基于字节流而不是消息的，因此在传输过程中可能会出现粘包（Packing）和拆包（Unpacking）问题。**粘包问题（TCP粘包现象）**指的是发送方在传输数据时，TCP协议把多个发送的小数据包“粘”在一起，形成一个大的数据包发送；或者接收方在接收数据时，多个小的数据包被“粘”在一起，形成一个大的数据包接收。
TCP粘包的解决办法
阳光心态，健康人生的博客
08-10 918
详情请看链接:https://www.cnblogs.com/kex1n/p/6502002.html
tcp 粘包 拆包解决思路以代码
04-25
在TCP协议中，由于其流式传输的特性，可能会出现“粘包”和“拆包”的问题。这两个术语是网络编程中的常见概念，主要涉及到数据在网络传输过程中的封装与...在实际项目中，需要根据具体需求和场景选择合适的解决方案。
TCP粘包的解决方案
weixin_46921682的博客
10-29 1177
前言 TCP粘包是个常见的问题，也有很多文章谈到。我根据自己的经验，争取用一种简洁易懂的办法把粘包的问题和解决办法和读者分享，希望留言指正。 基本概念 TCP本质上是数据流，从原理上看，没有包的概念，TCP包对应用程序员可以是透明的。 粘包实际上是把底层包的实现和上层流的概念混在一起。 粘包问题本质上是如何确定数据流的边界。 确定边界的几种典型办法 1. 固定长度法：一般在简单的私有协议中实现，可以简化流程，方便实现。 阻塞发送与接收： 发送：send(fd, wr_data_bu
TCP粘包、半包原理及解决方案
weixin_42226134的博客
02-17 2825
引言：TCP协议是网络通信协议中十分重要的协议，相比于UDP协议来说，它是一个可靠的传输协议，并且是一个面向数据流的协议；所谓面向数据流，其实是指数据传输是以流式的方式传输，这些传输的数据就像一条河里的水，他们之间是没有缝隙的，也就是说TCP协议传输的数据是无边界的；（其实TCP粘包概念个人感觉不恰当，毕竟TCP传输是以流式的方式） 而UDP是面向数据包的，收发数据包要么全收要么不收，数据包与数据...
C#中TCP粘包问题的解决方法
08-30
在TCP/IP通信中，"粘包"问题是一个常见的现象，特别是在C#等编程语言中进行TCP编程时。TCP粘包是指发送方发送的多个数据包在接收方接收时被合并成...在实际应用中，通常需要结合具体需求和场景来选择最合适的解决方案。
TCP 粘包解决办法
03-13
TCP 通信 粘包解决办法
【QT】自定义协议解决TCP粘包和拆包问题
08-11
本demo模拟了TCP通信中发送端和接收端的行为，并利用序列化和反序列化的思想，自定义协议来解决TCP的粘包和拆包问题。
TCP粘包，解决方案
Allen_Walker_QAQ的博客
05-20 288
what    所谓的粘包就是tcp的接收缓冲区由于各种原因导致多个消息没有边界的拼接在一起，无法区分上个包和下个包。我们也无法通过现有的函数接口将消息分开取出。备注：UDP不会why    为什么会出现这个问题呢，UDP为什么不会出现呢？这个要追溯到设计UDP和TCP的阶段。众所周知：TCP设计出来就是为了严谨的通讯，他是面向连接的，所以tcp需要3次握手，4次断连，并且传输中兼顾了重发等各种操...
TCP粘包解决方案
初音喵喵喵
02-29 273
TCP粘包解决方案 黏包的在客户端发送频率低的情况下粘包不明显，下面是原来的服务器中epoll一个事件可读的回调函数recvdata(event_infor *infor)，当调用这个函数然后recv()函数读缓冲区的数据，指定大小为BUFF_MAX-1，而BUFF_MAX我设置为1024，一般单次接收数据小于这个值，所以基本上就是读取了所有缓冲区数据，接收过程：收到数据->epoll可读-...
TCP通信粘包问题及解决方法
深耕嵌入式领用多年， 致力于分享嵌入式领域技术!
04-28 884
在网络通信中，TCP（传输控制协议）是一种可靠的、面向连接的协议，它确保了数据的可靠传输。然而，在实际的应用中，我们常常会遇到所谓的“粘包”问题。粘包是指发送方连续发送的数据在接收方收到时被“粘”在一起，导致接收方无法正确解析出每个数据包的边界，从而影响了数据的解析和处理。
TCP解决粘包问题
ZCC的专栏
09-14 1131
一、定义 二、解决办法 方法一：TCP提供了强制数据立即传送的操作指令push，TCP软件收到该操作指令后，就立即将本段数据发送出去，而不必等待发送缓冲区满； 方法二：发送固定长度的消息 方法三：把消息的尺寸与消息一块发送 方法四：双方约定每次传送的大小 方法五：双方约定使用特殊标记来区分消息间隔 方法六：标准协议按协议规则处理，如Sip协议 　为了避免粘包现象，可采取以下几种...
基于TCP远程执行命令粘包问题的解决
taxuebufeng的博客
04-20 150
基于TCP远程执行命令粘包问题的解决 运行的时候会发生粘包问题 服务端 import socket import subprocess HOST = '127.0.0.1' # 服务端绑定0.0.0.0的IP 放行所有的客户端请求 PORT = 8080 # 0-65535 1024前被系统保留使用 BUFSIZE = 1024 ADDR = (HOST, PORT) # STREAM 流式协议 TCP协议　　　　DGRAM　数据报协议　　UDP协议 server = sock
【Socket】解决TCP粘包问题
Smartlab411
06-04 1228
TCP粘包是指在使用TCP协议进行数据传输时，发送方连续发送的多个数据包在接收方收到时被黏合成一个大的数据包。这种现象可能会导致接收方无法正确解析数据，从而影响应用程序的正常运行。
TCP粘包现象解析与解决方案
"本文主要探讨了TCP协议中的粘包现象及其解决方案，通过Python代码示例进行解析。在TCP协议中，由于内部优化机制，可能会出现数据包合并的情况，即粘包。而UDP协议则不存在此类问题，因为它基于数据报进行传输。文章...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值