TCP、UDP模型与粘包问题

最新推荐文章于 2024-06-07 09:42:51 发布
最新推荐文章于 2024-06-07 09:42:51 发布
阅读量1k 收藏 20
点赞数 11
文章标签： 网络 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g1446992400/article/details/138925272
版权

【一】三次握手和四次挥手

  • TCP协议位于osi七层协议中的传输层

    • 使用三次握手来建立连接

    • 使用四次挥手来断开连接

  • 有几个名词：

    • SYN：SYN=1 表示要建立连接

    • SYN：SYN=1 表示要建立连接

    • ACK：ACK=1 表示我收到了，允许

    • seq：随机数，建立连接无论客户端还是服务端要建立连接就要要携带

    • ack：回应请求就要加1返回

    • FIN：表示断开连接

    【1】三次握手

    发生在建立连接的阶段
【1】第一次请求
由客户端发起请求 带SYN=1
表示我自己是客户端我要建立连接
seq随机数带
发送给服务端
客户端 ---> 携带 SYN和SEQ ---> 发送给服务端
【2】第二次请求
服务端接收到客户端的请求
ACK=1 表示收到了当前客户端发送给我的请求
SYN=1 表示要建立连接
seq：随机数
服务端 ---> 接收到客户端的请求,同意建立连接 ---> 发送给客户端
【3】第三次请求
客户端接收到了服务端的请求
ACK=1 表示收到了当前服务端发送给我的请求
SYN=1 表示要建立连接
seq：随机数
和服务端建立连接成功

    img

    【2】四次挥手

    发生在断开连接上
【1】第一次
客户端向服务端发送请求，表示想要断开连接
【2】第二次
服务端接收到客户端的请求
表示同意断开连接
【3】第三次
服务端向客户端发送请求，请求的原因是当前还有数据没有传输完成
请求等待，等待数据传输完成
发起请求，断开连接
服务端向客户端发送请求，请求断开连接
【4】第四次
客户端接收到服务端的请求
直接断开连接

    img

【二】UDP协议模型

client文件

# 【一】引入socket模块
from conf import settings
import socket
​
​
# 【二】创建一个client对象
# AF_INET: 当前连接的是基于网络的套接字
# SOCK_DGRAM：连接模式是UDP协议的报式模式
client = socket.socket(family=socket.AF_INET,type=socket.SOCK_DGRAM)
# 【三】直接发送数据
to_server_send_data = f'这是来自客户端的数据'
to_server_send_data = to_server_send_data.encode()
client.sendto(to_server_send_data,settings.ADDR)
print(f"client:{client}")
# 【四】接收到服务端回的消息
from_server_recv_data,addr = client.recvfrom(1024)
from_server_recv_data = from_server_recv_data.decode()
print(f'from_server_recv_data:{from_server_recv_data}')
print(from_server_recv_data)
# 【五】关闭连接对象
client.close()

server文件

from conf import settings
​
# 【一】引入socket模块
import socket
​
# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_DGRAM：连接模式是UDP协议的报式模式
# 只会发送一次数据
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
# 【三】绑定IP和PORT
server.bind(settings.ADDR)
print(f'server:{server}')
# 【四】接收到客户端的数据
from_client_socket_data,addr = server.recvfrom(1024)
from_client_socket_data = from_client_socket_data.decode()
print(f'from_client_socket_data: {from_client_socket_data}')
print(f'addr :>>>>{addr}')
# 【五】返回给客户端数据
to_client_send_data = '这是来自服务端的一条消息!'
to_client_send_data = to_client_send_data.encode()
server.sendto(to_client_send_data,addr)
# 【六】关闭连接和服务
server.close()

补充：

【1】localhost和127.0.0.1的区别

127.0.0.1又称为本机IP地址

DNS解析 ---》一串字符解析成IP

localhost就是一个域名，但是只能在本地使用

【2】报错问题
# 【一】解决办法一：通用 ： 换 端口号
# 直接将启动的IP和端口号中的端口号更改
# 【二】解决办法二：加一个配置
# address already in use
# 【1】加配置
# SO_REUSEADDR ： re 重新 use 使用 addr 地址
# server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定IP和PORT
# 【2】绑定端口
# server.bind(settings.ADDR)
# 【三】解决办法三：# OSError: [WinError 10048] 通常每个套接字地址(协议/网络地址/端口)只允许使用一次。
# 【1】Windows
# 查看当前端口对应的进程，杀死进程
# netstat -ano|findstr 8002
# 杀死当前进程PID对应的进程
# taskkill /pid PID号 /F

【三】TCP协议模型

settings文件

IP = '127.0.0.1'
PORT = 8088
​
ADDR = (IP, PORT)
【1】第一版

客户端文件

# 【一】引入socket模块
from conf import settings
import socket
​
​
# 【二】创建一个server对象
# AF_INET: 当前连接的是基于网络的套接字
# SOCK_STREAM：连接模式是TCP的流式模式
client = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)
​
# 【三】绑定IP和PORT
client.connect(settings.ADDR)
# 【四】直接发送数据
to_server_send_data = f'这是来自客户端的数据'
to_server_send_data = to_server_send_data.encode()
client.send(to_server_send_data)
print(f'to_server_send_data :>>>> {client}')
# 【五】接收到服务端回的消息
from_server_recv_data = client.recv(1024)
from_server_recv_data = from_server_recv_data.decode()
print(from_server_recv_data)
# 【六】关闭连接对象
client.close()

