解决TCP协议的粘包问题

Posted boygc

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了解决TCP协议的粘包问题相关的知识,希望对你有一定的参考价值。

1、基于TCP协议实现远程执行命令

服务端

# 服务端应该满足两个特点:
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
from socket import *

server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加
server.bind((127.0.0.1,8082))
server.listen(5)
#  服务端应该做两件事
# 第一件事:循环地从板连接池中取出链接请求与其建立双向链接,拿到链接对象
while True:
    conn,client_addr=server.accept()
    # 第二件事:拿到链接对象,与其进行通信循环
    while True:
        try:
            cmd=conn.recv(1024)
            if len(cmd) == 0:break
            obj=subprocess.Popen(cmd.decode(utf-8),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()
            print(len(stdout_res)+len(stderr_res))
            conn.send(stdout_res+stderr_res)
        except Exception:
            break
    conn.close()

客户端

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect((127.0.0.1,8082))

while True:
    cmd=input(请输入命令>>:).strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode(utf-8))

    cmd_res=client.recv(1024) # 本次接收,最大接收1024Bytes
    print(cmd_res.decode(gbk)) # 强调:windows系统用gbk

2、粘包问题

只有TCP有粘包现象,UDP永远不会粘包。

TCP粘包是指发送方发送的若干包数据到接收方接收时粘成一包,造成数据在接收方缓冲区的堆积。

粘包问题出现的原因

  1、tcp是流式协议,数据像水流一样粘在一起,没有任何边界区分

  2、收数据没收干净,有残留,就会下一次结果混淆在一起

解决的核心法门就是:每次都收干净,不要任何残留

解决粘包问题思路:

  1、拿到数据的总大小total_size

  2、recv_size=0,循环接收,每接收一次,recv_size+=接收的长度

  3、直到recv_size=total_size,结束循环

 

解决粘包问题版本一

服务端:

import subprocess
import struct
from socket import *

server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加
server.bind((127.0.0.1,8083))
server.listen(5)

#  服务端应该做两件事
# 第一件事:循环地从板连接池中取出链接请求与其建立双向链接,拿到链接对象
while True:
    conn,client_addr=server.accept()

    # 第二件事:拿到链接对象,与其进行通信循环
    while True:
        try:
            cmd=conn.recv(1024)
            if len(cmd) == 0:break
            obj=subprocess.Popen(cmd.decode(utf-8),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )

            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()
            total_size=len(stdout_res)+len(stderr_res)
            print(total_size)

            # 1、先发头信息(固定长度的bytes):对数据描述信息
            # int->固定长度的bytes
            header=struct.pack(i,total_size)
            conn.send(header)

            # 2、再发真实的数据
            conn.send(stdout_res + stderr_res)
            # conn.send(stdout_res)
            # conn.send(stderr_res)

        except Exception:
            break
    conn.close()

客户端:

import struct
from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect((127.0.0.1,8083))

while True:
    cmd=input(请输入命令>>:).strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode(utf-8))

    # 一、先收固定长度的头:解析出数据的描述信息,包括数据的总大小total_size
    header=client.recv(4)
    total_size=struct.unpack(i,header)[0]

    # 二、根据解析出的描述信息,接收真实的数据
    # 2、recv_size=0,循环接收,每接收一次,recv_size+=接收的长度
    # 3、直到recv_size=total_size,结束循环
    recv_size = 0
    while recv_size < total_size:
        recv_data=client.recv(1024)
        recv_size+=len(recv_data)
        print(recv_data.decode(gbk),end=‘‘)
    else:
        print()

解决粘包问题终极版(可以当模板用)

服务端:

import subprocess
import struct
import json
from socket import *

server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加
server.bind((127.0.0.1,8083))
server.listen(5)

