Files
QFT/ios/QFT/Core/HostDiscovery.swift
T
zhy200308 4d77ba6c91 feat: 新增 iPhone 客户端,含隔空投送式点对点互传
三条链路:
- 电脑 → iPhone:扫 QFTSEND2 码下载,流式落盘 + 增量 SHA-256,
  支持 Range 断点续传
- iPhone → 电脑:扫 QFTPAIR2 码后 init/chunk/finish 并行分块上传
- iPhone ↔ iPhone:QFTP2P1 扫码握手,Network.framework 开启
  includePeerToPeer(AirDrop 同款 BLE 发现 + AWDL 点对点 Wi-Fi),
  两台设备不需要连同一个 Wi-Fi,也不需要路由器

P2P 用 TLS-PSK 握手:32 字节预共享密钥由发送端随机生成并写进二维码,
扫码这个动作本身完成带外密钥交换与双向认证,无需证书体系与配对弹窗。
未扫到码的第三方连上来过不了握手。

核心层刻意不 import UIKit,可直接以 macOS 为目标编译测试,
不需要 Xcode 也不需要模拟器,已接入主自检套件,72 项全部通过:
- 端点白名单 11 种拒绝用例(域名、公网、172.32 边界、
  非规范八位组、IPv6、带凭据/路径/query)
- CoreTests/MockPCServer.py 严格复刻 receiver.rs / sender.rs 的线上语义
  (路径、header 名、JSON 字段、Range 行为、chunk 长度校验),
  构成 Swift 与 Rust 两端的线格式契约测试,任一端改协议即会失败
- 真实 TLS-PSK 握手下的 P2P 端到端传输,含错误密钥必须被拒

iOS 平台限制(已在 ios/README.md 说明):
NEHotspotConfiguration 需要付费账号 entitlement,故不实现 Direct AP
流程,与电脑互传要求同一局域网;AWDL 是苹果私有链路,Windows 无法参与。
上传块固定 4 MiB 而非 Android 的 4/8/16 MiB,因为 iOS 上
worker 数 × 块大小即内存峰值。

未验证部分:本机只有 Command Line Tools,无 Xcode 与 iOS SDK,
UI 层(SwiftUI/UIKit/AVFoundation)未经编译;.xcodeproj 已通过
plutil 解析与引用完整性校验(42 个对象无悬空引用),
但未在 Xcode 中实际打开过。
2026-08-11 09:08:37 +08:00