服务器文件

from conf import settings
​
# 【一】引入socket模块
import socket
​
# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_STREAM：连接模式是TCP协议的流式模式
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 【三】绑定IP和PORT
server.bind(settings.ADDR)
# 【四】监听连接对象
server.listen(5)
# 【五】建立连接对象
conn,addr = server.accept()
# 【六】接收到客户端的数据
from_client_socket_data = conn.recv(1024)
from_client_socket_data = from_client_socket_data.decode()
print(from_client_socket_data)
# 【七】返回给客户端数据
to_client_send_data = '这是来自服务端的一条消息!'
to_client_send_data = to_client_send_data.encode()
conn.send(to_client_send_data)
# 【八】关闭连接和服务
conn.close()
server.close()
【2】第二版（解决了只能发送一次数据的问题）

在里面套一个while循环即可

client文件

# 【一】引入socket模块
from conf import settings
import socket


# 【二】创建一个server对象
# AF_INET: 当前连接的是基于网络的套接字
# SOCK_STREAM：连接模式是TCP的流式模式
client = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)

# 【三】绑定IP和PORT
client.connect(settings.ADDR)
while True:
    # 【四】直接发送数据
    to_server_send_data = input(f'请输入要传递给服务端的数据：').strip()
    to_server_send_data = to_server_send_data.encode()
    client.send(to_server_send_data)
    print(f'to_server_send_data :>>>> {client}')
    # 【五】接收到服务端回的消息
    from_server_recv_data = client.recv(1024)
    from_server_recv_data = from_server_recv_data.decode()
    print(from_server_recv_data)
# 【六】关闭连接对象
client.close()

server文件

from conf import settings

# 【一】引入socket模块
import socket

# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_STREAM：连接模式是TCP协议的流式模式
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 【三】绑定IP和PORT
server.bind(settings.ADDR)
# 【四】监听连接对象
server.listen(5 )
while True:
    # 【五】建立连接对象
    conn, addr = server.accept()
    # 【六】接收到客户端的数据
    from_client_socket_data = conn.recv(1024)
    from_client_socket_data = from_client_socket_data.decode()
    print(from_client_socket_data)
    # 【七】返回给客户端数据
    to_client_send_data = input(f'请输入传递给客户端的数据：').strip()
    to_client_send_data = to_client_send_data.encode()
    conn.send(to_client_send_data)
# 【八】关闭连接和服务
conn.close()
server.close()
【3】第三版（上面只能发一个来回，这里解决了这个问题）

server文件

from conf import settings

# 【一】引入socket模块
import socket

# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_STREAM：连接模式是TCP协议的流式模式
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 【三】绑定IP和PORT
server.bind(settings.ADDR)
# 【四】监听连接对象
server.listen(5)
# 【五】建立连接对象
conn, addr = server.accept()	# 将他放到while循环外面，每次都会换对象，在里面不会换
while True:
    # 这里面交流的对象永远都是上面接收到的
    # 【六】接收到客户端的数据
    from_client_socket_data = conn.recv(1024)
    from_client_socket_data = from_client_socket_data.decode()
    print(from_client_socket_data)
    # 【七】返回给客户端数据
    to_client_send_data = input(f'请输入传递给客户端的数据：').strip()
    to_client_send_data = to_client_send_data.encode()
    conn.send(to_client_send_data)
# 【八】关闭连接和服务
conn.close()
server.close()
【4】第四版（不允许传递空格及q退出，在里面再次添加一个while判断）

client文件

# 【一】引入socket模块
from conf import settings
import socket


# 【二】创建一个server对象
# AF_INET: 当前连接的是基于网络的套接字
# SOCK_STREAM：连接模式是TCP的流式模式
client = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)

# 【三】绑定IP和PORT
client.connect(settings.ADDR)
while True:
    # 【四】直接发送数据
    to_server_send_data = input(f'请输入要传递给服务端的数据：').strip()
    if not to_server_send_data:
        print(f'不允许传递空格')
        continue
    if to_server_send_data == 'q':
        print(f'成功断开连接')
        break
    to_server_send_data = to_server_send_data.encode()
    client.send(to_server_send_data)
    print(f'to_server_send_data :>>>> {client}')
    # 【五】接收到服务端回的消息
    from_server_recv_data = client.recv(1024)
    from_server_recv_data = from_server_recv_data.decode()
    print(from_server_recv_data)
# 【六】关闭连接对象
client.close()

server文件

from conf import settings

# 【一】引入socket模块
import socket

# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_STREAM：连接模式是TCP协议的流式模式
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 【三】绑定IP和PORT
server.bind(settings.ADDR)
# 【四】监听连接对象
server.listen(5)
# 【五】建立连接对象
conn, addr = server.accept()
while True:
    # 这里面交流的对象永远都是上面接收到的
    # 【六】接收到客户端的数据
    from_client_socket_data = conn.recv(1024)
    from_client_socket_data = from_client_socket_data.decode()
    print(from_client_socket_data)
    while True:
        # 【七】返回给客户端数据
        to_client_send_data = input(f'请输入传递给客户端的数据：').strip()
        if not to_client_send_data:
            print(f"不允许传递空格")
            continue
        if to_client_send_data == "q":
            print(f'成功断开连接')
            break
        to_client_send_data = to_client_send_data.encode()
        conn.send(to_client_send_data)
        break
