TCP、UDP模型与粘包问题

于 2024-05-15 22:05:04 发布
阅读量1.8k 收藏 40
点赞数 24
文章标签： 网络 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)  # 打印解析后的数据

##

唯有聪明绝顶
关注
  • 24
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
UDP“粘包”
farmanlinuxer的博客
12-11 3977
UDP“粘包”的事实、有限分析及针对性克服思路。
粘包现象与解决粘包问题
淘小欣的博客
01-20 6435
粘包现象与解决粘包问题 一、引入 粘包问题主要出现在用TCP协议传输中才会出现的问题,UDP不会出现,因为TCP传输中他会服务端会一次性把所有东西一并丢入缓存区,而读取的内容大小有时候没法准确的做到一一读取,所有会存在粘包。 而UDP他传输的时候是吧一个个内容丢过去,不管客户端能否完全接受到内容他都会接受他制定大小的内容,而内容大于他接受设定的大小时候多余的东西会被丢到 注意：只有TCP才会出现粘包现象，UDP永远不会出现粘包现象 一、粘包现象介绍 1.socket收发消息的原理 其实我们发送数据并不是
如何解决tcp通信中的粘包问题？
m0_37829435的博客
08-16 1万+
TCP通信中的粘包问题 尹德位 2015 西安   关键词 ： TCP 网络通信 粘包 Linux C/S 一  粘包问题概述 二  粘包回避设计   第一章  粘包问题概述   1.1  描述背景 采用TCP协议进行网络数据传送的软件设计中，普遍存在粘包问题。这主要是由于现代操作系统的网络传输机制所产生的。我们知道，网络通信采用的套接字(socket)技术，其实现实际是由系统...
【Python基础篇021】黏包现象丨udp的socket服务
周周の博客小屋
11-13 825
基于udp的socket服务有什么特点？黏包现象是什么？又是如何产生的？udp和tcp哪种会有黏包现象？看完这篇文章相信你会有所收获。
TCP粘包是什么？如何处理？UDP有粘包吗？
nigar_的博客
02-09 2248
文章目录1.什么是TCP粘包2.出现粘包的原因3.粘包的处理- 什么时候需要处理- 如何处理4.UDP没有粘包 1.什么是TCP粘包 TCP粘包就是指发送方发送的若干包数据到达接收方时粘成了一包，从接收缓冲区来看，后一包数据的头紧接着前一包数据的尾，出现粘包的原因是多方面的，可能是来自发送方，也可能是来自接收方。 2.出现粘包的原因 出现粘包的原因是多方面的，可能是来自发送方，也可能是来自接收方。...
TCP粘包问题
J_Shine的博客
06-22 456
本篇博客从以下四个问题进行分析，来理解TCP粘包问题。 什么是TCP粘包问题？ 为什么会存在TCP粘包问题？ 如何解决TCP粘包问题？ UDP是否存在粘包问题？为什么？ 什么是TCP粘包问题？ TCP是面向连接的，即客户端和服务端要成对维护socket连接。如果客户端连续不断的向服务端发送数据包时，服务端接收的数据会出现两个数据包粘在一起的情况，这就是TCP协议中经常会遇到的粘包以...
tcp 粘包问题
技术的搬运工
05-06 146
粘包出现原因 扩展：udp是面向消息传输，tcp是面向流传输，所以UDP不会出现粘包，因为它有消息边界(参考Windows网络编程) 发送方引起：TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一包数据。若连续几次发送的数据都很少，通常TCP会根据优化算法把这些数据合成一包后一次发送出去，这样接收方就收到了粘包数据。 接收方引起：由于接收方用户进程不及时接收数据，从而导致粘包现象...
Unity 完整TCP、UDP异步客户端 分包、粘包、完整发送、账户登录、 ProtoBuf协议
04-18
1.Unity完整TCP、UDP服务器请查看NetworkServer资源。 2.完整TCP、UDP客户端，采用高效 ProtoBuf协议传送，包含完整的消息编解码、组装，UDP数据分包、组包处理。 3.完整心跳检测。 4.完整的数据接收缓冲区，发送...
Boostasio异步TCP通讯及tcp粘包解包解决方案.doc
10-03
在实现 Boostasio 异步 TCP 通讯和 TCP 粘包解包解决方案时，我们需要使用 Boost Asio 库提供的异步I/O模型。下面是一个简单的示例代码： ```c #include using namespace boost::asio; using namespace boost::...
Unity 完整TCP、UDP异步服务器 多路复用 分包、粘包、完整发送、账户登录、 ProtoBuf协议
04-18
1.Unity完整TCP、UDP客户端请查看NetworkClientpackage资源。 2.完整TCP、UDP服务器，采用高效 ProtoBuf协议传送，包含完整的消息编解码、组装，UDP数据分包、组包处理。 3.TCP采用多路复用方式。 4.完整的数据接收...
Netty的技术的总结（Marshalling编解码，tcp的拆包粘包，webservice），包括新手入门源码，注释清楚，绝对物超所值
09-28
**TCP的拆包粘包问题**：TCP是面向字节流的协议，不区分消息边界，可能导致数据接收方无法准确解析消息。Netty通过提供一系列的编解码器，如LengthFieldBasedFrameDecoder，解决了这个问题。它可以根据前导长度字段...
SuperSocket.ClientEngine.Core socket 客户端处理粘包半包
09-16
粘包和半包是网络通信中的常见问题，主要出现在TCP协议中。由于TCP为了提高传输效率，会将多个小的数据包合并成一个大的数据包进行发送（粘包），或者将一个大数据包分成多个小的数据包发送（半包）。这可能导致接收...
【操作系统】为什么TCP会粘包、UDP不会粘包？
m0_46613023的博客
08-27 3558
TCP协议面向字节流 发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。 UDP协议面向数据报 而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。 怎样.
粘包问题
weixin_30823227的博客
06-16 153
目录 一、什么是粘包？ 二、TCP发送数据的四种情况 三、粘包的两种情况 3.1 服务端 3.2 客户端 3.3 服务端 3.4 客户端 四、补充问题一：为何TCP是可靠传输，udp是不可靠传输 五、...
粘包拆包现象的原因及解决办法
zhang_qing_yun的博客
12-07 985
粘包拆包现象的原因及解决办法
TCP粘包，UDP不存在粘包问题
热门推荐
多学多思
09-12 1万+
有关TCP和UDP 粘包 消息保护边界 from: http://www.cnblogs.com/lancidie/archive/2013/10/28/3392428.html 在socket网络程序中，TCP和UDP分别是面向连接和非面向连接的。因此TCP的socket编程，收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方
网络收发数据中涉及的黏包问题及解决办法
python全栈
10-17 3390
一、什么是黏包: 粘包指的是数据和数据之间没有明确的分界线，导致不能正确读取数据 应用程序无法直接操作硬件,应用程序想要发送数据则必须将数据交给操作系统，而操作系统需要同时为所有应用程序提供数据传输服务，也就意味着，操作系统不可能立马就能将应用程序的数据发送出去,就需要为应用程 序提供一个缓冲区，用于临时存放数据，具体流程如下: 这意味着UDP根本不会粘包，但是会丢数据，不可靠。 意味着: TCP传输数据是可靠的，但是会粘包。 二、用代码说明黏包问题（发送方出现的粘包问题）： 服务器端： from soc
Python网络编程之udp编程、黏包以及解决方案、tcpserver
最新发布
景天科技苑
01-29 1426
TCP协议，每次都要经过三次握手才能建立连接，效率比较低。有没有更快的数据传输方式呢？ udp第一次只能客户端发送数据，服务端接收到后，知道了客户端的ip和端口，服务端才能给客户端发数据。
tcp和udp是什么
09-09
TCP和UDP是计算机网络中两种常见的传输协议。TCP是传输控制协议（Transmission Control Protocol），而UDP是用户数据报协议（User Datagram Protocol）。 TCP是一种可靠的、面向连接的协议。它使用三次握手建立连接，并提供数据的可靠传输，确保数据按照正确的顺序到达目标设备。TCP的头部较长，至少20个字节，并且会产生粘包问题。 UDP是一种不可靠的、面向无连接的协议。它不需要建立连接，直接发送数据报文。UDP的头部较短，只有8个字节，但是会产生丢包问题。UDP支持一对一、一对多、多对多和多对一的传输方式，提供了单播、多播和广播的功能。UDP是面向报文的，即将发送的数据作为一个整体进行传输。 这两种协议都位于计算机网络模型中的运输层，负责传输应用层产生的数据。TCP主要用于可靠传输，适用于需要确保数据完整性和顺序的场景，如网页浏览和文件传输。UDP主要用于实时传输和对可靠性要求较低的场景，如音频和视频流传输以及在线游戏。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值