272 lines
11 KiB
Swift
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import Foundation
#if canImport(UIKit)
import UIKit
#endif
enum DeviceInfo {
static var name: String {
#if canImport(UIKit)
let raw = UIDevice.current.name
#else
let raw = Host.current().localizedName ?? "iPhone"
#endif
let cleaned = raw.filter { !$0.isNewline }
return cleaned.isEmpty ? "iPhone" : String(cleaned.prefix(64))
}
}
struct QFTHost: Equatable {
let baseURL: String // 形如 http://192.168.1.20:39393
}
enum QFTError: LocalizedError {
case hostNotFound
case httpStatus(Int, String)
case malformedResponse(String)
case integrity(String)
case cancelled
var errorDescription: String? {
switch self {
case .hostNotFound:
return "找不到电脑。请确认手机和电脑连在同一个 Wi-Fi,并且电脑上的 QFT 正在等待连接。"
case .httpStatus(let code, let detail):
return "电脑返回 HTTP \(code)\(detail.isEmpty ? "" : ":\(detail)")"
case .malformedResponse(let detail):
return "电脑返回的数据无法解析:\(detail)"
case .integrity(let detail):
return "校验失败:\(detail)"
case .cancelled:
return "已取消"
}
}
}
/// 在局域网里定位 Windows 端。
///
/// 顺序:二维码自带的 endpoint → UDP QFTDISC2 广播 → 当前子网有界扫描。
/// 与 Android 端同一套策略,但去掉了 Direct-AP 相关的分支:iOS 连不上指定 AP。
struct HostDiscovery {
let pairing: PairingPayload
let deviceName: String
static let discoveryPort: UInt16 = 39392
func locate() async throws -> QFTHost {
if let host = await probe(pairing.endpoints, timeout: 1.2) {
return host
}
if let hinted = await udpDiscover(timeout: 1.5),
let host = await probe([hinted], timeout: 1.5) {
return host
}
let candidates = LocalNetwork.subnetCandidates(port: pairing.port, limit: 254)
if !candidates.isEmpty, let host = await probe(candidates, timeout: 0.7) {
return host
}
throw QFTError.hostNotFound
}
/// 并发 ping 全部候选,返回第一个应答的。
func probe(_ endpoints: [String], timeout: TimeInterval) async -> QFTHost? {
guard !endpoints.isEmpty else { return nil }
return await withTaskGroup(of: QFTHost?.self) { group in
for endpoint in endpoints {
group.addTask { await Self.ping(endpoint, session: pairing.session,
deviceName: deviceName, timeout: timeout) }
}
for await result in group {
if let result {
group.cancelAll()
return result
}
}
return nil
}
}
static func ping(_ baseURL: String, session: String,
deviceName: String, timeout: TimeInterval) async -> QFTHost? {
guard let url = URL(string: baseURL + "/qft/ping") else { return nil }
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.timeoutInterval = timeout
request.setValue(session, forHTTPHeaderField: "X-QFT-Token")
request.setValue(Base64URL.encode(deviceName), forHTTPHeaderField: "X-QFT-Device")
let configuration = URLSessionConfiguration.ephemeral
configuration.timeoutIntervalForRequest = timeout
configuration.waitsForConnectivity = false
let urlSession = URLSession(configuration: configuration)
defer { urlSession.finishTasksAndInvalidate() }
guard let (data, response) = try? await urlSession.data(for: request),
let http = response as? HTTPURLResponse, http.statusCode == 200,
let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
(object["ok"] as? Bool) == true else { return nil }
return QFTHost(baseURL: baseURL)
}
/// 向广播地址发 `QFTDISC2:<session>`,等待 `QFTHERE2:<session>:<port>`。
/// 返回可用的 base URL;iOS 首次调用会触发「本地网络」权限弹窗。
func udpDiscover(timeout: TimeInterval) async -> String? {
let expected = "QFTHERE2:\(pairing.session):"
let request = Data("QFTDISC2:\(pairing.session)".utf8)
return await withCheckedContinuation { continuation in
DispatchQueue.global(qos: .userInitiated).async {
let result = Self.udpRoundTrip(request: request,
expectedPrefix: expected,
timeout: timeout)
continuation.resume(returning: result)
}
}
}
private static func udpRoundTrip(request: Data, expectedPrefix: String,
timeout: TimeInterval) -> String? {
let fd = socket(AF_INET, SOCK_DGRAM, 0)
guard fd >= 0 else { return nil }
defer { close(fd) }
var enable: Int32 = 1
setsockopt(fd, SOL_SOCKET, SO_BROADCAST, &enable, socklen_t(MemoryLayout<Int32>.size))
var tv = timeval(tv_sec: Int(timeout), tv_usec: Int32((timeout - floor(timeout)) * 1_000_000))
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, socklen_t(MemoryLayout<timeval>.size))
var targets = ["255.255.255.255"]
if let broadcast = LocalNetwork.subnetBroadcastAddress() { targets.insert(broadcast, at: 0) }
for target in targets {
var address = sockaddr_in()
address.sin_family = sa_family_t(AF_INET)
address.sin_port = discoveryPort.bigEndian
address.sin_addr.s_addr = inet_addr(target)
let sent = request.withUnsafeBytes { buffer -> Int in
withUnsafePointer(to: &address) { pointer in
pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockPointer in
sendto(fd, buffer.baseAddress, buffer.count, 0,
sockPointer, socklen_t(MemoryLayout<sockaddr_in>.size))
}
}
}
if sent < 0 { continue }
}
let deadline = Date().addingTimeInterval(timeout)
var buffer = [UInt8](repeating: 0, count: 512)
while Date() < deadline {
var from = sockaddr_in()
var fromLength = socklen_t(MemoryLayout<sockaddr_in>.size)
let received = withUnsafeMutablePointer(to: &from) { pointer -> Int in
pointer.withMemoryRebound(to: sockaddr.self, capacity: 1) { sockPointer in
recvfrom(fd, &buffer, buffer.count, 0, sockPointer, &fromLength)
}
}
if received <= 0 { break }
guard let text = String(bytes: buffer[0..<received], encoding: .utf8),
text.hasPrefix(expectedPrefix),
let port = Int(text.dropFirst(expectedPrefix.count)),
(1...65535).contains(port) else { continue }
var raw = from.sin_addr
var host = [CChar](repeating: 0, count: Int(INET_ADDRSTRLEN))
guard inet_ntop(AF_INET, &raw, &host, socklen_t(INET_ADDRSTRLEN)) != nil else { continue }
let ip = String(cString: host)
// 应答来源同样必须是私有地址:广播回包也属于不可信输入
guard PairingProtocol.isPrivateIPv4(ip) else { continue }
return "http://\(ip):\(port)"
}
return nil
}
}
/// 本机 IPv4 与子网推导(getifaddrs)。
enum LocalNetwork {
struct Interface {
let name: String
let address: String
let netmask: String
}
static func activeInterfaces() -> [Interface] {
var head: UnsafeMutablePointer<ifaddrs>?
guard getifaddrs(&head) == 0, let first = head else { return [] }
defer { freeifaddrs(head) }
var result: [Interface] = []
var cursor: UnsafeMutablePointer<ifaddrs>? = first
while let entry = cursor {
defer { cursor = entry.pointee.ifa_next }
guard let rawAddress = entry.pointee.ifa_addr,
rawAddress.pointee.sa_family == UInt8(AF_INET) else { continue }
let flags = Int32(entry.pointee.ifa_flags)
guard flags & IFF_UP != 0, flags & IFF_LOOPBACK == 0 else { continue }
guard let address = describe(rawAddress),
let maskPointer = entry.pointee.ifa_netmask,
let netmask = describe(maskPointer) else { continue }
guard PairingProtocol.isPrivateIPv4(address) else { continue }
result.append(Interface(name: String(cString: entry.pointee.ifa_name),
address: address, netmask: netmask))
}
// en0 是 iPhone 的 Wi-Fi 接口,优先于蜂窝/热点接口
return result.sorted { lhs, _ in lhs.name == "en0" }
}
private static func describe(_ address: UnsafeMutablePointer<sockaddr>) -> String? {
var host = [CChar](repeating: 0, count: Int(NI_MAXHOST))
let length = socklen_t(MemoryLayout<sockaddr_in>.size)
guard getnameinfo(address, length, &host, socklen_t(host.count),
nil, 0, NI_NUMERICHOST) == 0 else { return nil }
return String(cString: host)
}
static func subnetBroadcastAddress() -> String? {
guard let iface = activeInterfaces().first,
let ip = ipv4(iface.address), let mask = ipv4(iface.netmask) else { return nil }
return format(ip | ~mask)
}
/// 当前子网内的候选地址。仅在 /24 或更小的子网上启用,
/// 避免在大网段里做无意义的上千次探测。
static func subnetCandidates(port: Int, limit: Int) -> [String] {
guard let iface = activeInterfaces().first,
let ip = ipv4(iface.address), let mask = ipv4(iface.netmask) else { return [] }
let hostBits = (~mask).nonzeroBitCount
guard hostBits > 0, hostBits <= 8 else { return [] }
let network = ip & mask
let broadcast = ip | ~mask
var result: [String] = []
var candidate = network &+ 1
while candidate < broadcast && result.count < limit {
if candidate != ip { result.append("http://\(format(candidate)):\(port)") }
candidate &+= 1
}
// 网关通常是 .1,多半就是那台开热点/路由的机器,放最前面
if let gatewayIndex = result.firstIndex(of: "http://\(format(network &+ 1)):\(port)") {
result.swapAt(0, gatewayIndex)
}
return result
}
static func ipv4(_ text: String) -> UInt32? {
let parts = text.split(separator: ".", omittingEmptySubsequences: false)
guard parts.count == 4 else { return nil }
var value: UInt32 = 0
for part in parts {
guard let octet = UInt32(part), octet <= 255 else { return nil }
value = (value << 8) | octet
}
return value
}
static func format(_ value: UInt32) -> String {
"\((value >> 24) & 0xff).\((value >> 16) & 0xff).\((value >> 8) & 0xff).\(value & 0xff)"
}
}