# 【八】关闭连接和服务
conn.close()
server.close()
【5】第五版（无论哪一边输入q，两边都断开，不会傻等了）

client文件

# 【一】引入socket模块
from conf import settings
import socket


# 【二】创建一个server对象
# AF_INET: 当前连接的是基于网络的套接字
# SOCK_STREAM：连接模式是TCP的流式模式
client = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)

# 【三】绑定IP和PORT
client.connect(settings.ADDR)
while True:
    # 【四】直接发送数据
    to_server_send_data = input(f'请输入要传递给服务端的数据：').strip()
    if not to_server_send_data:
        print(f'不允许传递空格')
        continue
    if to_server_send_data == 'q':
        print(f'成功断开连接')
        break
    to_server_send_data = to_server_send_data.encode()
    client.send(to_server_send_data)
    print(f'to_server_send_data :>>>> {client}')
    # 【五】接收到服务端回的消息
    from_server_recv_data = client.recv(1024)
    from_server_recv_data = from_server_recv_data.decode()
    print(from_server_recv_data)
    if from_server_recv_data == 'q':	
        break
# 【六】关闭连接对象
client.close()

server文件

from conf import settings

# 【一】引入socket模块
import socket

# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_STREAM：连接模式是TCP协议的流式模式
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 解决端口号占用报错的方法，重用ip端口号
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 【三】绑定IP和PORT
server.bind(settings.ADDR)
# 【四】监听连接对象
server.listen(5)
# 【五】建立连接对象
conn, addr = server.accept()
while True:
    # 添加一个try捕获异常
    try:
        # 这里面交流的对象永远都是上面接收到的
        # 【六】接收到客户端的数据
        from_client_socket_data = conn.recv(1024)
        from_client_socket_data = from_client_socket_data.decode()
        print(from_client_socket_data)
        if not from_client_socket_data:
            break
        while True:
            # 【七】返回给客户端数据
            to_client_send_data = input(f'请输入传递给客户端的数据：').strip()
            if not to_client_send_data:
                print(f"不允许传递空格")
                continue
            if to_client_send_data == "q":
                print(f'成功断开连接')	# 这里输入q之后编码传过去，然后执行break断开
            to_client_send_data = to_client_send_data.encode()
            conn.send(to_client_send_data)
            break
    except Exception as e:
        break
# 【八】关闭连接和服务
conn.close()
server.close()

【四】粘包

【1】粘包问题的介绍

[1]粘包问题的背景

粘包问题只会发生在TCP协议 ---> 流式协议 ---> 不断的传输数据

比如有一个大缸：先放红颜色的颜料放了一缸但是还有一勺没有放进去

没有放进去的这一勺红颜色颜料和下一缸的绿颜色颜料混到了一起

不会发生在UDP协议 ---> 报式协议 ---> 一次性传输数据

比如有一个大缸：先放红颜色的颜料放了一缸但是还有一勺没有放进去

那么直接将这勺颜料扔了

[2]粘包问题

客户端发送的数据远远超出服务端的接收范围,出现没接收完整的情况，导致了不同数据之间的数据混乱

问题

[3]实例

执行本地的 ipconfig 命令会获取到当前执行的结果

将结果传递给 服务端

服务端接收到数据 只能接收一部分 另外一部分发现接收不到

只能和第二次的数据合并到一起发送

[4]解决办法

问题产生在服务端

原因是客户端向服务端发送数据，但是服务端不知道总的数据大小，只能按照默认的数据大小接收

解决思路：

客户端在发送数据的时候将数据的总大小一起发送给服务端

服务端接收到总的大小的数据长度 ， 根据自己的容量大小分批次接收

【2】问题演示

client文件

# 【一】引入socket模块
from conf import settings
import socket
import subprocess


def run_cmd(command):
    result = subprocess.run(
        command,  # 子进程要执行的命令
        shell=True,  # 执行的是shell的命令
        # 存放的是执行命令成功的结果
        stdout=subprocess.PIPE,
        # 存放的是执行命令失败的结果
        stderr=subprocess.PIPE,
        encoding="gbk",
        timeout=1)
    # return code属性是run()函数返回结果的状态。
    if result.returncode == 0:
        return result.stdout
    else:
        return result.stderr


# 【二】创建一个server对象
# AF_INET: 当前连接的是基于网络的套接字
# SOCK_STREAM：连接模式是TCP的流式模式
client = socket.socket(family=socket.AF_INET,type=socket.SOCK_STREAM)

