粘包问题

目录:

　　　　粘包内存

　　　　粘包原因

　　　　远程执行系统命令

　　　　解决粘包

　　　　自定义报头

粘包内存(仅TCP):

 粘包原因:

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

TCP内部nagle算法,优化传输效率:数据量小且间隔时间小的数据会合并为一次进行发送

未解决前:

服务端:

from socket import *

server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8080))
server.listen(5)

conn,addr=server.accept()

res1=conn.recv(1024)
print('第一次；',res1)

res2=conn.recv(1024)
print('第二次；',res2)

res3=conn.recv(1024)
print('第三次；',res3)

客户端:

from socket import *

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

client.send(b'hello')
client.send(b'world')
client.send(b'egon')

 运行结果:

第一次； b'helloworldegon'#发生粘包问题
第二次； b''
第三次； b''

 解决之后:

#添加时间睡眠,减慢运行过程,完成分单次发送
服务端:

from socket import *

server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8080))
server.listen(5)

conn,addr=server.accept()

res1=conn.recv(1024)
print('第一次；',res1)

res2=conn.recv(1024)
print('第二次；',res2)

res3=conn.recv(1024)
print('第三次；',res3)

客户端:

from socket import *
import time

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

client.send(b'hello')
time.sleep(0.2)
client.send(b'world')
time.sleep(0.2)
client.send(b'egon')

 打印结果:

第一次； b'hello'
第二次； b'world'
第三次； b'egon'

远程执行系统命令:

客户端:

from socket import *
import subprocess
import struct

server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8080))
server.listen(5)

while True:
    conn,client_addr=server.accept()
    print('新的客户端',client_addr)

    while True:
        try:
            cmd=conn.recv(1024) #cmd=b'dir'
            if len(cmd) == 0:break

            # 运行系统命令
            obj=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,#命令解释器
                             stderr=subprocess.PIPE,
                             stdout=subprocess.PIPE
                             )

            stdout=obj.stdout.read()
            stderr=obj.stderr.read()

            #1、先制作报头（固定长度）
            total_size=len(stdout) + len(stderr)

            header=struct.pack('i',total_size)

            #2、先发送固定长度的报头
            conn.send(header)

            #3、再发送真实的数据
            conn.send(stdout)
            conn.send(stderr)
        except ConnectionResetError:
            break

    conn.close()

服务端:

from socket import *
import struct

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))
'''
如果执行的命令返回的数据过多,一次接收不完,只能打印部分信息.(剩余的会放在系统缓冲区,会导致执行新命令的时候还会打印上次命令的信息),
所以需要分多次接收,接收到全部数据后,一次打印.从而避免不同的命令返回的信息发生粘包问题
'''
while True:
    cmd=input('>>: ').strip()
    if len(cmd) == 0:continue#输空,重新发
    client.send(cmd.encode('utf-8'))

    #1、先收固定长度的报头
    header=client.recv(4)

    #2、从报头中解析出对数据的描述信息
    total_size=struct.unpack('i',header)[0]#发送的数据的总长度

    #3、再收真实的数据
    recv_size=0
    res=b''
    while recv_size < total_size :#接收到的数据的长度如果小于总长度,说明没有接收完
        data=client.recv(1024)
        res+=data
        recv_size+=len(data)

    print(res.decode('gbk'))#系统返回的为gbk

struct模块:

import struct
import json

header_dic={
    'filename':'a.txt',
    'total_size':111123131232122222222221212121212121212211113122222222222222222222222222222222222222222222222,
    'hash':'asdf123123x123213x'
}

header_json=json.dumps(header_dic)

header_bytes=header_json.encode('utf-8')

obj=struct.pack('i',len(header_bytes))#i模式会将任意数据变为四位
print(obj,len(obj))#b'xfbx01x00x00' 4

解决粘包:

服务端:

from socket import *
import subprocess
import struct
import json

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8080))
server.listen(5)

