P2P 与分布式存储 / 系统课时

Request/Piece 消息时序

Request/Piece 消息时序

BitTorrent 客户端获得 Peer 的分块可用信息后,需要通过 Request 请求具体数据,再由 Piece 返回实际字节。本课使用一组可复现的报文,解析消息长度、分块索引、块内偏移和请求长度,重建完整的请求响应时序,并验证收到的数据是否对应原请求。

学习目标

  • 识别 Request 与 Piece 的消息 ID、长度前缀及字段编码。
  • 使用分块索引、块内偏移和请求长度匹配请求与响应。
  • 编写 Python 示例构造、解析并验证一次分块传输。

Request 与 Piece 的报文结构

BitTorrent Peer Wire Protocol 使用四字节大端无符号整数表示消息长度。长度字段自身不计入该数值;普通消息的长度包含一字节消息 ID 和后续载荷。

Request 的消息 ID 为 6,固定消息长度为 13,完整报文共 17 字节。它包含三个四字节大端无符号整数:

字段 字节数 示例值 含义
length 4 13 ID 与载荷总长度
id 1 6 Request 消息
index 4 2 请求第 2 号 Piece
begin 4 16384 Piece 内起始偏移
length(请求字段) 4 4096 请求的数据字节数

这里两个 length 不能混淆:第一个是消息帧长度,第二个是本次请求的数据长度。Piece 索引从 0 开始,begin 是当前 Piece 内的字节偏移,而不是整个资源的绝对偏移。

Piece 的消息 ID 为 7,载荷依次包含 index、begin 和 block。假设返回 4096 字节,则消息长度为 9 + 4096 = 4105,完整报文长度为 4109 字节。

字段 字节数 示例值
length 4 4105
id 1 7
index 4 2
begin 4 16384
block 4096 实际数据字节

Piece 消息没有独立的请求长度字段。接收端应从 消息长度 - 9 计算实际 block 长度,再与对应的未完成 Request 核对。

从请求到响应的消息时序

假设种子元数据指定 piece length = 32768 字节,目标 Piece 索引为 2,客户端已经通过 Bitfield 或 Have 确认远端持有该 Piece。

一次典型交互按以下顺序进行:

  1. 双方完成握手,交换必要的 Bitfield 或 Have 信息。
  2. 下载端发送 Interested(ID 为 2),表示希望获取远端数据。
  3. 上传端发送 Unchoke(ID 为 1),允许下载端提出 Request。
  4. 下载端发送 Request,指定 index=2、begin=16384、length=4096。
  5. 上传端检查请求范围及本地数据可用性,返回 Piece,携带相同的 index、begin 和 4096 字节数据。
  6. 下载端根据请求记录匹配响应,将数据写入 Piece 的相应偏移,并在收齐完整 Piece 后进行哈希验证。

BitTorrent Request 与 Piece 请求响应时序及字段匹配

在这个例子中,Piece 2 的资源全局起始偏移为 2 × 32768 = 65536 字节。收到的块写入全局偏移 65536 + 16384 = 81920,覆盖区间 [81920, 86016)。

使用 Python 构造并解析报文

下面使用 Python 3.10 及以上版本的标准库 struct 构造 Request 和 Piece。示例不依赖真实网络,使用内存字节模拟上传端返回数据,重点验证协议字段和请求响应匹配关系。

python
import struct

PIECE_INDEX = 2
PIECE_LENGTH = 32768
BEGIN = 16384
REQUEST_LENGTH = 4096


def encode_request(index, begin, size):
    # 网络字节序使用大端,Request 消息长度固定为 13。
    return struct.pack(">IBIII", 13, 6, index, begin, size)


def encode_piece(index, begin, block):
    # Piece 的消息长度为 1 字节 ID + 8 字节位置字段 + 数据长度。
    return struct.pack(">IBII", 9 + len(block), 7, index, begin) + block


def decode_frame(frame):
    if len(frame) < 5:
        raise ValueError("消息头不完整")
    message_length = struct.unpack_from(">I", frame, 0)[0]
    if len(frame) != 4 + message_length:
        raise ValueError("消息长度不匹配")
    return frame[4], frame[5:]