# 【三】绑定IP和PORT
client.connect(settings.ADDR)
while True:
    # 【四】直接发送数据
    command = input(f'请输入要传递给服务端的数据：').strip()
    if not command:
        print(f'不允许传递空格')
        continue
    if command == 'q':
        print(f'成功断开连接')
        break
    to_server_send_data = run_cmd(command=command)
    to_server_send_data = to_server_send_data.encode()
    client.send(to_server_send_data)
    print(f'to_server_send_data :>>>> {client}')
    # 【五】接收到服务端回的消息
    from_server_recv_data = client.recv(1024)
    from_server_recv_data = from_server_recv_data.decode()
    print(from_server_recv_data)
    if from_server_recv_data == 'q':
        break
# 【六】关闭连接对象
client.close()

server文件

from conf import settings

# 【一】引入socket模块
import socket

# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_STREAM：连接模式是TCP协议的流式模式
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 解决端口号占用报错的方法，重用ip端口号
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 【三】绑定IP和PORT
server.bind(settings.ADDR)
# 【四】监听连接对象
server.listen(5)
# 【五】建立连接对象
conn, addr = server.accept()
while True:
    try:
        # 这里面交流的对象永远都是上面接收到的
        # 【六】接收到客户端的数据
        from_client_socket_data = conn.recv(1024)
        from_client_socket_data = from_client_socket_data.decode()
        print(from_client_socket_data)
        if not from_client_socket_data:
            break
        while True:
            # 【七】返回给客户端数据
            to_client_send_data = input(f'请输入传递给客户端的数据：').strip()
            if not to_client_send_data:
                print(f"不允许传递空格")
                continue
            if to_client_send_data == "q":
                print(f'成功断开连接')
            to_client_send_data = to_client_send_data.encode()
            conn.send(to_client_send_data)
            break
    except Exception as e:
        break
# 【八】关闭连接和服务
conn.close()
server.close()

【3】解决办法

import json

from conf import settings
# 【一】引入socket模块
import socket
import subprocess
import uuid


def run_cmd(command):
    result = subprocess.run(
        command,  # 子进程要执行的命令
        shell=True,  # 执行的是shell的命令
        # 存放的是执行命令成功的结果
        stdout=subprocess.PIPE,
        # 存放的是执行命令失败的结果
        stderr=subprocess.PIPE,
        encoding="gbk",
        timeout=1)
    # returncode属性是run()函数返回结果的状态。
    if result.returncode == 0:
        return result.stdout
    else:
        return result.stderr


# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_STREAM：连接模式是TCP协议的流式模式
client = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
# 【三】绑定IP和PORT
client.connect(settings.ADDR)
while True:
    # 【四】直接发送数据
    command = input("请输入需要执行的命令 :>>>> ").strip()
    if not command:
        print(f'不允许发送空的数据')
        continue
    if command == 'q':
        print(f'当前连接已退出!')
        break
    # 【1】执行本地的命令，获取到当前命令结果
    result = run_cmd(command=command)
    # 【2】对命令的结果进行编码---> 转成二进制数据
    result_bytes = result.encode()
    # 【3】计算长度
    data_length = len(result_bytes)
    # 【4】增加一个数据概览 --> 字典格式 做数据概览
    # 存储当前文件名 / 结果名 / md5加密盐(用来校验数据的完整性)
    salt = uuid.uuid4().hex
    encrypted = settings.encrypt_data(data=result_bytes, salt=salt)
    send_data_info = {
        'command': command,
        'data_length': data_length,
        'salt': salt,
        'encrypted': encrypted
    }
    # 【5】将上面打包好的数据全部发送给服务端
    # （1）字典格式无法发送
    # 将字典转换为字符串数据 ----> json
    # dump : 处理文件数据
    # dumps : 做格式转换的
    json_str = json.dumps(send_data_info)
    # （2）将json字符串数据转换为二进制数据
    json_bytes = json_str.encode()
    # 【6】问题产生
    # JSON字符串转换为的二进制数据还是会很长
    # 让数据变短
    # struct 模块 ---> 将某几个数字转换为四个字节的二进制数据
    json_length_pack = settings.pack_data(data_length=len(json_bytes))
    # 【7】发送struct打包的数据(四个字节) + JSON数据 + 原始数据
    # JSON数据里面存的是所有数据信息而没有原始的二进制数据
    # 服务端接受的顺序取决于客户端发送的顺序
    # 先发送struct打包后的数据
    client.send(json_length_pack)  # 4 字节 --> 包含json二进制数据的长度
    # 先发送 json_bytes 打包后的数据
    client.send(json_bytes)  # 不知道
    # 再发送 result_bytes 原始数据
    client.send(result_bytes)
    # 【五】接收到服务端回的消息
    from_server_recv_data = client.recv(1024)
    from_server_recv_data = from_server_recv_data.decode()
    if from_server_recv_data == 'q':
        break
    print(f'这是来自服务端的数据 :>>>>  \n{from_server_recv_data}')
# 【六】关闭连接对象
client.close()
import json

from conf import settings
# 【一】引入socket模块
import socket

