feat(desktop): 跨平台桌面端 + 电脑↔电脑互传(v0.5.0-m1)
对应 V05_EXECUTION_PLAN 的 P1。核心改动是把「PC 只能当服务端」 这个写死的角色拆开——此前 TcpStream::connect 只出现在测试里, 桌面端根本无法主动连接另一台桌面端,PC↔PC 因此完全不可用。 跨平台 - windows/ → desktop/,crate 更名 qft-desktop - 新增 platform.rs 收敛全部平台差异:配置目录(LOCALAPPDATA / Application Support / XDG)、下载目录(含 Linux 本地化的 ~/下载)、 设备名、Direct AP 能力。约定:其余模块不得再出现 #[cfg(target_os)] - direct_ap.rs 的 Context 导入按平台条件化,非 Windows 上不再告警 - macOS 上已实测编译并链接出可执行文件(65 MB Mach-O arm64), 这是本仓库首次在非 Windows 平台构建成功 电脑 ↔ 电脑 - 新增 client.rs:桌面端发起侧。手写 HTTP,不引入客户端依赖—— 服务端本来就是手写的,两边同一套解析更容易与 Android/iOS 对齐。 含并发分块上传(自适应 4/8/16 MiB、最多 8 worker)与 Range 断点续传 - 新增 discovery.rs:UDP 广播 QFTBROWSE3 浏览局域网节点。 既有的 QFTDISC2 是「已知令牌找机器」,用于扫码之后; PC 没有摄像头,必须先能列出附近有谁 - receiver.rs 新增 POST /qft/pair:用 6 位配对码换会话令牌。 这是唯一不校验令牌的端点。6 位仅约 20 bit 熵,配严格失败计数兜底—— 错 5 次即作废,需重启接收;比较用定长实现,不做短路返回 - 新增「电脑 ↔ 电脑」界面:接收方显示配对码与本机地址; 发送方搜索/手动输入地址 → 输码连接 → 多选文件 → 带进度发送 验证(macOS,Rust 1.97.1) - cargo check 0 错误,cargo test 17/17 通过 - 新增端到端用例:真实起接收服务 → 配对(含错误码必须被拒)→ 9 MB 跨多分块并发上传 → 校验落盘内容逐字节一致且 SHA-256 与 接收端返回值相同。这就是 PC↔PC 的完整链路 - 11 项 Python 自检全部通过 顺带修复 - single_channel_guard_selftest 长期为红:它断言 DEFAULT_CHUNK_SIZE = 450,而代码早已改为 320。改名前即存在, 已用 git stash 验证与本次无关。改为范围检查(128~4096)并在 PASS 信息里打印实际值,既挡住"退回多通道小块"又不会因调参误报 已知限制 - UDP 广播只覆盖同一广播域。跨网段或 AP 隔离的 Wi-Fi 上搜索不到, 需手动输入对方 IP(界面已说明)。mDNS 留待后续 - 本阶段仍走 v2 明文 HTTP,加密随 QFT-Stream v3 一起做(见 P2)
This commit is contained in:
@@ -0,0 +1,754 @@
|
||||
use anyhow::{bail, Context, Result};
|
||||
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
|
||||
use rand::RngCore;
|
||||
use serde_json::json;
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
fs::{self, File, OpenOptions},
|
||||
io::{BufRead, BufReader, Read, Seek, SeekFrom, Write},
|
||||
net::{TcpListener, TcpStream, UdpSocket},
|
||||
path::{Path, PathBuf},
|
||||
sync::{
|
||||
atomic::{AtomicBool, AtomicU32, Ordering},
|
||||
mpsc::Sender,
|
||||
Arc, Mutex,
|
||||
},
|
||||
thread::{self, JoinHandle},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
pub const PREFERRED_PORT: u16 = 39393;
|
||||
pub const DISCOVERY_PORT: u16 = 39392;
|
||||
pub const PARALLEL_CHUNK_SIZE: u64 = 8 * 1024 * 1024;
|
||||
const MIN_PARALLEL_CHUNK_SIZE: u64 = 64 * 1024;
|
||||
const MAX_PARALLEL_CHUNK_SIZE: u64 = 16 * 1024 * 1024;
|
||||
const IO_BUFFER: usize = 1024 * 1024;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum ReceiverEvent {
|
||||
ClientConnected { device: String },
|
||||
UploadStarted { device: String, file_name: String, size: u64 },
|
||||
UploadProgress { device: String, file_name: String, received: u64, size: u64 },
|
||||
UploadCompleted { device: String, file_name: String, saved_path: PathBuf, sha256: String },
|
||||
Error(String),
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
struct UploadSession {
|
||||
upload_key: Option<String>,
|
||||
device: String,
|
||||
file_name: String,
|
||||
size: u64,
|
||||
chunk_size: u64,
|
||||
total_chunks: u32,
|
||||
part_path: PathBuf,
|
||||
final_path: PathBuf,
|
||||
received: Vec<bool>,
|
||||
received_bytes: u64,
|
||||
}
|
||||
|
||||
type SessionMap = Arc<Mutex<HashMap<String, Arc<Mutex<UploadSession>>>>>;
|
||||
type CompletedMap = Arc<Mutex<HashMap<String, CompletedUpload>>>;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct CompletedUpload {
|
||||
sha256: String,
|
||||
size: u64,
|
||||
}
|
||||
|
||||
pub struct ReceiverServer {
|
||||
pub port: u16,
|
||||
/// PC↔PC 用的 6 位配对码:对端没有摄像头,扫不了二维码,
|
||||
/// 只能靠用户口头/目视传递这 6 位数字来换取会话令牌。
|
||||
pub pair_code: String,
|
||||
stop: Arc<AtomicBool>,
|
||||
tcp_thread: Option<JoinHandle<()>>,
|
||||
udp_thread: Option<JoinHandle<()>>,
|
||||
}
|
||||
|
||||
impl ReceiverServer {
|
||||
pub fn start(save_dir: PathBuf, session_token: String, events: Sender<ReceiverEvent>) -> Result<Self> {
|
||||
fs::create_dir_all(&save_dir).context("创建接收目录失败")?;
|
||||
let listener = TcpListener::bind(("0.0.0.0", PREFERRED_PORT))
|
||||
.or_else(|_| TcpListener::bind(("0.0.0.0", 0)))
|
||||
.context("启动本地接收端口失败")?;
|
||||
let port = listener.local_addr()?.port();
|
||||
listener.set_nonblocking(true)?;
|
||||
|
||||
let stop = Arc::new(AtomicBool::new(false));
|
||||
let sessions: SessionMap = Arc::new(Mutex::new(HashMap::new()));
|
||||
let completed: CompletedMap = Arc::new(Mutex::new(HashMap::new()));
|
||||
// 6 位数字只有约 20 bit 熵,单靠它不足以抵抗在线爆破,
|
||||
// 因此配一个严格的失败计数:错 5 次即作废,必须重启接收重新生成。
|
||||
let pair_code = crate::pairing::new_pair_code();
|
||||
let pair_failures = Arc::new(AtomicU32::new(0));
|
||||
|
||||
let stop_tcp = stop.clone();
|
||||
let sessions_tcp = sessions.clone();
|
||||
let completed_tcp = completed.clone();
|
||||
let token_tcp = session_token.clone();
|
||||
let dir_tcp = save_dir.clone();
|
||||
let events_tcp = events.clone();
|
||||
let code_tcp = pair_code.clone();
|
||||
let failures_tcp = pair_failures.clone();
|
||||
let tcp_thread = thread::spawn(move || {
|
||||
while !stop_tcp.load(Ordering::Relaxed) {
|
||||
match listener.accept() {
|
||||
Ok((mut stream, _)) => {
|
||||
let dir = dir_tcp.clone();
|
||||
let token = token_tcp.clone();
|
||||
let tx = events_tcp.clone();
|
||||
let sessions = sessions_tcp.clone();
|
||||
let completed = completed_tcp.clone();
|
||||
let code = code_tcp.clone();
|
||||
let failures = failures_tcp.clone();
|
||||
thread::spawn(move || {
|
||||
if let Err(e) = handle_client(&mut stream, &dir, &token, &code, &failures, &tx, &sessions, &completed) {
|
||||
// Never turn a parse/write race into an opaque Android
|
||||
// `unexpected end of stream`: make a best effort to
|
||||
// return an HTTP status before closing the socket.
|
||||
let message = format!("接收失败:{e:#}");
|
||||
let _ = write_response(&mut stream, 500, "text/plain", message.as_bytes());
|
||||
let _ = tx.send(ReceiverEvent::Error(message));
|
||||
}
|
||||
});
|
||||
}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
|
||||
thread::sleep(Duration::from_millis(12));
|
||||
}
|
||||
Err(e) => {
|
||||
let _ = events_tcp.send(ReceiverEvent::Error(format!("监听端口失败:{e}")));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let stop_udp = stop.clone();
|
||||
let token_udp = session_token;
|
||||
let udp_thread = thread::spawn(move || {
|
||||
let socket = match UdpSocket::bind(("0.0.0.0", DISCOVERY_PORT)) {
|
||||
Ok(v) => v,
|
||||
Err(e) => {
|
||||
let _ = events.send(ReceiverEvent::Error(format!(
|
||||
"快速发现端口 {DISCOVERY_PORT} 不可用:{e}。仍可使用网关/IP 探测。"
|
||||
)));
|
||||
return;
|
||||
}
|
||||
};
|
||||
let _ = socket.set_read_timeout(Some(Duration::from_millis(250)));
|
||||
let expected = format!("QFTDISC2:{token_udp}");
|
||||
let response = format!("QFTHERE2:{token_udp}:{port}");
|
||||
// PC↔PC 的对端不知道令牌,需要先能把本机列出来
|
||||
let announce = crate::discovery::browse_reply(&crate::discovery::NodeAnnounce {
|
||||
n: crate::platform::device_name(),
|
||||
p: crate::platform::platform_tag().to_owned(),
|
||||
t: port,
|
||||
r: true,
|
||||
});
|
||||
let mut buf = [0u8; 512];
|
||||
while !stop_udp.load(Ordering::Relaxed) {
|
||||
match socket.recv_from(&mut buf) {
|
||||
Ok((n, peer)) => {
|
||||
match std::str::from_utf8(&buf[..n]).ok() {
|
||||
Some(text) if text == expected => {
|
||||
let _ = socket.send_to(response.as_bytes(), peer);
|
||||
}
|
||||
Some(text) if text == crate::discovery::BROWSE_QUERY => {
|
||||
let _ = socket.send_to(&announce, peer);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => {}
|
||||
Err(_) => break,
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
Ok(Self {
|
||||
port,
|
||||
stop,
|
||||
tcp_thread: Some(tcp_thread),
|
||||
pair_code,
|
||||
udp_thread: Some(udp_thread),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for ReceiverServer {
|
||||
fn drop(&mut self) {
|
||||
self.stop.store(true, Ordering::Relaxed);
|
||||
if let Some(handle) = self.tcp_thread.take() {
|
||||
let _ = handle.join();
|
||||
}
|
||||
if let Some(handle) = self.udp_thread.take() {
|
||||
let _ = handle.join();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `POST /qft/pair`,请求头 `X-QFT-Code: 123456`。
|
||||
///
|
||||
/// 这是唯一不校验令牌的端点——它的作用就是用 6 位码换取令牌。
|
||||
/// 6 位只有约 20 bit 熵,必须靠失败计数兜底:错 5 次即作废整个码,
|
||||
/// 用户需要在电脑上重新启动接收才能拿到新码。
|
||||
fn handle_pair(
|
||||
stream: &mut TcpStream,
|
||||
headers: &HashMap<String, String>,
|
||||
token: &str,
|
||||
pair_code: &str,
|
||||
pair_failures: &AtomicU32,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
) -> Result<()> {
|
||||
const MAX_FAILURES: u32 = 5;
|
||||
if pair_failures.load(Ordering::Relaxed) >= MAX_FAILURES {
|
||||
let body = json!({
|
||||
"ok": false,
|
||||
"error": "配对码已因多次输入错误作废,请在电脑上重新启动接收"
|
||||
}).to_string();
|
||||
return write_response(stream, 429, "application/json", body.as_bytes());
|
||||
}
|
||||
|
||||
let supplied = headers.get("x-qft-code").map(String::as_str).unwrap_or("");
|
||||
if !constant_time_eq(supplied.as_bytes(), pair_code.as_bytes()) {
|
||||
let count = pair_failures.fetch_add(1, Ordering::Relaxed) + 1;
|
||||
let _ = events.send(ReceiverEvent::Error(format!(
|
||||
"配对码错误({count}/{MAX_FAILURES})"
|
||||
)));
|
||||
let body = json!({"ok": false, "remaining": MAX_FAILURES.saturating_sub(count)}).to_string();
|
||||
return write_response(stream, 403, "application/json", body.as_bytes());
|
||||
}
|
||||
|
||||
pair_failures.store(0, Ordering::Relaxed);
|
||||
let device = decode_header(headers.get("x-qft-device")).unwrap_or_else(|| "电脑".to_owned());
|
||||
let _ = events.send(ReceiverEvent::ClientConnected { device });
|
||||
let body = json!({"ok": true, "token": token}).to_string();
|
||||
write_response(stream, 200, "application/json", body.as_bytes())
|
||||
}
|
||||
|
||||
/// 定长比较,不因首个不同字节的位置而提前返回。
|
||||
/// 局域网上计时攻击并不现实,但这段代码很便宜,没有理由写成短路比较。
|
||||
fn constant_time_eq(a: &[u8], b: &[u8]) -> bool {
|
||||
if a.len() != b.len() {
|
||||
return false;
|
||||
}
|
||||
let mut diff = 0u8;
|
||||
for (x, y) in a.iter().zip(b.iter()) {
|
||||
diff |= x ^ y;
|
||||
}
|
||||
diff == 0
|
||||
}
|
||||
|
||||
fn handle_client(
|
||||
stream: &mut TcpStream,
|
||||
save_dir: &Path,
|
||||
token: &str,
|
||||
pair_code: &str,
|
||||
pair_failures: &AtomicU32,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
sessions: &SessionMap,
|
||||
completed: &CompletedMap,
|
||||
) -> Result<()> {
|
||||
// The listener is non-blocking so the UI can poll for shutdown. On
|
||||
// Windows an accepted socket may retain that mode, which made a body read
|
||||
// race the next Wi-Fi Direct packet and fail with WSAEWOULDBLOCK (10035).
|
||||
// File requests must instead wait under the explicit socket timeouts.
|
||||
stream.set_nonblocking(false)?;
|
||||
stream.set_nodelay(true).ok();
|
||||
stream.set_read_timeout(Some(Duration::from_secs(120)))?;
|
||||
stream.set_write_timeout(Some(Duration::from_secs(120)))?;
|
||||
let cloned = stream.try_clone()?;
|
||||
let mut reader = BufReader::with_capacity(64 * 1024, cloned);
|
||||
|
||||
let mut request_line = String::new();
|
||||
reader.read_line(&mut request_line)?;
|
||||
if request_line.len() > 8192 { bail!("请求行过长") }
|
||||
let mut headers = HashMap::<String, String>::new();
|
||||
loop {
|
||||
let mut line = String::new();
|
||||
let n = reader.read_line(&mut line)?;
|
||||
if n == 0 { bail!("连接提前关闭") }
|
||||
if line == "\r\n" || line == "\n" { break }
|
||||
if line.len() > 16 * 1024 { bail!("请求头过长") }
|
||||
if let Some((k, v)) = line.split_once(':') {
|
||||
headers.insert(k.trim().to_ascii_lowercase(), v.trim().to_owned());
|
||||
}
|
||||
}
|
||||
|
||||
let mut parts = request_line.split_whitespace();
|
||||
let method = parts.next().unwrap_or("");
|
||||
let path = parts.next().unwrap_or("");
|
||||
|
||||
// 配对是唯一不需要令牌的端点——它的作用正是换取令牌。
|
||||
if method == "POST" && path == "/qft/pair" {
|
||||
return handle_pair(stream, &headers, token, pair_code, pair_failures, events);
|
||||
}
|
||||
|
||||
let supplied = headers.get("x-qft-token").map(String::as_str).unwrap_or("");
|
||||
if supplied != token {
|
||||
return write_response(stream, 403, "text/plain", b"invalid session");
|
||||
}
|
||||
|
||||
let device = decode_header(headers.get("x-qft-device")).unwrap_or_else(|| "Android".to_owned());
|
||||
let _ = events.send(ReceiverEvent::ClientConnected { device: device.clone() });
|
||||
|
||||
if method == "GET" && path == "/qft/ping" {
|
||||
let body = json!({"ok": true, "protocol": 2, "parallel": true}).to_string();
|
||||
return write_response(stream, 200, "application/json", body.as_bytes());
|
||||
}
|
||||
|
||||
if method == "POST" && path == "/qft/upload/init" {
|
||||
return init_parallel_upload(stream, save_dir, &headers, &device, events, sessions);
|
||||
}
|
||||
|
||||
if method == "POST" && path.starts_with("/qft/upload/chunk/") {
|
||||
return receive_parallel_chunk(stream, &mut reader, path, &headers, events, sessions);
|
||||
}
|
||||
|
||||
if method == "POST" && path.starts_with("/qft/upload/finish/") {
|
||||
return finish_parallel_upload(stream, path, events, sessions, completed);
|
||||
}
|
||||
|
||||
// Compatibility path for old clients and content providers that cannot seek.
|
||||
if method == "POST" && path == "/qft/upload" {
|
||||
return receive_legacy_stream(stream, &mut reader, save_dir, &headers, &device, events);
|
||||
}
|
||||
|
||||
write_response(stream, 404, "text/plain", b"not found")
|
||||
}
|
||||
|
||||
fn init_parallel_upload(
|
||||
stream: &mut TcpStream,
|
||||
save_dir: &Path,
|
||||
headers: &HashMap<String, String>,
|
||||
device: &str,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
sessions: &SessionMap,
|
||||
) -> Result<()> {
|
||||
let file_name = decode_header(headers.get("x-qft-filename"))
|
||||
.map(sanitize_file_name)
|
||||
.filter(|s| !s.is_empty())
|
||||
.unwrap_or_else(|| "qft-upload.bin".to_owned());
|
||||
let size: u64 = headers.get("x-qft-size")
|
||||
.context("缺少 X-QFT-Size")?
|
||||
.parse().context("X-QFT-Size 无效")?;
|
||||
let chunk_size = headers.get("x-qft-chunk-size")
|
||||
.and_then(|v| v.parse::<u64>().ok())
|
||||
.map(|v| v.clamp(MIN_PARALLEL_CHUNK_SIZE, MAX_PARALLEL_CHUNK_SIZE))
|
||||
.unwrap_or(PARALLEL_CHUNK_SIZE);
|
||||
let total_chunks_u64 = if size == 0 { 0 } else { (size + chunk_size - 1) / chunk_size };
|
||||
if total_chunks_u64 > u32::MAX as u64 { bail!("文件分块数过大") }
|
||||
let total_chunks = total_chunks_u64 as u32;
|
||||
let upload_key = headers.get("x-qft-upload-key")
|
||||
.map(|value| value.trim().to_owned())
|
||||
.filter(|value| !value.is_empty() && value.len() <= 128);
|
||||
|
||||
let mut map = sessions.lock().map_err(|_| anyhow::anyhow!("上传会话锁损坏"))?;
|
||||
// init is idempotent: if the response packet was lost, the Android client
|
||||
// may repeat init. Return the existing session so already received chunks
|
||||
// and the preallocated file are preserved instead of leaking a second part.
|
||||
for (existing_id, existing) in map.iter() {
|
||||
if let Ok(session) = existing.lock() {
|
||||
if upload_key.is_some() && session.upload_key == upload_key {
|
||||
let missing: Vec<usize> = session.received.iter().enumerate()
|
||||
.filter_map(|(index, received)| if *received { None } else { Some(index) })
|
||||
.collect();
|
||||
let body = json!({
|
||||
"ok": true,
|
||||
"upload_id": existing_id,
|
||||
"chunk_size": session.chunk_size,
|
||||
"total_chunks": session.total_chunks,
|
||||
"resumed": true,
|
||||
"missing": missing,
|
||||
}).to_string();
|
||||
return write_response(stream, 200, "application/json", body.as_bytes());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let upload_id = random_id();
|
||||
let final_path = unique_path_reserved(save_dir, &file_name, map.values());
|
||||
let final_name = final_path.file_name().and_then(|v| v.to_str()).unwrap_or("qft-upload.bin");
|
||||
let part_path = final_path.with_file_name(format!("{final_name}.{upload_id}.qftpart"));
|
||||
let part = File::create(&part_path)
|
||||
.with_context(|| format!("创建临时文件 {}", part_path.display()))?;
|
||||
part.set_len(size)?;
|
||||
drop(part);
|
||||
|
||||
let session = UploadSession {
|
||||
upload_key,
|
||||
device: device.to_owned(),
|
||||
file_name: file_name.clone(),
|
||||
size,
|
||||
chunk_size,
|
||||
total_chunks,
|
||||
part_path,
|
||||
final_path,
|
||||
received: vec![false; total_chunks as usize],
|
||||
received_bytes: 0,
|
||||
};
|
||||
map.insert(upload_id.clone(), Arc::new(Mutex::new(session)));
|
||||
drop(map);
|
||||
|
||||
let _ = events.send(ReceiverEvent::UploadStarted {
|
||||
device: device.to_owned(),
|
||||
file_name,
|
||||
size,
|
||||
});
|
||||
let body = json!({
|
||||
"ok": true,
|
||||
"upload_id": upload_id,
|
||||
"chunk_size": chunk_size,
|
||||
"total_chunks": total_chunks,
|
||||
}).to_string();
|
||||
write_response(stream, 200, "application/json", body.as_bytes())
|
||||
}
|
||||
|
||||
fn receive_parallel_chunk(
|
||||
stream: &mut TcpStream,
|
||||
reader: &mut BufReader<TcpStream>,
|
||||
path: &str,
|
||||
headers: &HashMap<String, String>,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
sessions: &SessionMap,
|
||||
) -> Result<()> {
|
||||
let suffix = path.trim_start_matches("/qft/upload/chunk/");
|
||||
let (upload_id, index_text) = suffix.split_once('/').context("chunk 路径无效")?;
|
||||
let index: u32 = index_text.parse().context("chunk index 无效")?;
|
||||
let content_len: u64 = headers.get("content-length")
|
||||
.context("缺少 Content-Length")?
|
||||
.parse().context("Content-Length 无效")?;
|
||||
|
||||
let session_arc = {
|
||||
let map = sessions.lock().map_err(|_| anyhow::anyhow!("上传会话锁损坏"))?;
|
||||
map.get(upload_id).cloned().context("上传会话不存在或已完成")?
|
||||
};
|
||||
|
||||
let (part_path, offset, expected_len, device, file_name, size, already) = {
|
||||
let session = session_arc.lock().map_err(|_| anyhow::anyhow!("上传会话损坏"))?;
|
||||
if index >= session.total_chunks { bail!("chunk index 越界") }
|
||||
let offset = index as u64 * session.chunk_size;
|
||||
let expected = (session.size - offset).min(session.chunk_size);
|
||||
(
|
||||
session.part_path.clone(),
|
||||
offset,
|
||||
expected,
|
||||
session.device.clone(),
|
||||
session.file_name.clone(),
|
||||
session.size,
|
||||
session.received[index as usize],
|
||||
)
|
||||
};
|
||||
if content_len != expected_len { bail!("chunk 长度不匹配:{content_len} != {expected_len}") }
|
||||
|
||||
if already {
|
||||
drain_exact(reader, content_len)?;
|
||||
return write_response(stream, 200, "application/json", b"{\"ok\":true,\"duplicate\":true}");
|
||||
}
|
||||
|
||||
let mut out = OpenOptions::new().write(true).open(&part_path)?;
|
||||
out.seek(SeekFrom::Start(offset))?;
|
||||
copy_exact(reader, &mut out, content_len)?;
|
||||
out.sync_data()?;
|
||||
|
||||
let received = {
|
||||
let mut session = session_arc.lock().map_err(|_| anyhow::anyhow!("上传会话损坏"))?;
|
||||
if !session.received[index as usize] {
|
||||
session.received[index as usize] = true;
|
||||
session.received_bytes = session.received_bytes.saturating_add(content_len);
|
||||
}
|
||||
session.received_bytes
|
||||
};
|
||||
let _ = events.send(ReceiverEvent::UploadProgress { device, file_name, received, size });
|
||||
write_response(stream, 200, "application/json", b"{\"ok\":true}")
|
||||
}
|
||||
|
||||
fn finish_parallel_upload(
|
||||
stream: &mut TcpStream,
|
||||
path: &str,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
sessions: &SessionMap,
|
||||
completed: &CompletedMap,
|
||||
) -> Result<()> {
|
||||
let upload_id = path.trim_start_matches("/qft/upload/finish/");
|
||||
let session_arc = {
|
||||
let map = sessions.lock().map_err(|_| anyhow::anyhow!("上传会话锁损坏"))?;
|
||||
map.get(upload_id).cloned()
|
||||
};
|
||||
if session_arc.is_none() {
|
||||
// The client may lose the TCP response after the file was safely
|
||||
// renamed. Finish is idempotent so its retry reports that committed
|
||||
// result instead of surfacing an opaque connection/404 failure.
|
||||
if let Some(done) = completed.lock().ok().and_then(|v| v.get(upload_id).cloned()) {
|
||||
let body = json!({"ok": true, "sha256": done.sha256, "size": done.size, "duplicate": true}).to_string();
|
||||
return write_response(stream, 200, "application/json", body.as_bytes());
|
||||
}
|
||||
bail!("上传会话不存在或已完成")
|
||||
}
|
||||
let session_arc = session_arc.expect("checked above");
|
||||
|
||||
let (device, file_name, size, part_path, final_path) = {
|
||||
let session = session_arc.lock().map_err(|_| anyhow::anyhow!("上传会话损坏"))?;
|
||||
if session.received.iter().any(|v| !*v) {
|
||||
let missing = session.received.iter().filter(|v| !**v).count();
|
||||
let body = json!({"ok": false, "missing": missing}).to_string();
|
||||
return write_response(stream, 409, "application/json", body.as_bytes());
|
||||
}
|
||||
(
|
||||
session.device.clone(), session.file_name.clone(), session.size,
|
||||
session.part_path.clone(), session.final_path.clone(),
|
||||
)
|
||||
};
|
||||
|
||||
let sha = hash_file(&part_path)?;
|
||||
if final_path.exists() { bail!("目标文件已存在,请重新初始化上传") }
|
||||
fs::rename(&part_path, &final_path).context("完成文件重命名失败")?;
|
||||
{
|
||||
let mut map = sessions.lock().map_err(|_| anyhow::anyhow!("上传会话锁损坏"))?;
|
||||
map.remove(upload_id);
|
||||
}
|
||||
if let Ok(mut finished) = completed.lock() {
|
||||
// A QFT receive session is short-lived. Keep a bounded completion cache
|
||||
// only for retrying a lost finish response.
|
||||
if finished.len() >= 64 { finished.clear(); }
|
||||
finished.insert(upload_id.to_owned(), CompletedUpload { sha256: sha.clone(), size });
|
||||
}
|
||||
let _ = events.send(ReceiverEvent::UploadCompleted {
|
||||
device, file_name, saved_path: final_path, sha256: sha.clone(),
|
||||
});
|
||||
let body = json!({"ok": true, "sha256": sha, "size": size}).to_string();
|
||||
write_response(stream, 200, "application/json", body.as_bytes())
|
||||
}
|
||||
|
||||
fn receive_legacy_stream(
|
||||
stream: &mut TcpStream,
|
||||
reader: &mut BufReader<TcpStream>,
|
||||
save_dir: &Path,
|
||||
headers: &HashMap<String, String>,
|
||||
device: &str,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
) -> Result<()> {
|
||||
let file_name = decode_header(headers.get("x-qft-filename"))
|
||||
.map(sanitize_file_name)
|
||||
.filter(|s| !s.is_empty())
|
||||
.unwrap_or_else(|| "qft-upload.bin".to_owned());
|
||||
let size: u64 = headers.get("content-length")
|
||||
.context("缺少 Content-Length")?
|
||||
.parse().context("Content-Length 无效")?;
|
||||
let declared_size = headers.get("x-qft-size")
|
||||
.and_then(|v| v.parse::<u64>().ok())
|
||||
.unwrap_or(size);
|
||||
if declared_size != size { bail!("文件大小头与 Content-Length 不一致") }
|
||||
|
||||
let final_path = unique_path(save_dir, &file_name);
|
||||
let final_name = final_path.file_name().and_then(|v| v.to_str()).unwrap_or("qft-upload.bin");
|
||||
let part_path = final_path.with_file_name(format!("{final_name}.qftpart"));
|
||||
let mut out = File::create(&part_path).with_context(|| format!("创建临时文件 {}", part_path.display()))?;
|
||||
let _ = events.send(ReceiverEvent::UploadStarted { device: device.to_owned(), file_name: file_name.clone(), size });
|
||||
|
||||
let mut remaining = size;
|
||||
let mut received = 0u64;
|
||||
let mut buf = vec![0u8; IO_BUFFER];
|
||||
let mut hasher = Sha256::new();
|
||||
let mut last_report = Instant::now();
|
||||
while remaining > 0 {
|
||||
let want = remaining.min(buf.len() as u64) as usize;
|
||||
let n = reader.read(&mut buf[..want])?;
|
||||
if n == 0 { bail!("上传中连接提前关闭:{received}/{size}") }
|
||||
out.write_all(&buf[..n])?;
|
||||
hasher.update(&buf[..n]);
|
||||
received += n as u64;
|
||||
remaining -= n as u64;
|
||||
if last_report.elapsed() >= Duration::from_millis(100) || remaining == 0 {
|
||||
let _ = events.send(ReceiverEvent::UploadProgress {
|
||||
device: device.to_owned(), file_name: file_name.clone(), received, size,
|
||||
});
|
||||
last_report = Instant::now();
|
||||
}
|
||||
}
|
||||
out.sync_all()?;
|
||||
drop(out);
|
||||
fs::rename(&part_path, &final_path).context("完成文件重命名失败")?;
|
||||
let sha = hex(&hasher.finalize());
|
||||
let _ = events.send(ReceiverEvent::UploadCompleted {
|
||||
device: device.to_owned(), file_name, saved_path: final_path, sha256: sha,
|
||||
});
|
||||
write_response(stream, 200, "application/json", b"{\"ok\":true,\"legacy\":true}")
|
||||
}
|
||||
|
||||
fn copy_exact(reader: &mut impl Read, writer: &mut impl Write, mut remaining: u64) -> Result<()> {
|
||||
let mut buf = vec![0u8; IO_BUFFER];
|
||||
while remaining > 0 {
|
||||
let want = remaining.min(buf.len() as u64) as usize;
|
||||
let n = reader.read(&mut buf[..want])?;
|
||||
if n == 0 { bail!("chunk 上传中连接提前关闭") }
|
||||
writer.write_all(&buf[..n])?;
|
||||
remaining -= n as u64;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn drain_exact(reader: &mut impl Read, remaining: u64) -> Result<()> {
|
||||
copy_exact(reader, &mut std::io::sink(), remaining)
|
||||
}
|
||||
|
||||
fn hash_file(path: &Path) -> Result<String> {
|
||||
let mut input = File::open(path)?;
|
||||
let mut hasher = Sha256::new();
|
||||
let mut buf = vec![0u8; 4 * 1024 * 1024];
|
||||
loop {
|
||||
let n = input.read(&mut buf)?;
|
||||
if n == 0 { break }
|
||||
hasher.update(&buf[..n]);
|
||||
}
|
||||
Ok(hex(&hasher.finalize()))
|
||||
}
|
||||
|
||||
fn write_response(stream: &mut TcpStream, code: u16, content_type: &str, body: &[u8]) -> Result<()> {
|
||||
let reason = match code {
|
||||
200 => "OK", 400 => "Bad Request", 403 => "Forbidden", 404 => "Not Found",
|
||||
409 => "Conflict", _ => "Error",
|
||||
};
|
||||
write!(stream,
|
||||
"HTTP/1.1 {code} {reason}\r\nContent-Type: {content_type}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
|
||||
body.len())?;
|
||||
stream.write_all(body)?;
|
||||
stream.flush()?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn decode_header(value: Option<&String>) -> Option<String> {
|
||||
let raw = value?;
|
||||
let bytes = URL_SAFE_NO_PAD.decode(raw).ok()?;
|
||||
String::from_utf8(bytes).ok()
|
||||
}
|
||||
|
||||
fn sanitize_file_name(name: String) -> String {
|
||||
let cleaned: String = name.chars()
|
||||
.map(|c| if c.is_control() || matches!(c, '<' | '>' | ':' | '"' | '/' | '\\' | '|' | '?' | '*') { '_' } else { c })
|
||||
.collect();
|
||||
cleaned.trim().trim_matches('.').chars().take(180).collect()
|
||||
}
|
||||
|
||||
fn unique_path(dir: &Path, name: &str) -> PathBuf {
|
||||
let base = Path::new(name);
|
||||
let stem = base.file_stem().and_then(|s| s.to_str()).unwrap_or("qft-upload");
|
||||
let ext = base.extension().and_then(|s| s.to_str());
|
||||
let mut candidate = dir.join(name);
|
||||
let mut n = 1;
|
||||
while candidate.exists() {
|
||||
let next = match ext {
|
||||
Some(ext) => format!("{stem} ({n}).{ext}"),
|
||||
None => format!("{stem} ({n})"),
|
||||
};
|
||||
candidate = dir.join(next);
|
||||
n += 1;
|
||||
}
|
||||
candidate
|
||||
}
|
||||
|
||||
fn unique_path_reserved<'a>(
|
||||
dir: &Path,
|
||||
name: &str,
|
||||
sessions: impl Iterator<Item = &'a Arc<Mutex<UploadSession>>>,
|
||||
) -> PathBuf {
|
||||
let reserved: Vec<PathBuf> = sessions
|
||||
.filter_map(|s| s.lock().ok().map(|v| v.final_path.clone()))
|
||||
.collect();
|
||||
let base = Path::new(name);
|
||||
let stem = base.file_stem().and_then(|s| s.to_str()).unwrap_or("qft-upload");
|
||||
let ext = base.extension().and_then(|s| s.to_str());
|
||||
let mut n = 0u32;
|
||||
loop {
|
||||
let next_name = if n == 0 {
|
||||
name.to_owned()
|
||||
} else {
|
||||
match ext {
|
||||
Some(ext) => format!("{stem} ({n}).{ext}"),
|
||||
None => format!("{stem} ({n})"),
|
||||
}
|
||||
};
|
||||
let candidate = dir.join(next_name);
|
||||
if !candidate.exists() && !reserved.contains(&candidate) {
|
||||
return candidate;
|
||||
}
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
|
||||
fn random_id() -> String {
|
||||
let mut bytes = [0u8; 12];
|
||||
rand::rng().fill_bytes(&mut bytes);
|
||||
URL_SAFE_NO_PAD.encode(bytes)
|
||||
}
|
||||
|
||||
fn hex(bytes: &[u8]) -> String {
|
||||
const H: &[u8; 16] = b"0123456789abcdef";
|
||||
let mut out = String::with_capacity(bytes.len() * 2);
|
||||
for &b in bytes { out.push(H[(b >> 4) as usize] as char); out.push(H[(b & 15) as usize] as char); }
|
||||
out
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::{
|
||||
io::{Read, Write},
|
||||
net::TcpListener,
|
||||
sync::mpsc,
|
||||
time::{SystemTime, UNIX_EPOCH},
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn legacy_upload_waits_for_a_delayed_body_on_a_nonblocking_accepted_socket() {
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let dir = std::env::temp_dir().join(format!(
|
||||
"qft-receiver-test-{}-{}",
|
||||
std::process::id(),
|
||||
SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos(),
|
||||
));
|
||||
fs::create_dir_all(&dir).unwrap();
|
||||
let dir_for_server = dir.clone();
|
||||
let (events, _updates) = mpsc::channel();
|
||||
let sessions: SessionMap = Arc::new(Mutex::new(HashMap::new()));
|
||||
let completed: CompletedMap = Arc::new(Mutex::new(HashMap::new()));
|
||||
|
||||
let server = thread::spawn(move || {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
// This matches the Windows mode inheritance that previously made
|
||||
// the body read return WSAEWOULDBLOCK between TCP packets.
|
||||
stream.set_nonblocking(true).unwrap();
|
||||
handle_client(
|
||||
&mut stream,
|
||||
&dir_for_server,
|
||||
"session",
|
||||
"000000",
|
||||
&AtomicU32::new(0),
|
||||
&events,
|
||||
&sessions,
|
||||
&completed,
|
||||
)
|
||||
});
|
||||
|
||||
let mut client = TcpStream::connect(address).unwrap();
|
||||
client
|
||||
.write_all(
|
||||
b"POST /qft/upload HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\nContent-Length: 4\r\nX-QFT-Size: 4\r\n\r\n",
|
||||
)
|
||||
.unwrap();
|
||||
client.flush().unwrap();
|
||||
thread::sleep(Duration::from_millis(50));
|
||||
client.write_all(b"qft!").unwrap();
|
||||
client.flush().unwrap();
|
||||
|
||||
let mut response = String::new();
|
||||
client.read_to_string(&mut response).unwrap();
|
||||
server.join().unwrap().unwrap();
|
||||
assert!(response.starts_with("HTTP/1.1 200"), "{response}");
|
||||
assert_eq!(fs::read(dir.join("qft-upload.bin")).unwrap(), b"qft!");
|
||||
let _ = fs::remove_dir_all(dir);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user