#  服务端应该做两件事
# 第一件事:循环地从板连接池中取出链接请求与其建立双向链接,拿到链接对象
while True:
    conn,client_addr=server.accept()

    # 第二件事:拿到链接对象,与其进行通信循环
    while True:
        try:
            cmd=conn.recv(1024)
            if len(cmd) == 0:break
            obj=subprocess.Popen(cmd.decode(utf-8),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )

            stdout_res=obj.stdout.read()
            stderr_res=obj.stderr.read()
            total_size=len(stdout_res)+len(stderr_res)

            # 1、制作头
            header_dic={
                "filename":"a.txt",
                "total_size":total_size,
                "md5":"123123xi12ix12"
            }
            json_str = json.dumps(header_dic)
            json_str_bytes = json_str.encode(utf-8)

            # 2、先把头的长度发过去
            x=struct.pack(i,len(json_str_bytes))
            conn.send(x)

            # 3、发头信息
            conn.send(json_str_bytes)
            # 4、再发真实的数据
            conn.send(stdout_res)
            conn.send(stderr_res)

        except Exception:
            break
    conn.close()

客户端:

import struct
import json
from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect((127.0.0.1,8083))

while True:
    cmd=input(请输入命令>>:).strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode(utf-8))

    # 接收端
    # 1、先手4个字节,从中提取接下来要收的头的长度
    x=client.recv(4)
    header_len=struct.unpack(i,x)[0]

    # 2、接收头,并解析
    json_str_bytes=client.recv(header_len)
    json_str=json_str_bytes.decode(utf-8)
    header_dic=json.loads(json_str)
    print(header_dic)
    total_size=header_dic["total_size"]

    # 3、接收真实的数据
    recv_size = 0
    while recv_size < total_size:
        recv_data=client.recv(1024)
        recv_size+=len(recv_data)
        print(recv_data.decode(gbk),end=‘‘)
    else:
        print()

3、socketserver模块的基本使用

3.1、基于tcp协议的使用

服务端:

import socketserver

class MyRequestHandle(socketserver.BaseRequestHandler):
    def handle(self):
        # 如果tcp协议,self.request=>conn
        print(self.client_address)
        while True:
            try:
                msg = self.request.recv(1024)
                if len(msg) == 0: break
                self.request.send(msg.upper())
            except Exception:
                break
        self.request.close()



#  服务端应该做两件事
# 第一件事:循环地从半连接池中取出链接请求与其建立双向链接,拿到链接对象
s=socketserver.ThreadingTCPServer((127.0.0.1,8889),MyRequestHandle)
s.serve_forever()
# 等同于
# while True:
#     conn,client_addr=server.accept()
#     启动一个线程(conn,client_addr)

# 第二件事:拿到链接对象,与其进行通信循环===>handle

客户端1(客户端2,客户端3相同):

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect((127.0.0.1,8889))

while True:
    msg=input(请输入命令>>:).strip()
    if len(msg) == 0:continue
    client.send(msg.encode(utf-8))

    res=client.recv(1024)
    print(res.decode(utf-8))

可以实现多用户的并发执行

3.2、基于udp协议的使用

服务端:

import socketserver

class MyRequestHanlde(socketserver.BaseRequestHandler):
    def handle(self):
        client_data=self.request[0]
        server=self.request[1]
        client_address=self.client_address
        print(客户端发来的数据%s %client_data)
        server.sendto(client_data.upper(),client_address)


s=socketserver.ThreadingUDPServer(("127.0.0.1",8888),MyRequestHanlde)
s.serve_forever()
# 相当于:只负责循环地收
# while True:
#     data,client_addr=server.recvfrom(1024)
#     启动一个线程处理后续的事情(data,client_addr)

客户端:

import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) 

while True:
    msg=input(>>>: ).strip()
    client.sendto(msg.encode(utf-8),(127.0.0.1,8888))
    res=client.recvfrom(1024)
    print(res)

struct模块

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

>>> struct.pack(‘i‘,1111111111111)

。。。。。。。。。

struct.error: ‘i‘ format requires -2147483648 <= number <= 2147483647 #这个是范围

技术图片

 

以上是关于解决TCP协议的粘包问题的主要内容,如果未能解决你的问题,请参考以下文章

TCP粘包问题

tcp的粘包和拆包示例以及使用LengthFieldFrameDecoder来解决的方法

TCP协议下的粘包问题

[网络知识]TCP协议中的粘包与拆包

socket 的粘包问题解决方案

golang中解决tcp传输中的粘包问题