Files
zhy200308 eae24000e9 优化IOS
2026-08-19 09:31:21 +08:00

280 lines
11 KiB
Python
Raw Permalink 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.
#!/usr/bin/env python3
"""按 desktop/src/{sender,receiver}.rs 的线上语义实现的假电脑端。
存在的意义:Swift 客户端的线格式必须和 Rust 端逐字节一致,
而 Rust 端在这台机器上编译不了。这个 mock 把两端的契约固定下来,
任何一边改了 header 名、路径或 JSON 字段,集成测试都会红。
用法:
python3 MockPCServer.py --token <session> --serve <文件> --save-dir <目录> --port 0
启动后在 stdout 打印一行 `READY <port>`,供测试脚本读取。
"""
import argparse
import base64
import hashlib
import json
import os
import socket
import sys
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
STATE = {}
def b64url_decode(text):
padding = "=" * (-len(text) % 4)
return base64.urlsafe_b64decode(text + padding)
def b64url_encode(data):
return base64.urlsafe_b64encode(data).decode("ascii").rstrip("=")
class Handler(BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
def log_message(self, *_args):
pass
# -------------------------------------------------- 工具
def _json(self, code, payload):
body = json.dumps(payload).encode("utf-8")
self.send_response(code)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.send_header("Connection", "close")
self.end_headers()
self.wfile.write(body)
def _authorized(self):
if self.headers.get("X-QFT-Token") != STATE["token"]:
self.send_response(403)
self.send_header("Content-Length", "0")
self.send_header("Connection", "close")
self.end_headers()
return False
# 设备名必须是 base64url,解不出来说明客户端编码错了
device = self.headers.get("X-QFT-Device")
if device is not None:
b64url_decode(device).decode("utf-8")
return True
# -------------------------------------------------- GET
def do_GET(self):
if not self._authorized():
return
if self.path == "/qft/ping":
return self._json(200, {"ok": True, "protocol": 2, "parallel": True})
if self.path == "/qft/download":
return self._download()
return self._json(404, {"ok": False})
def _download(self):
path = STATE["serve"]
size = os.path.getsize(path)
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"
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 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 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")))
# 并行下载会在一条连接上连续发多个 Range 请求,
# sender.rs 对这种请求保持 keep-alive
self.send_header("Connection", "keep-alive")
self.end_headers()
with open(path, "rb") as fh:
fh.seek(offset)
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":
return self._upload_init()
if self.path.startswith("/qft/upload/chunk/"):
return self._upload_chunk()
if self.path.startswith("/qft/upload/finish/"):
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"])
chunk_size = int(self.headers.get("X-QFT-Chunk-Size", 8 * 1024 * 1024))
chunk_size = max(1024 * 1024, min(16 * 1024 * 1024, chunk_size))
total = 0 if size == 0 else (size + chunk_size - 1) // chunk_size
upload_id = base64.urlsafe_b64encode(os.urandom(9)).decode("ascii").rstrip("=")
part = os.path.join(STATE["save_dir"], "%s.%s.qftpart" % (name, upload_id))
with open(part, "wb") as fh:
fh.truncate(size)
STATE["uploads"][upload_id] = {
"name": name, "size": size, "chunk_size": chunk_size,
"total": total, "part": part, "received": [False] * total,
"lock": threading.Lock(),
}
return self._json(200, {"ok": True, "upload_id": upload_id,
"chunk_size": chunk_size, "total_chunks": total})
def _upload_chunk(self):
suffix = self.path[len("/qft/upload/chunk/"):]
upload_id, _, index_text = suffix.partition("/")
index = int(index_text)
session = STATE["uploads"].get(upload_id)
if session is None:
return self._json(500, {"ok": False, "error": "unknown upload"})
length = int(self.headers["Content-Length"])
offset = index * session["chunk_size"]
expected = min(session["chunk_size"], session["size"] - offset)
assert length == expected, "chunk 长度不匹配:%d != %d" % (length, expected)
body = b""
while len(body) < length:
block = self.rfile.read(length - len(body))
if not block:
break
body += block
assert len(body) == length, "chunk 体不完整"
with session["lock"]:
if session["received"][index]:
return self._json(200, {"ok": True, "duplicate": True})
with open(session["part"], "r+b") as fh:
fh.seek(offset)
fh.write(body)
session["received"][index] = True
return self._json(200, {"ok": True})
def _upload_finish(self):
upload_id = self.path[len("/qft/upload/finish/"):]
session = STATE["uploads"].get(upload_id)
if session is None:
return self._json(500, {"ok": False, "error": "unknown upload"})
missing = session["received"].count(False)
if missing:
return self._json(409, {"ok": False, "missing": missing})
digest = hashlib.sha256()
with open(session["part"], "rb") as fh:
while True:
block = fh.read(1024 * 1024)
if not block:
break
digest.update(block)
final = os.path.join(STATE["save_dir"], session["name"])
os.replace(session["part"], final)
del STATE["uploads"][upload_id]
return self._json(200, {"ok": True, "sha256": digest.hexdigest(), "size": session["size"]})
def udp_responder(token, http_port, stop):
"""receiver.rs 的 UDP 线程:既回 QFTDISC2,也回不带令牌的 QFTBROWSE3。"""
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
sock.bind(("0.0.0.0", 39392))
except OSError:
return
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)
except socket.timeout:
continue
except OSError:
break
if data == b"QFTBROWSE3":
sock.sendto(announce, peer)
elif data == expected:
sock.sendto(reply, peer)
sock.close()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--token", required=True)
parser.add_argument("--serve", required=True, help="供 /qft/download 下发的文件")
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={},
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)
port = server.server_address[1]
stop = threading.Event()
if args.udp:
threading.Thread(target=udp_responder, args=(args.token, port, stop), daemon=True).start()
print("READY %d" % port, flush=True)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
finally:
stop.set()
if __name__ == "__main__":
main()