优化IOS
This commit is contained in:
+486
-25
@@ -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 }
|
||||
|
||||
Reference in New Issue
Block a user