Files
QFT/desktop/src/receiver.rs
T
zhy200308 84643bff5e feat(desktop): PC↔PC 改用连接码,一串搞定,不再单独输 IP
此前发送方要分别念/输三样东西:IP、端口、6 位配对码。现在合成一串
可口述的连接码,**地址就编在码里**,所以拿到码即可直连——不需要广播、
不需要在同一网段,只要 IP 层路由可达即可(同一路由器下的不同 VLAN /
网段正属于这种情况)。

新增 connect_code.rs
- 编码:version(3) | kind(3) | 默认端口位 | 地址 | [端口] | 24bit 秘密 | CRC-8
- 按网段压缩地址:192.168.a.b 只需 2 字节,10./172.16-31. 三字节,
  其余四字节,IPv6 十六字节
- Crockford Base32(去掉易混的 I/L/O/U),分组显示
- 典型 192.168.a.b:39393 → **12 个字符**,如 4849-3WT1-3ZS0
- 输入容错:大小写、分隔符、空格随意;I/L 归一为 1、O 归一为 0

接收侧
- 6 位配对码 → 3 字节秘密;UI 为**每个网卡各生成一个连接码**,
  对方在哪个网段就用哪一串(虚拟网卡排后面)
- 新增 pairing::local_ipv4_addresses(),按「最可能被对方看到」排序

发送侧
- 三个输入框(设备列表 / 手动 IP / 配对码)合并为**一个连接码输入框**
- 边打边校验:CRC 在连接之前就能发现输错,并实时显示「将连接 http://x.x.x.x:port」
- 广播搜索降级为可选的折叠项——同网段免输码是锦上添花,不再是主路径

一个被测试抓出来的真问题
最初单字符输错的拦截率只有 96%。原因是 12 个 Base32 字符携带 60 bit
而实际只用 56 bit,末尾 4 个填充位被解码器直接丢弃,改动最后一个字符
有 1/16 概率解出完全相同的字节,CRC 根本没机会发现。加上填充位必须为 0
的校验后拦截率 >99%。

必须说清的边界
连接码解决的是「找不到对方」和「输入太繁琐」,不能凭空制造可达性。
若两台机器在 IP 层互不可达(Wi-Fi 客户端隔离、各自在不同物理网络),
任何客户端侧协议都无法建立连接,只能换链路或引入第三方中转——
后者与 QFT「不经过外网」的定位冲突,本版不做。

验证:cargo test 30/30,含连接码往返(全部地址类型)、容错输入、
单字符输错拦截率统计、以及走完整连接码链路的端到端传输
(编码 → 解码 → 换令牌 → 9MB 并发上传 → SHA-256 比对)。
2026-08-11 17:29:00 +08:00

756 lines
29 KiB
Rust
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.
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 的配对秘密(3 字节)。UI 会把它和本机地址一起编成连接码,
/// 用户只需要念/粘贴那一串,不必再单独报 IP 和端口。
pub secret: [u8; crate::connect_code::SECRET_LEN],
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()));
// 24 bit 秘密对在线爆破仍然不够,靠严格失败计数兜底:
// 错 5 次即作废,必须重启接收重新生成。
let secret = crate::connect_code::new_secret();
let secret_hex: String = secret.iter().map(|b| format!("{b:02x}")).collect();
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 = secret_hex.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),
secret,
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);
}
}