# 【二】创建一个server对象
# AF_INET：当前连接是基于网络的套接字
# SOCK_STREAM：连接模式是TCP协议的流式模式
server = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 【三】绑定IP和PORT
server.bind(settings.ADDR)
# 【四】监听连接对象
server.listen(5)
# 【五】建立连接对象
# 放在这里 进入的 while 循环中的哪个连接对象会一致不变
conn, addr = server.accept()
while True:
    try:
        # 这里面交流的对象永远是上面接收到的那一个
        # conn, addr = server.accept() ： 接收到新的对象，忘记上一个连接过的对象
        # 【六】接收到客户端的数据
        # 【1】先接接收四个字节的数据 ---> struct打包好的四个字节的数据
        json_pack_data = conn.recv(4)
        if not json_pack_data:
            break
        json_bytes_length = settings.unpack_data(data=json_pack_data)
        # 【2】根据json二进制数据长度解出JSON二进制数据
        json_data_bytes = conn.recv(json_bytes_length)
        # 【3】将json二进制数据转为json字符串数据
        json_str = json_data_bytes.decode()
        # 【4】将json字符串数据转换为python的字典
        data_info = json.loads(json_str)
        # 【5】从字典中获取自定的参数
        # 获取到总的数据长度
        # 10000
        data_length = data_info.get('data_length')
        # 【6】定义参数
        # （1）总数据
        all_data = b''
        # （2）每次接收的数据大小
        size = 1024
        # data_length : 5
        # size : 2
        # count : 2 , last_size : 1
        count, last_size = divmod(data_length, size)
        # （3）已经接受的数据大小
        all_size = 0
        while all_size < count + 1:
            all_size += 1
            # 接收到每一次的数据并和总数据拼接
            if all_size == count + 1:
                all_data += conn.recv(last_size)
            else:
                all_data += conn.recv(size)
        from_client_recv_data = all_data.decode()
        print(f'这是来自客户端的数据 :>>>>  \n {from_client_recv_data}')
        # 【七】返回给客户端数据
        while True:
            to_client_send_data = input("请输入发送给客户端的数据 :>>>> ").strip()
            if not to_client_send_data:
                print(f'不允许发送空的数据')
                continue
            if to_client_send_data == 'q':
                print(f'当前连接已退出!')
            to_client_send_data = to_client_send_data.encode()
            conn.send(to_client_send_data)
            break
    except Exception as e:
        break
# 【八】关闭连接和服务
conn.close()
server.close()

【4】subprocess模块回顾

import subprocess


def run_cmd(command):
    result = subprocess.run(
        command,  # 子进程要执行的命令
        shell=True,  # 执行的是shell的命令
        # 存放的是执行命令成功的结果
        stdout=subprocess.PIPE,
        # 存放的是执行命令失败的结果
        stderr=subprocess.PIPE,
        encoding="gbk",
        timeout=1)
    # returncode属性是run()函数返回结果的状态。
    if result.returncode == 0:
        return result.stdout
    else:
        return result.stderr


if __name__ == '__main__':
    print(run_cmd(['dir']))

【5】struct模块介绍

# 【一】模块介绍
# ● struct.pack()是Python内置模块struct中的一个函数
# ● 它的作用是将指定的数据按照指定的格式进行打包
# 并将打包后的结果转换成一个字节序列（byte string），可以用于在网络上传输或者储存于文件中。
# 【二】参数简介
# struct.pack(fmt, v1, v2, ...)
# ● 其中，fmt为格式字符串，指定了需要打包的数据的格式，后面的v1,v2,...则是需要打包的数据。
# ● 这些数据会按照fmt的格式被编码成二进制的字节串，并返回这个字节串。

# 【三】示例
import struct

# 定义一个包含不同类型字段的格式字符串
format_string = 'i'

# 示例数据：整数、四个字节的原始数据、短整数
data_to_pack = '十七dasdadsad asd 撒大撒多所adsaddasdadsa da dsa asad撒大大带我去大青蛙大大大大大萨达去问问恰饭恰饭放散阀昂发昂发沙发阿发发发放上千万请发送方三房启发法阿发发发ad sada dsa dsa dsa sa dsa dsa as ad sad ad ada顿撒大大三大撒打我前端'
data_to_pack_bytes = data_to_pack.encode()

data_to_pack_len = len(data_to_pack_bytes)
print(data_to_pack_len)
# 使用 struct.pack 将数据打包成二进制字节串
packed_data = struct.pack(format_string, data_to_pack_len)

# 41000000
# 64000000
# 19010000
print("Packed data:", len(packed_data))  # 打印打包后的十六进制表示

# 解析二进制字节串，恢复原始数据
unpacked_data = struct.unpack(format_string, packed_data)
#
print("Unpacked data:", unpacked_data)  # 打印解析后的数据

##

