优化IOS

This commit is contained in:
zhy200308
2026-08-19 09:31:21 +08:00
parent 7023062b45
commit eae24000e9
29 changed files with 4025 additions and 377 deletions
+17
View File
@@ -5,6 +5,23 @@ func sha256Hex(_ data: Data) -> String {
SHA256.hash(data: data).map { String(format: "%02x", $0) }.joined()
}
extension Data {
/// 十六进制字符串转字节。只在测试里造光学清单时用。
init?(hexString: String) {
guard hexString.count % 2 == 0 else { return nil }
var bytes = [UInt8]()
bytes.reserveCapacity(hexString.count / 2)
var index = hexString.startIndex
while index < hexString.endIndex {
let next = hexString.index(index, offsetBy: 2)
guard let byte = UInt8(hexString[index..<next], radix: 16) else { return nil }
bytes.append(byte)
index = next
}
self.init(bytes)
}
}
/// 从管道里读一行,带超时。用来等 MockPCServer 打印 `READY <port>`。
func readReadyLine(from handle: FileHandle, timeout: TimeInterval) -> String? {
let deadline = Date().addingTimeInterval(timeout)
+52 -14
View File
@@ -76,35 +76,50 @@ class Handler(BaseHTTPRequestHandler):
def _download(self):
path = STATE["serve"]
size = os.path.getsize(path)
offset = 0
header = self.headers.get("Range")
# 老版本/别的实现可能整个忽略 Range,直接把整份文件送过来。
# 客户端必须能识别这种服务端并回落单流下载。
if STATE.get("ignore_range"):
header = None
# 与 sender.rs::parse_range 同一套语义:开区间与闭区间都接受,
# 不支持后缀 Range,越界一律拒绝。
offset, end = 0, max(size - 1, 0)
if header:
assert header.startswith("bytes="), "只支持 bytes= 形式的 Range"
assert header.endswith("-"), "sender.rs 只支持单段开区间 Range"
offset = int(header[len("bytes="):-1])
assert 0 <= offset < size, "Range 越界"
remaining = size - offset
start_text, _, end_text = header[len("bytes="):].partition("-")
assert start_text, "不支持后缀 Range"
offset = int(start_text)
end = int(end_text) if end_text else size - 1
assert 0 <= offset < size and offset <= end < size, "Range 越界"
remaining = 0 if size == 0 else end - offset + 1
self.send_response(206 if offset else 200)
self.send_response(206 if header else 200)
self.send_header("Content-Type", "application/octet-stream")
self.send_header("Content-Length", str(remaining))
self.send_header("Accept-Ranges", "bytes")
if offset:
self.send_header("Content-Range", "bytes %d-%d/%d" % (offset, size - 1, size))
if header:
self.send_header("Content-Range", "bytes %d-%d/%d" % (offset, end, size))
self.send_header("X-QFT-Filename", b64url_encode(os.path.basename(path).encode("utf-8")))
self.send_header("Connection", "close")
# 并行下载会在一条连接上连续发多个 Range 请求,
# sender.rs 对这种请求保持 keep-alive
self.send_header("Connection", "keep-alive")
self.end_headers()
with open(path, "rb") as fh:
fh.seek(offset)
while True:
block = fh.read(256 * 1024)
left = remaining
while left > 0:
block = fh.read(min(256 * 1024, left))
if not block:
break
self.wfile.write(block)
left -= len(block)
# -------------------------------------------------- POST
def do_POST(self):
# 配对是唯一不校验令牌的端点——它的作用正是换取令牌
if self.path == "/qft/pair":
return self._pair()
if not self._authorized():
return
if self.path == "/qft/upload/init":
@@ -115,6 +130,20 @@ class Handler(BaseHTTPRequestHandler):
return self._upload_finish()
return self._json(404, {"ok": False})
def _pair(self):
"""receiver.rs::handle_pair:6 位十六进制秘密换会话令牌,错 5 次作废。"""
max_failures = 5
if STATE["pair_failures"] >= max_failures:
return self._json(429, {"ok": False, "error": "配对码已因多次输入错误作废"})
if self.headers.get("X-QFT-Code") != STATE["code"]:
STATE["pair_failures"] += 1
return self._json(403, {
"ok": False,
"remaining": max_failures - STATE["pair_failures"],
})
STATE["pair_failures"] = 0
return self._json(200, {"ok": True, "token": STATE["token"]})
def _upload_init(self):
name = b64url_decode(self.headers["X-QFT-Filename"]).decode("utf-8")
size = int(self.headers["X-QFT-Size"])
@@ -187,7 +216,7 @@ class Handler(BaseHTTPRequestHandler):
def udp_responder(token, http_port, stop):
"""QFTDISC2:<token> → QFTHERE2:<token>:<port>,对应 sender.rs 的发现线程。"""
"""receiver.rs 的 UDP 线程:既回 QFTDISC2,也回不带令牌的 QFTBROWSE3。"""
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
@@ -197,6 +226,9 @@ def udp_responder(token, http_port, stop):
sock.settimeout(0.25)
expected = ("QFTDISC2:%s" % token).encode("ascii")
reply = ("QFTHERE2:%s:%d" % (token, http_port)).encode("ascii")
announce = ("QFTNODE3:" + json.dumps(
{"n": "MOCK-PC", "p": "macos", "t": http_port, "r": True},
separators=(",", ":"))).encode("utf-8")
while not stop.is_set():
try:
data, peer = sock.recvfrom(512)
@@ -204,7 +236,9 @@ def udp_responder(token, http_port, stop):
continue
except OSError:
break
if data == expected:
if data == b"QFTBROWSE3":
sock.sendto(announce, peer)
elif data == expected:
sock.sendto(reply, peer)
sock.close()
@@ -216,9 +250,13 @@ def main():
parser.add_argument("--save-dir", required=True, help="接收上传的目录")
parser.add_argument("--port", type=int, default=0)
parser.add_argument("--udp", action="store_true", help="同时启动 UDP 发现应答")
parser.add_argument("--code", default="a1b2c3", help="/qft/pair 使用的 6 位十六进制秘密")
parser.add_argument("--ignore-range", action="store_true",
help="模拟不支持分段下载的电脑端,永远返回 200 整份文件")
args = parser.parse_args()
STATE.update(token=args.token, serve=args.serve, save_dir=args.save_dir, uploads={})
STATE.update(token=args.token, serve=args.serve, save_dir=args.save_dir, uploads={},
code=args.code, pair_failures=0, ignore_range=args.ignore_range)
os.makedirs(args.save_dir, exist_ok=True)
server = ThreadingHTTPServer(("127.0.0.1", args.port), Handler)
+486 -25
View File
@@ -6,6 +6,10 @@ import Foundation
// 集成测试跑在 MockPCServer.py 上,该 mock 严格复刻 receiver.rs / sender.rs
// 的线上语义,因此这里通过 == 线格式与 Windows 端兼容。
// 输出重定向到文件/管道时 stdout 默认是块缓冲的,一旦中途 trap 就什么都看不到,
// 排查成本极高。改成行缓冲。
setvbuf(stdout, nil, _IOLBF, 0)
var failures = 0
var checks = 0
@@ -129,6 +133,284 @@ checkEqual(LocalNetwork.ipv4("192.168.1.20"), 0xC0A80114, "IPv4 转整数")
checkEqual(LocalNetwork.format(0xC0A80114), "192.168.1.20", "整数转 IPv4")
check(LocalNetwork.ipv4("192.168.1.256") == nil, "拒绝越界八位组")
// iOS SDK 不导出 net/route.h,路由表报文只能按手写偏移解析。
// macOS SDK 有真类型,在这里逐字段交叉校验——布局一旦变了立刻红。
typealias RM = LocalNetwork.RouteMessage
checkEqual(RM.headerSize, MemoryLayout<rt_msghdr>.size, "rt_msghdr 大小")
checkEqual(RM.messageLengthOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_msglen), "rtm_msglen 偏移")
checkEqual(RM.versionOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_version), "rtm_version 偏移")
checkEqual(RM.interfaceIndexOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_index), "rtm_index 偏移")
checkEqual(RM.addressMaskOffset, MemoryLayout<rt_msghdr>.offset(of: \.rtm_addrs), "rtm_addrs 偏移")
checkEqual(Int32(RM.version), Int32(RTM_VERSION), "RTM_VERSION")
checkEqual(RM.gatewayFlag, Int32(RTF_GATEWAY), "RTF_GATEWAY")
checkEqual(RM.addressSlots, Int(RTAX_MAX), "RTAX_MAX")
checkEqual(RM.destinationSlot, Int(RTAX_DST), "RTAX_DST")
checkEqual(RM.gatewaySlot, Int(RTAX_GATEWAY), "RTAX_GATEWAY")
// 路由表读的是本机真实状态,不能断言具体内容,但**必须**保证:
// 不崩、且返回的东西全部是私有 IPv4——它会被直接当成电脑地址去连。
let gateways = LocalNetwork.defaultGateways()
check(gateways.allSatisfy(PairingProtocol.isPrivateIPv4), "默认网关全部是私有 IPv4(读到 \(gateways.count) 个)")
check(LocalNetwork.directedBroadcastAddresses().allSatisfy { $0.split(separator: ".").count == 4 },
"定向广播地址格式正确")
let candidates = LocalNetwork.hostCandidates(port: 39393, limit: 8)
check(candidates.allSatisfy { PairingProtocol.isAllowedLocalHTTPEndpoint($0, expectedPort: 39393) },
"候选地址全部过端点白名单")
check(Set(candidates).count == candidates.count, "候选地址无重复")
// ---------------------------------------------------------------- 专用网络
section("专用网络(Windows QFT Direct)")
let directText = makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "n": "DESKTOP-QFT", "p": 39393,
"e": [], "w": ["QFT-PC-abc123", "0123456789abcdef"],
])
let direct = PairingProtocol.parse(directText)
check(direct != nil, "接受只带 Wi-Fi 凭据、不带地址的专用网络二维码")
checkEqual(direct?.wifi, WifiCredentials(ssid: "QFT-PC-abc123", passphrase: "0123456789abcdef"), "Wi-Fi 凭据")
check(direct?.endpoints.isEmpty == true, "专用网络二维码不带任何电脑地址")
check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "p": 39393, "e": [],
])) == nil, "既无地址又无 Wi-Fi 时拒绝")
check(PairingProtocol.parse(makePairingText(prefix: "QFTPAIR2:", [
"v": 2, "s": session, "p": 39393, "e": [], "w": ["QFT-PC", "short"],
])) == nil, "Wi-Fi 密码过短时拒绝")
let lanPairing = PairingPayload(version: 2, session: session, pcName: "MAC", port: 39393,
endpoints: ["http://192.168.1.9:39393"], wifi: nil,
direction: .uploadToPC, fileName: nil, fileSize: nil, sha256: nil)
checkEqual(DedicatedNetworkPlan.plan(for: lanPairing, canJoinProgrammatically: true),
.useEndpoints(["http://192.168.1.9:39393"]), "有地址时直接连,不去动 Wi-Fi")
checkEqual(DedicatedNetworkPlan.plan(for: direct!, canJoinProgrammatically: true),
.joinWifi(direct!.wifi!), "有能力时自动加入专用 Wi-Fi")
checkEqual(DedicatedNetworkPlan.plan(for: direct!, canJoinProgrammatically: false),
.manualJoin(direct!.wifi!), "没有 entitlement 时转为手动加入引导,而不是假装成功")
// ---------------------------------------------------------------- Base45
section("Base45(与 desktop/src/base45.rs 同一组向量)")
checkEqual(Base45.encode(Data("AB".utf8)), "BB8", "编码 AB")
checkEqual(Base45.encode(Data("Hello!!".utf8)), "%69 VD92EX0", "编码 Hello!!")
checkEqual(Base45.encode(Data("base-45".utf8)), "UJCLQE7W581", "编码 base-45")
checkEqual(Base45.decode("BB8"), Data("AB".utf8), "解码 BB8")
checkEqual(Base45.decode("%69 VD92EX0"), Data("Hello!!".utf8), "解码 Hello!!")
checkEqual(Base45.decode("K1"), Data([0x41]), "两字符尾块解出单字节")
check(Base45.decode("AB") == nil, "两字符尾块超过 0xFF 时拒绝(A+B*45=505)")
check(Base45.decode("A") == nil, "长度 %3==1 时拒绝")
check(Base45.decode("ab") == nil, "小写不在字母表内,拒绝")
check(Base45.decode("::::::") == nil, "超过 0xFFFF 的三元组拒绝")
var base45RoundTripOK = true
for _ in 0..<200 {
let raw = Data((0..<Int.random(in: 0...600)).map { _ in UInt8.random(in: 0...255) })
if Base45.decode(Base45.encode(raw)) != raw { base45RoundTripOK = false; break }
}
check(base45RoundTripOK, "200 组随机字节 Base45 往返一致")
// ---------------------------------------------------------------- 光学协议
section("光学 QFT2 帧")
func opticalPlaylist(payload: Data, chunkSize: Int, name: String,
sessionID: UInt64 = 0x0123_4567_89ab_cdef) -> (OpticalManifest, [String]) {
let total = payload.isEmpty ? 0 : UInt32((payload.count + chunkSize - 1) / chunkSize)
let manifest = OpticalManifest(
sessionID: sessionID, senderDevice: "DESKTOP-QFT", fileName: name,
fileSize: UInt64(payload.count), chunkSize: chunkSize, totalChunks: total,
sha256: Data(hexString: sha256Hex(payload))!)
var frames = [OpticalProtocol.text(for: OpticalProtocol.encodeManifest(manifest))]
for index in 0..<Int(total) {
let start = index * chunkSize
let end = min(start + chunkSize, payload.count)
frames.append(OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .data, sessionID: sessionID, seq: UInt32(index),
totalChunks: total, payload: payload.subdata(in: start..<end))))
}
frames.append(OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .end, sessionID: sessionID, seq: 0, totalChunks: total, payload: Data())))
return (manifest, frames)
}
let opticalPayload = Data((0..<4321).map { UInt8($0 % 251) })
let (opticalManifest, opticalFrames) = opticalPlaylist(payload: opticalPayload,
chunkSize: 450, name: "报告.pdf")
check(opticalFrames.allSatisfy { $0.hasPrefix("QFT2:") }, "帧文本前缀为 QFT2:")
check(opticalFrames.allSatisfy(OpticalProtocol.isOpticalText), "全部被识别为光学帧")
let parsedManifest = OpticalProtocol.parseText(opticalFrames[0]).flatMap(OpticalProtocol.parseManifest)
checkEqual(parsedManifest, opticalManifest, "清单帧编解码往返一致")
checkEqual(parsedManifest?.fileName, "报告.pdf", "文件名支持中文")
checkEqual(parsedManifest?.sha256Hex, sha256Hex(opticalPayload), "清单里的 SHA-256")
// CRC 是唯一能挡住「语法合法但内容错误」的相机误识别的手段
var corrupted = OpticalProtocol.encodeFrame(kind: .data, sessionID: 1, seq: 0,
totalChunks: 1, payload: Data([1, 2, 3]))
corrupted[OpticalProtocol.headerSize] ^= 0x40
check(OpticalProtocol.parseBinary(corrupted, magic: "QFT2", version: 2) == nil, "CRC 不符时整帧丢弃")
check(OpticalProtocol.parseText("QFT2:" + String(repeating: "0", count: 60)) == nil, "噪声文本不会被当成帧")
check(OpticalProtocol.parseText("QFT2:") == nil, "空帧被拒绝")
check(OpticalProtocol.parseText("hello") == nil, "非 QFT 文本被忽略")
checkEqual(OpticalProtocol.sanitizeFileName("../../etc/passwd"), "etc_passwd", "文件名里的路径分隔符被清掉")
checkEqual(OpticalProtocol.sanitizeFileName(" "), "qft.bin", "空文件名有兜底")
// ---------------------------------------------------------------- 光学装配
section("光学会话装配")
let opticalRoot = URL(fileURLWithPath: NSTemporaryDirectory())
.appendingPathComponent("qft-optical-\(UUID().uuidString)", isDirectory: true)
try! FileManager.default.createDirectory(at: opticalRoot, withIntermediateDirectories: true)
var opticalSaved: URL?
var opticalErrors: [String] = []
var opticalProgressSeen = 0
let assembler = OpticalAssembler(destinationDirectory: opticalRoot,
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
switch event {
case .completed(_, let url): opticalSaved = url
case .failed(let message): opticalErrors.append(message)
case .progress(_, let received, _): opticalProgressSeen = received
case .started: break
}
}
// 真实场景是循环重播:乱序 + 大量重复
var duplicates = 0
var accepted = 0
for text in opticalFrames.shuffled() + opticalFrames {
switch assembler.accept(text: text) {
case .accepted: accepted += 1
case .duplicate: duplicates += 1
case .ignored: break
}
}
check(opticalErrors.isEmpty, "乱序重播过程中没有错误:\(opticalErrors)")
check(opticalSaved != nil, "收齐后自动落盘")
check(duplicates > 0, "重复帧被识别为 duplicate(\(duplicates) 帧),不会重复计入吞吐")
checkEqual(accepted, Int(opticalManifest.totalChunks) + 1, "有效新帧数 = 数据片数 + 清单")
check(opticalProgressSeen == Int(opticalManifest.totalChunks), "进度回调走到最后一片")
if let opticalSaved {
let data = try! Data(contentsOf: opticalSaved)
checkEqual(sha256Hex(data), sha256Hex(opticalPayload), "落盘内容 SHA-256 一致")
checkEqual(opticalSaved.lastPathComponent, "报告.pdf", "落盘文件名正确")
}
// 摘要对不上时必须整份丢弃,绝不把半份文件交给用户
var tamperedError: String?
let tamperedAssembler = OpticalAssembler(
destinationDirectory: opticalRoot.appendingPathComponent("bad"),
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
if case .failed(let message) = event { tamperedError = message }
}
let liar = OpticalManifest(sessionID: 42, senderDevice: "PC", fileName: "x.bin",
fileSize: UInt64(opticalPayload.count), chunkSize: 450,
totalChunks: UInt32((opticalPayload.count + 449) / 450),
sha256: Data(repeating: 0xAB, count: 32))
tamperedAssembler.accept(text: OpticalProtocol.text(for: OpticalProtocol.encodeManifest(liar)))
for index in 0..<Int(liar.totalChunks) {
let start = index * 450
let end = min(start + 450, opticalPayload.count)
tamperedAssembler.accept(text: OpticalProtocol.text(for: OpticalProtocol.encodeFrame(
kind: .data, sessionID: 42, seq: UInt32(index), totalChunks: liar.totalChunks,
payload: opticalPayload.subdata(in: start..<end))))
}
check(tamperedError?.contains("SHA-256") == true, "整份校验失败时报错并丢弃")
check(!FileManager.default.fileExists(
atPath: opticalRoot.appendingPathComponent("bad/x.bin").path), "校验失败的文件不会落到目标目录")
// 空文件是合法的边界:清单里 0 片,收到清单即完成
var emptySaved: URL?
let emptyAssembler = OpticalAssembler(
destinationDirectory: opticalRoot.appendingPathComponent("empty"),
workDirectory: opticalRoot.appendingPathComponent("work")) { event in
if case .completed(_, let url) = event { emptySaved = url }
}
let (_, emptyFrames) = opticalPlaylist(payload: Data(), chunkSize: 450, name: "empty.bin",
sessionID: 7)
emptyAssembler.accept(text: emptyFrames[0])
check(emptySaved != nil, "0 字节文件也能正常收完")
try? FileManager.default.removeItem(at: opticalRoot)
// ---------------------------------------------------------------- ROI
section("光学 ROI 状态机")
var roi = OpticalROI(aspect: 0.5625) // 竖屏 720×1280
check(!roi.isLocked, "初始为搜索态")
check(roi.decodeRegion.width > 0.8, "搜索态覆盖大半个画面")
roi.hit(boundingBox: CGRect(x: 0.30, y: 0.40, width: 0.20, height: 0.12))
check(roi.isLocked, "解出一帧后进入锁定")
let locked = roi.decodeRegion
check(locked.width < 0.6, "锁定后只解一小块(宽 \(String(format: "%.2f", locked.width)))")
// 归一化坐标在 9:16 画面上会把方码拉扁,ROI 必须按像素比例修方
check(abs(locked.width * 0.5625 - locked.height) < 0.02, "锁定框在像素意义上是正方形")
for _ in 0..<(OpticalROI.missesBeforeExpand + 1) { roi.miss() }
check(roi.decodeRegion.width > locked.width, "连续丢失后逐级放大 ROI")
for _ in 0..<OpticalROI.missesBeforeReacquire { roi.miss() }
check(!roi.isLocked && roi.decodeRegion.width > 0.8, "持续丢失后回到全画面重新搜索")
var edge = OpticalROI(aspect: 1)
edge.hit(boundingBox: CGRect(x: 0.95, y: 0.95, width: 0.2, height: 0.2))
let clamped = edge.decodeRegion
check(clamped.minX >= 0 && clamped.minY >= 0
&& clamped.maxX <= 1.0001 && clamped.maxY <= 1.0001, "越界的 ROI 被夹回画面内")
// ---------------------------------------------------------------- 连接码
section("桌面端连接码(与 desktop/src/connect_code.rs 交叉验证)")
// 这四组由 Rust 端实现直接产出,任何一边改了编码都会红
let codeVectors: [(String, Int, String, String)] = [
("192.168.1.20", 39393, "a1b2c3", "480H-98DJ-RCTG"),
("10.0.0.5", 39393, "010203", "4R00-0181-081P-P"),
("172.20.10.3", 40000, "ff007f", "5020-M0WW-83ZG-0ZTH"),
("127.0.0.1", 8080, "deadbe", "5HZG-0001-3Y8D-XBDY-98"),
]
for (address, port, secret, text) in codeVectors {
guard let decoded = try? ConnectCode.decode(text) else {
check(false, "解析 \(text) 失败"); continue
}
checkEqual(decoded.address, address, "\(text) 的地址")
checkEqual(decoded.port, port, "\(text) 的端口")
checkEqual(decoded.secretHex, secret, "\(text) 的秘密")
checkEqual(decoded.encode(), text, "\(text) 重新编码一致")
}
check((try? ConnectCode.decode("480h 98dj rctg")) != nil, "小写与空格分隔都接受")
check((try? ConnectCode.decode("48OH-98DJ-RCTG")) != nil, "Crockford 容错:O 当成 0")
check((try? ConnectCode.decode("480H-98DJ-RCTU")) == nil, "字母表外的字符被拒绝")
check((try? ConnectCode.decode("480H-98DJ-RCTF")) == nil, "改一位后校验失败")
check((try? ConnectCode.decode("480H")) == nil, "长度不足时拒绝")
check(try! ConnectCode.decode("480H-98DJ-RCTG").isUsable, "私有地址的连接码可用")
// 连接码同样是不可信输入:公网地址不能因为「码是对的」就放行
let publicCode = ConnectCode(address: "8.8.8.8", port: 39393, secret: [1, 2, 3])
check(!publicCode.isUsable, "公网地址的连接码被端点白名单拒绝")
// ---------------------------------------------------------------- 节点浏览
section("QFTBROWSE3 节点应答(不可信输入)")
let announce = #"QFTNODE3:{"n":"MacBook-Pro","p":"macos","t":39393,"r":true}"#
let peer = PeerBrowser.parseReply(announce, source: "192.168.1.20")
checkEqual(peer?.name, "MacBook-Pro", "节点名")
checkEqual(peer?.platform, "macos", "平台标识")
checkEqual(peer?.port, 39393, "端口")
checkEqual(peer?.baseURL, "http://192.168.1.20:39393", "base URL")
check(peer?.ready == true, "等待接收标志")
check(PeerBrowser.parseReply(announce, source: "8.8.8.8") == nil, "来源不是私有地址时丢弃")
check(PeerBrowser.parseReply(#"QFTNODE3:{"n":"x","p":"linux","t":0,"r":true}"#,
source: "10.0.0.2") == nil, "端口 0 的应答无意义")
check(PeerBrowser.parseReply("QFTHERE2:token:39393", source: "10.0.0.2") == nil, "前缀不符时丢弃")
check(PeerBrowser.parseReply("QFTNODE3:not-json", source: "10.0.0.2") == nil, "非 JSON 丢弃")
let dirty = PeerBrowser.parseReply(
"QFTNODE3:{\"n\":\"bad\\u0000name\",\"p\":\"linux!!\",\"t\":1,\"r\":false}", source: "10.0.0.2")
check(dirty?.name.contains("\0") == false, "节点名里的控制字符被清掉")
checkEqual(dirty?.platform, "linux", "平台标识只保留字母数字")
// ---------------------------------------------------------------- 集成测试
section("集成:与 MockPCServer 的完整传输")
@@ -226,6 +508,119 @@ if port > 0 {
check(false, "续传失败:\(error.localizedDescription)")
}
// --- 并行 Range 下载 ---
do {
let parallelDir = root.appendingPathComponent("parallel", isDirectory: true)
let client = RangeDownloadClient(host: host, token: token, deviceName: "iPhone 测试机",
destinationDirectory: parallelDir)
// 没有二维码时靠 Range: bytes=0-0 问出文件名与总长度
let probed = try await client.probe()
checkEqual(probed.fileName, "payload.bin", "探测拿到文件名")
checkEqual(probed.fileSize, UInt64(payloadSize), "探测拿到总长度")
let target = RangeDownloadClient.Target(fileName: "payload.bin",
fileSize: UInt64(payloadSize),
sha256: payloadHash)
var parallelFraction = 0.0
let saved = try await client.run(target) { parallelFraction = $0.fraction }
let received = try Data(contentsOf: saved)
checkEqual(sha256Hex(received), payloadHash, "并行下载内容 SHA-256 一致")
check(parallelFraction > 0.99, "并行下载进度回调抵达 100%")
check(!FileManager.default.fileExists(atPath: saved.path + ".qftpart"), "分块临时文件已清理")
check(!FileManager.default.fileExists(
atPath: parallelDir.appendingPathComponent("payload.bin.qftpart.ledger").path),
"断点账本已清理")
try? FileManager.default.removeItem(at: saved)
// 并行分块是乱序落盘的,续传只能靠账本,不能靠「已落盘长度」
let partURL = parallelDir.appendingPathComponent("payload.bin.qftpart")
let ledgerURL = parallelDir.appendingPathComponent("payload.bin.qftpart.ledger")
let chunk = RangeDownloadClient.chunkSize(for: UInt64(payloadSize))
let totalChunks = Int((UInt64(payloadSize) + chunk - 1) / chunk)
var half = [Bool](repeating: false, count: totalChunks)
var scratch = Data(count: payloadSize)
for index in stride(from: 0, to: totalChunks, by: 2) {
half[index] = true
let start = Int(UInt64(index) * chunk)
let end = min(start + Int(chunk), payloadSize)
scratch.replaceSubrange(start..<end, with: payload[start..<end])
}
try scratch.write(to: partURL)
try DownloadLedger(size: UInt64(payloadSize), chunkSize: chunk,
sha256: payloadHash, completed: half).encode().write(to: ledgerURL)
let resumed = try await client.run(target) { _ in }
checkEqual(sha256Hex(try Data(contentsOf: resumed)), payloadHash,
"按账本只补缺失块后内容仍正确")
try? FileManager.default.removeItem(at: resumed)
} catch {
check(false, "并行下载失败:\(error.localizedDescription)")
}
// --- 不支持分段下载的电脑端:必须能被识别出来,交给上层回落单流 ---
do {
let legacyProcess = Process()
legacyProcess.executableURL = URL(fileURLWithPath: "/usr/bin/env")
legacyProcess.arguments = ["python3", mockScript.path, "--token", token,
"--serve", sourceURL.path, "--save-dir", saveDir.path,
"--port", "0", "--ignore-range"]
let legacyPipe = Pipe()
legacyProcess.standardOutput = legacyPipe
try legacyProcess.run()
defer { legacyProcess.terminate() }
let line = readReadyLine(from: legacyPipe.fileHandleForReading, timeout: 10) ?? ""
let legacyPort = Int(line.dropFirst("READY ".count).trimmingCharacters(in: .whitespaces)) ?? 0
check(legacyPort > 0, "不支持分段的 mock 已启动(端口 \(legacyPort))")
if legacyPort > 0 {
let legacyHost = QFTHost(baseURL: "http://127.0.0.1:\(legacyPort)")
let client = RangeDownloadClient(host: legacyHost, token: token,
deviceName: "iPhone 测试机",
destinationDirectory: root.appendingPathComponent("legacy"))
do {
_ = try await client.run(RangeDownloadClient.Target(
fileName: "payload.bin", fileSize: UInt64(payloadSize),
sha256: payloadHash)) { _ in }
check(false, "对端忽略 Range 时本应显式失败")
} catch QFTError.rangeUnsupported {
check(true, "对端忽略 Range 时抛出 rangeUnsupported,上层据此回落单流")
} catch {
check(false, "应抛 rangeUnsupported,实得 \(error)")
}
// 回落路径本身必须还能把文件收完整
let fallbackDir = root.appendingPathComponent("legacy-fallback")
try FileManager.default.createDirectory(at: fallbackDir, withIntermediateDirectories: true)
let fallbackPairing = PairingPayload(
version: 2, session: token, pcName: "OLD-PC", port: legacyPort,
endpoints: [legacyHost.baseURL], wifi: nil, direction: .downloadToPhone,
fileName: "payload.bin", fileSize: UInt64(payloadSize), sha256: payloadHash)
let saved = try await DownloadClient(host: legacyHost, pairing: fallbackPairing,
deviceName: "iPhone 测试机",
destinationDirectory: fallbackDir).run { _ in }
checkEqual(sha256Hex(try Data(contentsOf: saved)), payloadHash, "单流回落后内容仍正确")
}
} catch {
check(false, "分段回落用例失败:\(error.localizedDescription)")
}
// --- 连接码配对 ---
do {
let paired = try await DesktopPairing.pair(baseURL: base, code: "a1b2c3",
deviceName: "iPhone 测试机")
checkEqual(paired, token, "连接码换到会话令牌")
} catch {
check(false, "连接码配对失败:\(error.localizedDescription)")
}
do {
_ = try await DesktopPairing.pair(baseURL: base, code: "000000",
deviceName: "iPhone 测试机")
check(false, "错误连接码本应失败")
} catch {
check(true, "错误连接码被拒绝:\(error.localizedDescription)")
}
// --- 上传 ---
let uploadPairing = PairingPayload(
version: 2, session: token, pcName: "MOCK-PC", port: port,
@@ -267,49 +662,76 @@ process.terminate()
section("隔空投送式配对码")
let sampleQueue = try! PeerQueue.encode(sender: "我的 iPhone", files: [
PeerFileMeta(name: "视频.mov", size: 987_654_321, sha256: String(repeating: "cd", count: 32)),
PeerFileMeta(name: "笔记.txt", size: 12, sha256: String(repeating: "ef", count: 32)),
])
let peerSample = PeerPairing(
version: 1, key: Data((0..<32).map { UInt8($0) }), instance: "qft-abcdefghijkl",
senderName: "我的 iPhone", fileName: "视频.mov", fileSize: 987_654_321,
sha256: String(repeating: "cd", count: 32))
version: 2, key: Data((0..<32).map { UInt8($0) }), instance: "qft-abcdefghijkl",
senderName: "我的 iPhone", fileCount: 2, totalSize: 987_654_333,
queueDigest: PeerQueue.digest(of: sampleQueue), previewName: "视频.mov")
let peerRoundTrip = PeerPairing.parse(peerSample.encode())
checkEqual(peerRoundTrip, peerSample, "QFTP2P1 编解码往返一致")
checkEqual(peerRoundTrip, peerSample, "QFTP2P2 编解码往返一致")
check(PeerPairing.isPeerText(peerSample.encode()), "前缀识别")
check(PairingProtocol.parse(peerSample.encode()) == nil, "P2P 码不会被误判为 QFTPAIR2")
// 多文件的元数据留在链路上,二维码只带摘要——十几个文件的清单会让码密到扫不动
check(peerSample.encode().count < 400, "二维码内容不随文件数增长(\(peerSample.encode().count) 字符)")
func mutatedPeer(_ change: (inout [String: Any]) -> Void) -> String? {
let queueRoundTrip = PeerQueue.decode(sampleQueue)
checkEqual(queueRoundTrip?.files.count, 2, "清单解析出两个文件")
checkEqual(queueRoundTrip?.files.first?.name, "视频.mov", "清单里的文件名")
check(PeerQueue.decode(Data("{}".utf8)) == nil, "空清单被拒绝")
check(PeerQueue.decode(Data(#"{"v":2,"files":[{"name":"../x","size":1,"sha256":"aa"}]}"#.utf8)) == nil,
"清单里的路径分隔符被拒绝")
func mutatedPeer(_ change: (inout [String: Any]) -> Void) -> String {
var object: [String: Any] = [
"v": 1, "k": Base64URL.encode(Data(repeating: 7, count: 32)),
"i": "qft-abcdefghijkl", "n": "iPhone", "f": "a.bin",
"z": 10, "h": String(repeating: "ab", count: 32),
"v": 2, "k": Base64URL.encode(Data(repeating: 7, count: 32)),
"i": "qft-abcdefghijkl", "n": "iPhone", "c": 1, "z": 10,
"d": String(repeating: "ab", count: 32), "f": "a.bin",
]
change(&object)
let data = try! JSONSerialization.data(withJSONObject: object)
return PeerPairing.prefix + Base64URL.encode(data)
}
check(PeerPairing.parse(mutatedPeer { $0["k"] = Base64URL.encode(Data(repeating: 7, count: 16)) }!) == nil,
check(PeerPairing.parse(mutatedPeer { $0["k"] = Base64URL.encode(Data(repeating: 7, count: 16)) }) == nil,
"密钥不足 32 字节时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["i"] = "bad instance!" }!) == nil, "非法实例名时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["f"] = "../../etc/passwd" }!) == nil, "文件名含路径分隔符时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["h"] = "zz" }!) == nil, "摘要格式错误时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["i"] = "bad instance!" }) == nil, "非法实例名时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["f"] = "../../etc/passwd" }) == nil, "预览文件名含路径分隔符时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["d"] = "zz" }) == nil, "摘要格式错误时拒绝")
check(PeerPairing.parse(mutatedPeer { $0["c"] = 0 }) == nil, "文件数为 0 时拒绝")
check(PeerPairing.newKey().count == 32, "新密钥为 32 字节")
check(PeerPairing.isValidInstance(PeerPairing.newInstance()), "新实例名合法")
check(PeerPairing.newKey() != PeerPairing.newKey(), "密钥每次不同")
// ---------------------------------------------------------------- P2P 传输
section("隔空投送式点对点传输(TLS-PSK 真实握手)")
section("隔空投送式点对点传输(TLS-PSK 真实握手,多文件)")
let peerDir = root.appendingPathComponent("peer", isDirectory: true)
try! FileManager.default.createDirectory(at: peerDir, withIntermediateDirectories: true)
// 三个大小各异的文件:大文件跨多个数据帧,空文件是最容易写错的边界
let peerSources: [(String, Data)] = [
("大文件.bin", payload),
("小文件.txt", Data("QFT 隔空多文件".utf8)),
("空文件.dat", Data()),
]
let peerURLs = peerSources.map { name, data -> URL in
let url = root.appendingPathComponent(name)
try! data.write(to: url)
return url
}
let peerTotal = peerSources.reduce(UInt64(0)) { $0 + UInt64($1.1.count) }
let peerSemaphore = DispatchSemaphore(value: 0)
Task {
defer { peerSemaphore.signal() }
let sender = PeerSender(fileURL: sourceURL, deviceName: "发送端 iPhone")
let sender = PeerSender(fileURLs: peerURLs, deviceName: "发送端 iPhone")
do {
let pairing = try sender.start()
checkEqual(pairing.fileSize, UInt64(payloadSize), "配对码里的文件大小")
checkEqual(pairing.sha256, payloadHash, "配对码里的 SHA-256 由发送端实算")
checkEqual(pairing.fileCount, 3, "配对码里的文件数")
checkEqual(pairing.totalSize, peerTotal, "配对码里的总字节数由发送端实读")
let port = try await sender.listeningPort()
check(port > 0, "监听器就绪(端口 \(port))")
@@ -324,14 +746,23 @@ Task {
async let sendSide: Void = sender.waitAndSend { _ in }
var peerFraction = 0.0
let saved = try await receiver.run { peerFraction = $0.fraction }
var seenNames: [String] = []
let saved = try await receiver.run {
peerFraction = $0.progress.fraction
if seenNames.last != $0.fileName { seenNames.append($0.fileName) }
}
try await sendSide
let data = try Data(contentsOf: saved)
checkEqual(data.count, payloadSize, "P2P 收到字节数一致")
checkEqual(sha256Hex(data), payloadHash, "P2P 收到内容 SHA-256 一致")
checkEqual(saved.count, 3, "三个文件全部落盘")
for (index, source) in peerSources.enumerated() where index < saved.count {
let data = try Data(contentsOf: saved[index])
checkEqual(sha256Hex(data), sha256Hex(source.1), "\(source.0) 内容一致")
checkEqual(saved[index].lastPathComponent, source.0, "\(source.0) 文件名一致")
}
check(peerFraction > 0.99, "P2P 进度回调抵达 100%")
check(!FileManager.default.fileExists(atPath: saved.path + ".qftpart"), "P2P 临时文件已清理")
check(seenNames.count >= 2, "进度回调报告了当前文件名(\(seenNames))")
check(!FileManager.default.fileExists(atPath: peerDir.appendingPathComponent("大文件.bin.qftpart").path),
"P2P 临时文件已清理")
} catch {
check(false, "P2P 传输失败:\(error.localizedDescription)")
}
@@ -341,18 +772,48 @@ if peerSemaphore.wait(timeout: .now() + 60) == .timedOut {
check(false, "P2P 传输超时")
}
// 清单摘要必须锁死「扫到的就是收到的」
let digestSemaphore = DispatchSemaphore(value: 0)
Task {
defer { digestSemaphore.signal() }
let sender = PeerSender(fileURLs: [peerURLs[1]], deviceName: "发送端")
do {
let pairing = try sender.start()
let port = try await sender.listeningPort()
let tampered = PeerPairing(version: 2, key: pairing.key, instance: pairing.instance,
senderName: pairing.senderName, fileCount: pairing.fileCount,
totalSize: pairing.totalSize,
queueDigest: String(repeating: "ab", count: 32),
previewName: pairing.previewName)
var receiver = PeerReceiver(pairing: tampered,
destinationDirectory: peerDir.appendingPathComponent("bad"))
receiver.directPort = port
async let sendSide: Void = sender.waitAndSend { _ in }
_ = try await receiver.run { _ in }
_ = try? await sendSide
check(false, "清单摘要不符本应被拒绝")
} catch {
check(true, "清单摘要不符时接收端拒绝:\(error.localizedDescription)")
}
sender.stop()
}
if digestSemaphore.wait(timeout: .now() + 30) == .timedOut {
check(false, "清单摘要用例超时")
}
// 错误密钥必须握手失败
let wrongKeySemaphore = DispatchSemaphore(value: 0)
Task {
defer { wrongKeySemaphore.signal() }
let sender = PeerSender(fileURL: sourceURL, deviceName: "发送端")
let sender = PeerSender(fileURLs: [peerURLs[1]], deviceName: "发送端")
do {
let pairing = try sender.start()
let port = try await sender.listeningPort()
let tampered = PeerPairing(version: 1, key: PeerPairing.newKey(),
let tampered = PeerPairing(version: 2, key: PeerPairing.newKey(),
instance: pairing.instance, senderName: pairing.senderName,
fileName: pairing.fileName, fileSize: pairing.fileSize,
sha256: pairing.sha256)
fileCount: pairing.fileCount, totalSize: pairing.totalSize,
queueDigest: pairing.queueDigest,
previewName: pairing.previewName)
var receiver = PeerReceiver(pairing: tampered, destinationDirectory: peerDir)
receiver.directPort = port
_ = try await receiver.run { _ in }