while True:
    conn, client_addr = server.accept()
    print('新的客户端', client_addr)

    while True:
        try:
            cmd = conn.recv(1024)  # cmd=b'dir'
            if len(cmd) == 0: break
            # 运行系统命令
            obj = subprocess.Popen(cmd.decode('utf-8'),
                                   shell=True,
                                   stderr=subprocess.PIPE,
                                   stdout=subprocess.PIPE
                                   )

            stdout = obj.stdout.read()
            stderr = obj.stderr.read()
            # 先制作报头,要包含发送数据的描述信息
            header_dic = {
                'filename': 'a.txt',
                'total_size': len(stdout) + len(stderr),
                'hash': 'xasf123213123'
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('utf-8')

            # 1、先把报头的长度len(header_bytes)打包成4个bytes，然后发送
            conn.send(struct.pack('i', len(header_bytes)))
            # 2、发送报头
            conn.send(header_bytes)
            # 3、再发送真实的数据
            conn.send(stdout)
            conn.send(stderr)
        except ConnectionResetError:
            break

    conn.close()

客户端:

from socket import *
import struct
import json

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

while True:
    cmd = input('>>: ').strip()
    if len(cmd) == 0: continue
    client.send(cmd.encode('utf-8'))

    # 1、先收4个字节，该4个字节中包含报头的长度
    header_len = struct.unpack('i', client.recv(4))[0]

    # 2、再接收报头
    header_bytes = client.recv(header_len)

    # 从报头中解析出想要的内容
    header_json = header_bytes.decode('utf-8')
    header_dic = json.loads(header_json)
    print(header_dic)
    total_size = header_dic['total_size']

    # 3、再收真实的数据
    recv_size = 0
    res = b''
    while recv_size < total_size:
        data = client.recv(1024)
        res += data
        recv_size += len(data)

    print(res.decode('gbk'))

struct模块:

import struct
import json

header_dic={
    'filename':'a.txt',
    'total_size':11112313123212222222222222222222222222222222222222222222222222222221111111111111111111111111111,
    'hash':'asdf123123x123213x'
}
# print(len(header_dic))
header_json=json.dumps(header_dic)

header_bytes=header_json.encode('utf-8')
print(len(header_bytes))
obj=struct.pack('i',len(header_bytes))
print(obj,len(obj))

res=struct.unpack('i',obj)
print(res[0])

 自定义报头:

1.先用报头传输数据的长度
    对于我们远程CMD程序来说,只要先传输长度就能解决粘包的问题
    但是如果做得是一个文件上传下载,除了数据的长度,还需要传输文件的名字/md5(用来判断接收的数据和发送时是否相同是否)等信息

2.自定义报头  完成发送一些额外的信息 例如文件名
    1.将要发送的额外数据打包成一个字典
    2.将字典转为bytes类型
    3.计算字典的bytes长度 并先发送
    4.发送字典数据
    5.发送真实数据

 代码:

服务端:

    # 1.组装一个报头信息
    head_dic = {
        "name":"仓老师视频教学 如何做炸鸡!",
        "md5":"asasasasaas",
        "total_size":len(res),
        "type":"video"
    }
    # 2.转json字符串
    head_str = json.dumps(head_dic)
    # 3.转字节
    head_bytes = head_str.encode("utf-8")
    # 4.发送报头长度
    bytes_len = struct.pack("i",len(head_bytes))
    c.send(bytes_len)
    # 5.发送报头
    c.send(head_bytes)
    # 6.发送真实数据
    c.send(res)

客户端:

# 1.先获取报头长度
bytes_len = c.recv(4) #对方是i格式 固定4字节
# 2.转回整型
head_len = struct.unpack("i",bytes_len)[0]

# 3.接受报头数据
head_bytes = c.recv(head_len)
# 4.转为json字符串 并转为字典
head_dic = json.loads(head_bytes.decode("utf-8"))
print(head_dic)

# 已经接收的长度
recv_len = 0
# 一个表示最终数据的bytes
finally_data = b''
# 3.收到的长度小于总长度就继续
while recv_len < head_dic["total_size"]:
    # 循环收数据
    data = c.recv(1024)
    recv_len += len(data)
    finally_data += data
# 整体解码
print(finally_data.decode("gbk"))