唯有聪明绝顶
关注
  • 11
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
StriveEngine2.0
08-29
如果您的项目不需要P2P、不需要传文件、不需要群集等功能，只需要简单的TCP/UDP通信。那么，可以考虑使用轻量级的通信引擎StriveEngine。相比较而言，StriveEngine更单纯、更容易上手，也更容易与已存在的遗留系统进行协作。 一.StriveEngine 主要特性 1.底层采用高效的IOCP（完成端口）模型。 2.内部自动管理可复用的线程池、以及内存池。 3.内置多种通信引擎类型：TCP/UDP、文本协议/二进制协议、服务端/客户端。而且，所有这些引擎的使用方式一致。 4.解决了TCP通信中的粘包以及消息重组问题。 5.发送消息支持同步、异步两种方式。 6.服务端引擎支持异步消息队列模式。 7.客户端TCP引擎支持断线自动重连。 8.支持Sock5代理。 9.兼容IPv6。 二.使用StriveEngine的步骤 （1）实现ITextContractHelper或者是IStreamContractHelper接口（如何实现该接口，可参考后面demo的源码）。 （2）调用NetworkEngineFactory的创建引擎的方法，得到正确的通信引擎实例。 （3）根据需要，设置引擎实例的某些属性（如MaxMessageSize属性）。 （4）根据需要，预定引擎实例的某些事件（如MessageReceived事件）。 （5）调用引擎实例的Initialize方法启动通信引擎。
linux网络编程
07-11
Linux网络编程之TCP/IP基础篇 01TCPIP基础（一） ISO/OSI参考模型 TCP/IP四层模型 基本概念（对等通信、封装、分用、端口） 02TCPIP基础（二） 最大传输单元（MTU）/路径MTU 以太网帧格式 ICMP ARP RARP 03TCPIP基础（三） IP数据报格式 网际校验和 路由 04TCPIP基础（四） TCP特点 TCP报文格式 连接建立三次握手 连接终止四次握手 TCP如何保证可靠性 05TCPIP基础（五） 滑动窗口协议 UDP特点 UDP报文格式 Linux网络编程之socket编程篇 06socket编程（一） 什么是socket IPv4套接口地址结构 网络字节序 字节序转换函数 地址转换函数 套接字类型 07socket编程（二） TCP客户/服务器模型 回射客户/服务器 socket、bind、listen、accept、connect 08socket编程（三） SO_REUSEADDR 处理多客户连接（process-per-conection） 点对点聊天程序实现 09socket编程（四） 流协议与粘包 粘包产生的原因 粘包处理方案 readn writen 回射客户/服务器 10socket编程（五） read、write与recv、send readline实现 用readline实现回射客户/服务器 getsockname、getpeername gethostname、gethostbyname、gethostbyaddr 11socket编程（六） TCP回射客户/服务器 TCP是个流协议 僵进程与SIGCHLD信号 12socket编程（七） TCP 11种状态 连接建立三次握手、连接终止四次握手 TIME_WAIT与SO_REUSEADDR SIGPIPE 13socket编程（八） 五种I/O模型 select 用select改进回射客户端程序 14socket编程（九） select 读、写、异常事件发生条件 用select改进回射服务器程序。 15socket编程（十） 用select改进第八章点对点聊天程序 16socket编程（十一） 套接字I/O超时设置方法 用select实现超时 read_timeout函数封装 write_timeout函数封装 accept_timeout函数封装 connect_timeout函数封装 17socket编程（十二） select限制 poll 18socket编程（十三） epoll使用 epoll与select、poll区别 epoll LT/ET模式 19socket编程（十四） UDP特点 UDP客户/服务基本模型 UDP回射客户/服务器 UDP注意点 20socket编程（十五） udp聊天室实现 21socket编程（十六） UNIX域协议特点 UNIX域地址结构 UNIX域字节流回射客户/服务 UNIX域套接字编程注意点 22socket编程（十七） socketpair sendmsg/recvmsg UNIX域套接字传递描述符字 Linux网络编程之进程间通信篇 23进程间通信介绍（一） 进程同步与进程互斥 进程间通信目的 进程间通信发展 进程间通信分类 进程间共享信息的三种方式 IPC对象的持续性 24进程间通信介绍（二） 死锁 信号量 PV原语 用PV原语解决司机与售票员问题 用PV原语解决民航售票问题 用PV原语解决汽车租赁问题 25System V消息队列（一） 消息队列 IPC对象数据结构 消息队列结构 消息队列在内核中的表示 消息队列函数 26System V消息队列（二） msgsnd函数 msgrcv函数 27System V消息队列（三） 消息队列实现回射客户/服务器 28共享内存介绍 共享内存 共享内存示意图 管道、消息队列与共享内存传递数据对比 mmap函数 munmap函数 msync函数 29System V共享内存 共享内存数据结构 共享内存函数 共享内存示例 30System V信号量（一） 信号量 信号量集结构 信号量集函数 信号量示例 31System V信号量（二） 用信号量实现进程互斥示例 32System V信号量（三） 用信号集解决哲学家就餐问题 33System V共享内存与信号量综合 用信号量解决生产者消费者问题 实现shmfifo 34POSIX消息队列 POSIX消息队列相关函数 POSIX消息队列示例 35POSIX共享内存 POSIX共享内存相关函数 POSIX共享内存示例 Linux网络编程之线程篇 36线程介绍 什么是线程 进程与线程 线程优缺点 线程模型 N:1用户线程模型 1:1核心线程模型 N:M混合线程模型 37POSIX线程（一） POSIX线程库相关函数 用线程实现回射客户/服务器 38POSIX线程（二） 线程属性 线程特定数据 39POSIX信号量与互斥锁 POSIX信号量相关函数 POSIX互斥锁相关函数 生产者消费者问题 自旋锁与读写锁介绍 40POSIX条件变量 条件变量 条件变量函数 条件变量使用规范 使用条件变量解决生产者消费者问题 41一个简单的线程池实现 线程池性能分析 线程池实现
Unity 完整TCP、UDP异步服务器 多路复用 分包、粘包、完整发送、账户登录、 ProtoBuf协议
04-18
1.Unity完整TCP、UDP客户端请查看NetworkClientpackage资源。 2.完整TCP、UDP服务器，采用高效 ProtoBuf协议传送，包含完整的消息编解码、组装，UDP数据分包、组包处理。 3.TCP采用多路复用方式。 4.完整的数据接收缓冲区，发送队列，采用异步模型。 5.包含客户端登陆、管理。 6.支持外网，需做服务器映射。 7.支持UWP平台，HoloLens。
Unity 完整TCP、UDP异步客户端 分包、粘包、完整发送、账户登录、 ProtoBuf协议
04-18
1.Unity完整TCP、UDP服务器请查看NetworkServer资源。 2.完整TCP、UDP客户端，采用高效 ProtoBuf协议传送，包含完整的消息编解码、组装，UDP数据分包、组包处理。 3.完整心跳检测。 4.完整的数据接收缓冲区，发送队列，采用异步模型。 5.包含客户端登陆、管理。 6.支持外网，需做服务器映射。 7.支持UWP平台，HoloLens。
轻量级的通信引擎 StriveEngine
08-22
如果您的项目不需要P2P、不需要传文件、不需要群集等功能，只需要简单的TCP/UDP通信。那么，可以考虑使用轻量级的通信引擎StriveEngine。相比较而言，StriveEngine更单纯、更容易上手，也更容易与已存在的遗留系统进行协作。 一.StriveEngine 主要特性 1.底层采用高效的IOCP（完成端口）模型。 2.内部自动管理可复用的线程池、以及内存池。 3.内置多种通信引擎类型：TCP/UDP、文本协议/二进制协议、服务端/客户端。而且，所有这些引擎的使用方式一致。 4.解决了TCP通信中的粘包以及消息重组问题。 5.发送消息支持同步、异步两种方式。 6.服务端引擎支持异步消息队列模式。 7.客户端TCP引擎支持断线自动重连。 8.支持Sock5代理。 9.兼容IPv6。 二.使用StriveEngine的步骤 （1）实现ITextContractHelper或者是IStreamContractHelper接口（如何实现该接口，可参考后面demo的源码）。 （2）调用NetworkEngineFactory的创建引擎的方法，得到正确的通信引擎实例。 （3）根据需要，设置引擎实例的某些属性（如MaxMessageSize属性）。 （4）根据需要，预定引擎实例的某些事件（如MessageReceived事件）。 （5）调用引擎实例的Initialize方法启动通信引擎。
TCP与UDP(非常详细)
好好学习
11-18 5030
TCP/IP模型是一些列协议的总称（TCP，UDP，IP，FTP，HTTP，ICMP，SMTP）。这些协议可以划分为四层：链路层、网络层、传输层、应用层。TCP和UDP都位于计算机网络模型中的运输层，它们主要负责传输应用层产生的数据。。TCP与UDP区别总结：1、TCP传输效率慢、所需资源多，UDP则相反。2、TCP面向连接（打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前不需要建立连接3、TCP提供可靠的服务，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;
解决TCP网络传输粘包问题
m0_60259116的博客
04-25 762
TCP/IP 协议簇建立了互联网中通信协议的概念模型，该协议簇中的两个主要协议就是 TCP 和 IP 协议。TCP/ IP 协议簇中的 TCP 协议能够保证数据段（Segment）的可靠性和顺序，有了可靠的传输层协议之后，应用层协议就可以直接使用 TCP 协议传输数据，不在需要关心数据段的丢失和重复问题 图 1 - TCP 协议与应用层协议 IP 协议解决了数据包（Packet）的路由和传输，上层的 TCP 协议不再关注路由和寻址，那么 TCP 协议解决的是传输的可靠性和顺序问题，上层不需要关心数据
tcp,udp一些列问题
weixin_53344209的博客
04-26 761
一般来说，提交一个GET或POST指令对客户端的耗费和带宽的占用是几乎可以忽略的，而服务器为处理此请求却可能要从上万条记录中去查出某个记录，这种处理过程对资源的耗费是很大的，常见的数据库服务器很少能支持数百个查询指令同时执行，而这对于客户端来说却是轻而易举的，因此攻击者只需通过 Proxy代理向主机服务器大量递交查询指令，只需数分钟就会把服务器资源消耗掉而导致拒绝服务，常见的现象就是网站慢如蜗牛、ASP程序失效、PHP连接数据库失败、数据库主程序占用CPU偏高。其实第三次握手的时候，是可以携带数据的。
TCP连接时CSocket粘包问题的解决方法
初级小白_的博客
03-29 376
解决TCP网络传输“粘包”问题 作者：杨小平 王胜开 原文出处：http://www.ciw.com.cn/ 当前在网络传输应用中，广泛采用的是TCP/IP通信协议及其标准的socket应用开发编程接口（API）。TCP/IP传输层有两个并列的协议：TCP和UDP。其中TCP（transport control protocol，传输控制协议）是面向连接的，提供高可靠性服务。UDP（user ...
Boostasio异步TCP通讯及tcp粘包解包解决方案.doc
10-03
在实现 Boostasio 异步 TCP 通讯和 TCP 粘包解包解决方案时，我们需要使用 Boost Asio 库提供的异步I/O模型。下面是一个简单的示例代码： ```c #include using namespace boost::asio; using namespace boost::...
为什么TCP会出现粘包问题？
sterlingjone1的博客
08-09 401
TCP/IP 协议簇建立了互联网中通信协议的概念模型，该协议簇中的两个主要协议就是 TCP 和 IP 协议。TCP/ IP 协议簇中的 TCP 协议能够保证数据段（Segment）的可靠性和顺序，有了可靠的传输层协议之后，应用层协议就可以直接使用 TCP 协议传输数据，不在需要关心数据段的丢失和重复问题。 图 1 - TCP 协议与应用层协议 IP 协议解决了数据包（Packet）的路由和传输，上层的 TCP 协议不再关注路由和寻址，那么 TCP 协议解决的是传输的可靠性和顺序问题，上层不需要关心数据能否
解决TCP网络传输“粘包”问题
千慧的专栏
03-07 1924
解决TCP网络传输“粘包”问题作者：杨小平 王胜开原文出处：http://www.ciw.com.cn/ 当前在网络传输应用中，广泛采用的是TCP/IP通信协议及其标准的socket应用开发编程接口（API）。TCP/IP传输层有两个并列的协议：TCP和UDP。其中TCP（transport control protocol，传输控制协议）是面向连接的，提供高可靠性服务。UDP（user da
TCP、UDP、TCP三次握手与四次挥手、TCP如何保证可靠传输、TCP异常分析、拆包和粘包等
loytuls的博客
03-20 1160
关于计算机网络的面试官最爱问的问题：TCP、UDP、TCP三次握手与四次挥手、TCP如何保证可靠传输、TCP异常分析、拆包和粘包等（必问问题）
TCP与UDP
BeginnerMind
04-18 1365
TCP与UDP协议TCP协议TCP原理确认应答机制超时重传机制连接管理机制滑动窗口流量控制拥塞控制延迟应答捎带应答粘包问题UDP协议参考 协议 协议（protocol）是不同的硬件、操作系统之间的通信，所需的一种规则。这种规则就是计算机与网络设备要相互通信，双方所使用的相同方法。比如：如何探测到通信目标、由哪一边先发起通信、使用哪种语言进行通信、怎样结束通信等规则都需要事先确定。 TCP/IP 是互联网相关的各类协议族的总称，比如：TCP，UDP，IP，FTP，HTTP，ICMP，SMTP 等都属于 TCP
应用程序加固的优势及其在移动应用安全中的重要性
gulu230220的博客
06-05 525
通过提升应用程序的安全性、防止应用程序被篡改、提高应用程序的抗攻击能力、保护应用程序的知识产权和提升用户体验和信任度，加固技术可以有效保障移动应用的安全和稳定，为用户提供更加安全和可靠的移动应用服务。通过加固应用程序的安全漏洞和弱点，加固技术可以防止黑客利用已知的攻击手段和工具对应用程序进行攻击，提高应用程序的安全性和稳定性。通过加密和混淆应用程序的源代码和关键算法，加固技术可以防止黑客和竞争对手获取应用程序的源代码和商业机密，保护开发者的创新成果和商业利益。应用程序加固能够有效提升移动应用程序的安全性。
速盾：DDoS高防IP上设置转发规则
zhuguowang01的博客
06-04 493
转发规则允许管理员根据自己的需求，将特定的网络流量转发到指定的服务器，提高网络的灵活性和可控性。总之，通过在DDoS高防IP上设置转发规则，网络管理员可以更好地管理和控制网络流量，提高网络的安全性和可用性。安全策略：通过设置转发规则，管理员可以实施一些安全策略，例如将特定类型的流量进行深度检测或防火墙过滤，提高网络的安全性。例如，可以设置规则将来自特定地区的流量转发到相应的服务器上，提高用户的访问速度和体验。例如，可以将特定类型的流量转发到离用户更近的服务器上，减少网络延迟，提高用户的响应速度。
Ruoyi-Vue-Plus 下载启动后菜单无法点击展开，
06-07 266
1.框架下载后运行2.使用mock数据3.进入页面后无法点击菜单本以为是动态路由或者菜单逻辑出了问题，最后发现是websocket的问题。
HTTP协议分析实验：通过一次下载任务抓包分析
最新发布
qq_39241682的博客
06-07 815
本实验主要讲解HTTP协议的应用，通过一次下载任务，抓取HTTP协议数据报文，对HTTP的请求和相应报文进行详细的分析。HTTP 是客户端浏览器或其他程序与Web服务器之间的应用层通信协议。 在Internet上的Web服务器上存放的都是超文本信息，客户机需要通过HTTP协议传输所要访问的超文本信息。
TCP和UDP分包粘包
07-28
TCP和UDP在传输过程中都可能会出现分包和粘包的问题，但是处理方式有所不同。 对于TCP协议，如果定义的TCP包没有超过范围，即在IP层不需要分包，传输过程中就可以避免IP层组包发生的错误。但是如果超过范围，即IP...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值