def main():
    request = encode_request(PIECE_INDEX, BEGIN, REQUEST_LENGTH)
    req_id, req_payload = decode_frame(request)
    index, begin, size = struct.unpack(">III", req_payload)

    if req_id != 6 or begin + size > PIECE_LENGTH:
        raise ValueError("非法 Request")

    # 用确定性字节内容模拟上传端持有的完整 Piece。
    source_piece = bytes(i % 256 for i in range(PIECE_LENGTH))
    block = source_piece[begin:begin + size]
    response = encode_piece(index, begin, block)

    piece_id, payload = decode_frame(response)
    if piece_id != 7 or len(payload) < 8:
        raise ValueError("非法 Piece")
    received_index, received_begin = struct.unpack_from(">II", payload, 0)
    received_block = payload[8:]

    # 三项必须与尚未完成的请求对应。
    matched = (
        received_index == index
        and received_begin == begin
        and len(received_block) == size
    )
    if not matched:
        raise ValueError("响应与请求不匹配")

    print(f"Request: id={req_id}, frame={len(request)} bytes")
    print(f"index={index}, begin={begin}, length={size}")
    print(f"Piece: id={piece_id}, frame={len(response)} bytes")
    print(f"block={len(received_block)} bytes, matched={matched}")
    print(f"global_offset={index * PIECE_LENGTH + begin}")


if __name__ == "__main__":
    main()

预期输出:

text
Request: id=6, frame=17 bytes
index=2, begin=16384, length=4096
Piece: id=7, frame=4109 bytes
block=4096 bytes, matched=True
global_offset=81920

这里的 matched=True 只证明响应字段与本地请求记录一致,并不代表内容已经通过完整性校验。真实客户端必须在完整 Piece 收齐后,按种子元数据规定的哈希机制验证内容;v1 使用 SHA-1 Piece 哈希,v2 使用相应的 SHA-256 Merkle 校验机制。

处理 TCP 分帧与并发请求

TCP 提供连续字节流,不保证一次 recv() 正好得到一条完整的 BitTorrent 消息。接收端应先读取四字节长度前缀,再累计接收对应长度的消息体,不能把一次网络读取直接当作完整 Piece。

实际下载通常同时存在多个未完成 Request。例如同一 Piece 可以并发请求三个不同区间:

index begin 请求长度 结束偏移
2 0 16384 16384
2 16384 8192 24576
2 24576 8192 32768

客户端可使用 (index, begin, length) 保存未完成请求记录;收到 Piece 后先依据 index 和 begin 定位请求,再用实际 block 长度核对原请求长度。不能只按响应到达顺序匹配,因为不同请求可能乱序完成。

对普通请求,还应检查 begin + length 不超过当前 Piece 的实际长度,且请求长度符合实现和对端支持的限制。常见兼容做法是使用不超过 16 KiB 的请求块,并避免发送零长度请求;最后一个 Piece 的实际长度可能小于种子声明的标准 Piece 长度。

判断请求超时与数据完成

如果请求发出后迟迟没有收到对应 Piece,应根据未完成请求表记录的发送时间判断超时,而不是直接认定整个 Peer 已断线。例如实验环境可以先设置 10 秒请求超时,生产实现再结合 RTT、拥塞情况和 Peer 表现调整。

收到迟到的 Piece 时,应检查该数据范围是否仍被需要;对已完成或已取消的请求,不应重复计算有效下载进度。若连接支持 Cancel(ID 为 8),客户端可以发送与原 Request 相同的 index、begin、length 取消尚未完成的请求,但取消消息不能保证已经开始发送的数据一定停止。

验证一次完整交换时,至少确认以下条件:

  • Request 消息长度为 13,完整报文为 17 字节。
  • Piece 的 index、begin 与未完成请求对应,实际块长度等于请求长度。
  • 数据写入位置按 Piece 索引和块内偏移计算,没有越界或重复计数。
  • 完整 Piece 的哈希验证通过后,才将该 Piece 标记为可信并向其他 Peer 宣告 Have。

Request 负责准确描述所需的字节区间,Piece 负责携带对应的数据。实现时将消息分帧、请求匹配、数据缓存与完整性验证分开处理,才能正确应对乱序响应、超时、重复数据和恶意报文。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

Request/Piece 消息时序

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通