0f0dbaef47
三个问题一起处理。 1. 提权改为手动 上一版会在点「启动接收」时自动弹 UAC。实际用下来太侵入——多数人 只是想收个文件,却先被要求管理员授权。现在: - 检测保持自动,但**只读**,无任何副作用 - 提权只在用户点「放行防火墙(需要管理员授权)」时发生 - 按钮无条件保留,不再只在"检测到被拦"时出现:检测可能不准, 而用户遇到「对方连不上」时需要有地方可点 - 同时移除了拒绝标记的持久化——提权已不自动发生,无需记忆 2. Windows 构建报 os error 5 error: failed to remove file `...\target\release\qft-desktop.exe` Caused by: 拒绝访问。 (os error 5) 原因是 QFT 窗口还开着,运行中的 exe 锁住了产物文件,而 cargo 的报错 完全看不出这一层。VERIFY_WINDOWS_HOST.ps1 现在会在构建前检测 qft-desktop 进程,列出 PID 并询问是否结束;README 也补了说明 (含 Defender 扫描导致的偶发同类报错)。 3. 构建警告 15 → 5 长期堆积的警告会训练人忽略所有警告,所以逐条处理: - 真实问题:if 条件多余的括号,已修 - 为后续里程碑准备但尚未接线的 API(client::ping、download_file、 platform::direct_ap_support/ensure_dir),加 #[allow(dead_code)] 并注明将在哪个阶段使用 - 仅特定平台构造的项(firewall::RULE_NAME 只用于 Windows, FirewallStatus::Unsupported 只在 Linux 返回),改用 #[cfg_attr(not(...), allow(dead_code))],避免无条件放行 剩余 5 个均为本次改动之前既有(cache_mib、v/transport、security、 path),不属本次范围,未改动。 验证:cargo test 35/35,release 构建 5 个警告且全部是既有的。
653 lines
24 KiB
Rust
653 lines
24 KiB
Rust
//! 桌面端的**发起侧**。
|
||
//!
|
||
//! v0.4.7 之前桌面端只有服务端(`receiver.rs` / `sender.rs`),
|
||
//! `TcpStream::connect` 只出现在测试里,因此 PC 无法主动连接另一台 PC。
|
||
//! 本模块补上这一半,PC↔PC 才成立。
|
||
//!
|
||
//! 线格式与 Android `UploadClient.kt`/`DownloadClient.kt`、
|
||
//! iOS `UploadClient.swift`/`DownloadClient.swift` 完全一致——沿用现有 v2 HTTP,
|
||
//! 不引入 HTTP 客户端依赖:服务端本来就是手写的,两边保持同一套解析更容易对齐。
|
||
|
||
use anyhow::{bail, Context, Result};
|
||
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
|
||
use std::{
|
||
collections::HashMap,
|
||
fs::{File, OpenOptions},
|
||
io::{BufRead, BufReader, Read, Seek, SeekFrom, Write},
|
||
net::{SocketAddr, TcpStream, ToSocketAddrs},
|
||
path::{Path, PathBuf},
|
||
sync::{
|
||
atomic::{AtomicU32, AtomicU64, Ordering},
|
||
Arc,
|
||
},
|
||
time::Duration,
|
||
};
|
||
|
||
const IO_BUFFER: usize = 1024 * 1024;
|
||
/// 与移动端一致:按文件大小自适应 4/8/16 MiB
|
||
const CHUNK_SMALL: u64 = 4 * 1024 * 1024;
|
||
const CHUNK_DEFAULT: u64 = 8 * 1024 * 1024;
|
||
const CHUNK_LARGE: u64 = 16 * 1024 * 1024;
|
||
const MAX_WORKERS: usize = 8;
|
||
|
||
#[derive(Clone, Debug)]
|
||
pub struct PeerClient {
|
||
/// 形如 `http://192.168.1.20:39393`
|
||
pub base_url: String,
|
||
pub token: String,
|
||
pub device_name: String,
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug)]
|
||
pub struct Progress {
|
||
pub done: u64,
|
||
/// 单个文件的总量。多文件发送时 UI 用的是跨文件的累计总量,
|
||
/// 因此当前没有读者;保留是为了让回调本身自洽,
|
||
/// 单文件场景(如 P2 的目录传输逐项进度)会用到。
|
||
#[allow(dead_code)]
|
||
pub total: u64,
|
||
}
|
||
|
||
impl PeerClient {
|
||
pub fn new(base_url: impl Into<String>, token: impl Into<String>, device_name: impl Into<String>) -> Self {
|
||
Self {
|
||
base_url: base_url.into(),
|
||
token: token.into(),
|
||
device_name: device_name.into(),
|
||
}
|
||
}
|
||
|
||
fn address(&self) -> Result<SocketAddr> {
|
||
let rest = self
|
||
.base_url
|
||
.strip_prefix("http://")
|
||
.context("端点必须以 http:// 开头")?;
|
||
let rest = rest.trim_end_matches('/');
|
||
if rest.contains('/') {
|
||
bail!("端点不允许带路径:{}", self.base_url)
|
||
}
|
||
rest.to_socket_addrs()
|
||
.with_context(|| format!("无法解析端点 {}", self.base_url))?
|
||
.next()
|
||
.with_context(|| format!("端点无可用地址 {}", self.base_url))
|
||
}
|
||
|
||
fn auth_headers(&self) -> Vec<(String, String)> {
|
||
vec![
|
||
("X-QFT-Token".into(), self.token.clone()),
|
||
(
|
||
"X-QFT-Device".into(),
|
||
URL_SAFE_NO_PAD.encode(self.device_name.as_bytes()),
|
||
),
|
||
]
|
||
}
|
||
|
||
/// `GET /qft/ping`。用于发现阶段快速验证「这个地址上确实是我要找的那台 QFT」。
|
||
// 供 P1.5 的发现流程与后续的可达性诊断使用,当前 UI 尚未接线
|
||
#[allow(dead_code)]
|
||
pub fn ping(&self, timeout: Duration) -> Result<serde_json::Value> {
|
||
let address = self.address()?;
|
||
let mut response = send_request(address, "GET", "/qft/ping", &self.auth_headers(), None, timeout)?;
|
||
if response.status != 200 {
|
||
bail!("ping 返回 HTTP {}", response.status)
|
||
}
|
||
let body = response.read_body()?;
|
||
serde_json::from_slice(&body).context("ping 响应不是 JSON")
|
||
}
|
||
|
||
/// `POST /qft/pair`:用 6 位配对码换取会话令牌。
|
||
///
|
||
/// PC↔PC 的入口——桌面端没有摄像头,扫不了二维码,
|
||
/// 只能由用户把对方屏幕上的 6 位数字敲进来。
|
||
pub fn pair(base_url: &str, code: &str, device_name: &str) -> Result<String> {
|
||
let probe = PeerClient::new(base_url, String::new(), device_name.to_owned());
|
||
let address = probe.address()?;
|
||
let mut headers = vec![
|
||
("X-QFT-Code".to_string(), code.to_string()),
|
||
(
|
||
"X-QFT-Device".to_string(),
|
||
URL_SAFE_NO_PAD.encode(device_name.as_bytes()),
|
||
),
|
||
];
|
||
headers.push(("Content-Length".to_string(), "0".to_string()));
|
||
|
||
let mut response = send_request(
|
||
address,
|
||
"POST",
|
||
"/qft/pair",
|
||
&headers[..2],
|
||
Some(&[]),
|
||
// 配对只是一次极小的请求,4 秒还没建连基本就是不通了。
|
||
// 拖到 10 秒只会让用户以为程序卡死。
|
||
Duration::from_secs(4),
|
||
)?;
|
||
let body = response.read_body()?;
|
||
let value: serde_json::Value = serde_json::from_slice(&body).unwrap_or(serde_json::Value::Null);
|
||
match response.status {
|
||
200 => value["token"]
|
||
.as_str()
|
||
.map(str::to_owned)
|
||
.context("配对响应缺少 token"),
|
||
403 => {
|
||
let remaining = value["remaining"].as_u64().unwrap_or(0);
|
||
bail!("配对码错误,还可尝试 {remaining} 次")
|
||
}
|
||
429 => bail!("配对码已作废,请让对方在电脑上重新启动接收"),
|
||
other => bail!("配对返回 HTTP {other}"),
|
||
}
|
||
}
|
||
|
||
// ------------------------------------------------------------ 上传
|
||
|
||
/// 把本地文件推送到对端的接收服务(对端跑 `receiver.rs`)。
|
||
pub fn upload_file(
|
||
&self,
|
||
path: &Path,
|
||
mut on_progress: impl FnMut(Progress) + Send,
|
||
) -> Result<String> {
|
||
let address = self.address()?;
|
||
let size = std::fs::metadata(path)
|
||
.with_context(|| format!("读取 {} 失败", path.display()))?
|
||
.len();
|
||
let name = path
|
||
.file_name()
|
||
.and_then(|v| v.to_str())
|
||
.filter(|v| !v.is_empty())
|
||
.unwrap_or("qft-upload.bin");
|
||
|
||
let session = self.init_upload(address, name, size)?;
|
||
if session.total_chunks == 0 {
|
||
on_progress(Progress { done: 0, total: 0 });
|
||
return self.finish_upload(address, &session.upload_id);
|
||
}
|
||
|
||
let next = Arc::new(AtomicU32::new(0));
|
||
let sent = Arc::new(AtomicU64::new(0));
|
||
let workers = (session.total_chunks as usize).min(MAX_WORKERS).max(1);
|
||
|
||
// 进度回调在主线程汇总:worker 只累加原子计数,避免把 FnMut 塞进多个线程
|
||
let failure = std::thread::scope(|scope| -> Result<()> {
|
||
let mut handles = Vec::with_capacity(workers);
|
||
for _ in 0..workers {
|
||
let next = next.clone();
|
||
let sent = sent.clone();
|
||
let session = &session;
|
||
handles.push(scope.spawn(move || -> Result<()> {
|
||
let mut file = File::open(path)?;
|
||
let mut buffer = vec![0u8; session.chunk_size as usize];
|
||
loop {
|
||
let index = next.fetch_add(1, Ordering::Relaxed);
|
||
if index >= session.total_chunks {
|
||
return Ok(());
|
||
}
|
||
let offset = index as u64 * session.chunk_size;
|
||
let length = (size - offset).min(session.chunk_size) as usize;
|
||
file.seek(SeekFrom::Start(offset))?;
|
||
file.read_exact(&mut buffer[..length])?;
|
||
self.put_chunk(address, &session.upload_id, index, &buffer[..length])?;
|
||
sent.fetch_add(length as u64, Ordering::Relaxed);
|
||
}
|
||
}));
|
||
}
|
||
let mut error = None;
|
||
for handle in handles {
|
||
match handle.join() {
|
||
Ok(Ok(())) => {}
|
||
Ok(Err(e)) => {
|
||
error.get_or_insert(e);
|
||
}
|
||
Err(_) => {
|
||
error.get_or_insert(anyhow::anyhow!("上传线程崩溃"));
|
||
}
|
||
}
|
||
}
|
||
match error {
|
||
Some(e) => Err(e),
|
||
None => Ok(()),
|
||
}
|
||
});
|
||
failure?;
|
||
|
||
on_progress(Progress {
|
||
done: sent.load(Ordering::Relaxed),
|
||
total: size,
|
||
});
|
||
self.finish_upload(address, &session.upload_id)
|
||
}
|
||
|
||
fn init_upload(&self, address: SocketAddr, name: &str, size: u64) -> Result<UploadSession> {
|
||
let chunk_size = desired_chunk_size(size);
|
||
let mut headers = self.auth_headers();
|
||
headers.push((
|
||
"X-QFT-Filename".into(),
|
||
URL_SAFE_NO_PAD.encode(name.as_bytes()),
|
||
));
|
||
headers.push(("X-QFT-Size".into(), size.to_string()));
|
||
headers.push(("X-QFT-Chunk-Size".into(), chunk_size.to_string()));
|
||
|
||
let mut response = send_request(
|
||
address,
|
||
"POST",
|
||
"/qft/upload/init",
|
||
&headers,
|
||
Some(&[]),
|
||
Duration::from_secs(15),
|
||
)?;
|
||
if response.status != 200 {
|
||
bail!("init 返回 HTTP {}", response.status)
|
||
}
|
||
let body = response.read_body()?;
|
||
let value: serde_json::Value = serde_json::from_slice(&body).context("init 响应不是 JSON")?;
|
||
Ok(UploadSession {
|
||
upload_id: value["upload_id"]
|
||
.as_str()
|
||
.context("init 响应缺少 upload_id")?
|
||
.to_owned(),
|
||
chunk_size: value["chunk_size"].as_u64().context("init 响应缺少 chunk_size")?,
|
||
total_chunks: value["total_chunks"]
|
||
.as_u64()
|
||
.context("init 响应缺少 total_chunks")? as u32,
|
||
})
|
||
}
|
||
|
||
fn put_chunk(&self, address: SocketAddr, upload_id: &str, index: u32, body: &[u8]) -> Result<()> {
|
||
let path = format!("/qft/upload/chunk/{upload_id}/{index}");
|
||
// 接收端对重复分块是幂等的,因此重试安全。
|
||
// 局域网上首次连接常被 Windows 防火墙首包丢弃,一次重试就能救回来。
|
||
let mut last = None;
|
||
for attempt in 0..3 {
|
||
match send_request(
|
||
address,
|
||
"POST",
|
||
&path,
|
||
&self.auth_headers(),
|
||
Some(body),
|
||
Duration::from_secs(60),
|
||
) {
|
||
Ok(mut response) => {
|
||
let payload = response.read_body()?;
|
||
if response.status == 200 {
|
||
return Ok(());
|
||
}
|
||
last = Some(anyhow::anyhow!(
|
||
"chunk {index} 返回 HTTP {}:{}",
|
||
response.status,
|
||
String::from_utf8_lossy(&payload[..payload.len().min(200)])
|
||
));
|
||
}
|
||
Err(e) => last = Some(e),
|
||
}
|
||
std::thread::sleep(Duration::from_millis(120 << attempt));
|
||
}
|
||
Err(last.unwrap_or_else(|| anyhow::anyhow!("chunk {index} 失败")))
|
||
}
|
||
|
||
fn finish_upload(&self, address: SocketAddr, upload_id: &str) -> Result<String> {
|
||
let path = format!("/qft/upload/finish/{upload_id}");
|
||
let mut response = send_request(
|
||
address,
|
||
"POST",
|
||
&path,
|
||
&self.auth_headers(),
|
||
Some(&[]),
|
||
Duration::from_secs(120),
|
||
)?;
|
||
let body = response.read_body()?;
|
||
if response.status != 200 {
|
||
bail!(
|
||
"finish 返回 HTTP {}:{}",
|
||
response.status,
|
||
String::from_utf8_lossy(&body[..body.len().min(200)])
|
||
)
|
||
}
|
||
let value: serde_json::Value = serde_json::from_slice(&body).context("finish 响应不是 JSON")?;
|
||
value["sha256"]
|
||
.as_str()
|
||
.map(str::to_owned)
|
||
.context("finish 响应缺少 sha256")
|
||
}
|
||
|
||
// ------------------------------------------------------------ 下载
|
||
|
||
/// 从对端的发送服务拉取文件(对端跑 `sender.rs`)。
|
||
/// 支持断点续传:`dest` 已存在的部分会作为 Range 起点。
|
||
// PC↔PC 目前只做「推送」,「主动拉取」在 P2 的会话模型里才用得上
|
||
#[allow(dead_code)]
|
||
pub fn download_file(
|
||
&self,
|
||
dest: &Path,
|
||
expected_size: Option<u64>,
|
||
mut on_progress: impl FnMut(Progress),
|
||
) -> Result<PathBuf> {
|
||
let address = self.address()?;
|
||
let part = dest.with_extension("qftpart");
|
||
let mut offset = part.metadata().map(|m| m.len()).unwrap_or(0);
|
||
if let Some(expected) = expected_size {
|
||
if offset > expected {
|
||
let _ = std::fs::remove_file(&part);
|
||
offset = 0;
|
||
}
|
||
}
|
||
|
||
let mut headers = self.auth_headers();
|
||
if offset > 0 {
|
||
headers.push(("Range".into(), format!("bytes={offset}-")));
|
||
}
|
||
let mut response = send_request(
|
||
address,
|
||
"GET",
|
||
"/qft/download",
|
||
&headers,
|
||
None,
|
||
Duration::from_secs(30),
|
||
)?;
|
||
if response.status != 200 && response.status != 206 {
|
||
bail!("下载返回 HTTP {}", response.status)
|
||
}
|
||
if response.status == 200 {
|
||
// 服务端忽略了 Range(旧版本),只能从头写
|
||
offset = 0;
|
||
}
|
||
|
||
let remaining = response
|
||
.headers
|
||
.get("content-length")
|
||
.and_then(|v| v.parse::<u64>().ok());
|
||
let total = expected_size.or_else(|| remaining.map(|r| offset + r)).unwrap_or(0);
|
||
|
||
if let Some(parent) = part.parent() {
|
||
platform_ensure_dir(parent)?;
|
||
}
|
||
let mut out = OpenOptions::new()
|
||
.create(true)
|
||
.write(true)
|
||
.open(&part)
|
||
.with_context(|| format!("创建 {} 失败", part.display()))?;
|
||
out.seek(SeekFrom::Start(offset))?;
|
||
out.set_len(offset)?;
|
||
|
||
let mut done = offset;
|
||
let mut buffer = vec![0u8; IO_BUFFER];
|
||
loop {
|
||
let n = response.reader.read(&mut buffer)?;
|
||
if n == 0 {
|
||
break;
|
||
}
|
||
out.write_all(&buffer[..n])?;
|
||
done += n as u64;
|
||
on_progress(Progress { done, total });
|
||
}
|
||
out.flush()?;
|
||
drop(out);
|
||
|
||
if let Some(expected) = expected_size {
|
||
if done != expected {
|
||
bail!("下载提前结束:{done}/{expected}")
|
||
}
|
||
}
|
||
std::fs::rename(&part, dest)
|
||
.with_context(|| format!("重命名 {} 失败", part.display()))?;
|
||
Ok(dest.to_path_buf())
|
||
}
|
||
}
|
||
|
||
struct UploadSession {
|
||
upload_id: String,
|
||
chunk_size: u64,
|
||
total_chunks: u32,
|
||
}
|
||
|
||
fn desired_chunk_size(size: u64) -> u64 {
|
||
if size < 32 * 1024 * 1024 {
|
||
CHUNK_SMALL
|
||
} else if size >= 512 * 1024 * 1024 {
|
||
CHUNK_LARGE
|
||
} else {
|
||
CHUNK_DEFAULT
|
||
}
|
||
}
|
||
|
||
#[allow(dead_code)] // 仅被尚未接线的 download_file 使用
|
||
fn platform_ensure_dir(path: &Path) -> Result<()> {
|
||
crate::platform::ensure_dir(path)
|
||
.with_context(|| format!("创建目录 {} 失败", path.display()))
|
||
}
|
||
|
||
/// 把底层 io 错误翻译成能指导下一步的说法。
|
||
///
|
||
/// 「超时」和「被拒绝」的成因完全不同:前者是包被丢了(防火墙、主机不可达、
|
||
/// AP 客户端隔离),后者是端口上没人监听(对方没点"启动接收")。
|
||
/// 给用户一句笼统的"连接失败"等于什么都没说。
|
||
fn describe_connect_failure(address: SocketAddr, error: &std::io::Error) -> anyhow::Error {
|
||
use std::io::ErrorKind;
|
||
let ip = address.ip();
|
||
match error.kind() {
|
||
ErrorKind::TimedOut => anyhow::anyhow!(
|
||
"连接 {address} 超时:数据包发出去了但没有任何回应。\n\
|
||
常见原因:① 对方电脑的防火墙拦截了入站连接(Windows 上需要放行 qft-desktop.exe 的专用网络);\
|
||
② Wi-Fi 开了客户端隔离,同网段设备之间不能互通;\
|
||
③ 对方已经关掉接收或换了网络。"
|
||
),
|
||
ErrorKind::ConnectionRefused => anyhow::anyhow!(
|
||
"{ip} 明确拒绝了连接:主机在线,但 {} 端口上没有程序在监听。\n\
|
||
请确认对方已经在「我要接收」里点了「启动接收」,并且连接码是最新的那一串。",
|
||
address.port()
|
||
),
|
||
ErrorKind::HostUnreachable | ErrorKind::NetworkUnreachable => anyhow::anyhow!(
|
||
"路由不可达:本机没有能到达 {ip} 的路由。请确认两台设备连在同一个网络里。"
|
||
),
|
||
_ => anyhow::anyhow!("连接 {address} 失败:{error}"),
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------- 极简 HTTP 客户端
|
||
|
||
struct HttpResponse {
|
||
status: u16,
|
||
headers: HashMap<String, String>,
|
||
reader: BufReader<TcpStream>,
|
||
}
|
||
|
||
impl HttpResponse {
|
||
/// 读完整个响应体。服务端总是发 `Connection: close`,
|
||
/// 所以按 Content-Length 读,没有该头则读到 EOF。
|
||
fn read_body(&mut self) -> Result<Vec<u8>> {
|
||
let mut body = Vec::new();
|
||
match self.headers.get("content-length").and_then(|v| v.parse::<u64>().ok()) {
|
||
Some(length) => {
|
||
body.resize(length as usize, 0);
|
||
self.reader.read_exact(&mut body)?;
|
||
}
|
||
None => {
|
||
self.reader.read_to_end(&mut body)?;
|
||
}
|
||
}
|
||
Ok(body)
|
||
}
|
||
}
|
||
|
||
fn send_request(
|
||
address: SocketAddr,
|
||
method: &str,
|
||
path: &str,
|
||
headers: &[(String, String)],
|
||
body: Option<&[u8]>,
|
||
timeout: Duration,
|
||
) -> Result<HttpResponse> {
|
||
let stream = TcpStream::connect_timeout(&address, timeout.min(Duration::from_secs(10)))
|
||
.map_err(|e| describe_connect_failure(address, &e))?;
|
||
stream.set_nodelay(true).ok();
|
||
stream.set_read_timeout(Some(timeout))?;
|
||
stream.set_write_timeout(Some(timeout))?;
|
||
|
||
let mut request = String::with_capacity(256);
|
||
request.push_str(&format!("{method} {path} HTTP/1.1\r\n"));
|
||
request.push_str(&format!("Host: {address}\r\n"));
|
||
request.push_str("Connection: close\r\n");
|
||
for (name, value) in headers {
|
||
request.push_str(&format!("{name}: {value}\r\n"));
|
||
}
|
||
if let Some(body) = body {
|
||
request.push_str("Content-Type: application/octet-stream\r\n");
|
||
request.push_str(&format!("Content-Length: {}\r\n", body.len()));
|
||
}
|
||
request.push_str("\r\n");
|
||
|
||
let mut writer = stream.try_clone()?;
|
||
writer.write_all(request.as_bytes())?;
|
||
if let Some(body) = body {
|
||
if !body.is_empty() {
|
||
writer.write_all(body)?;
|
||
}
|
||
}
|
||
writer.flush()?;
|
||
|
||
let mut reader = BufReader::with_capacity(64 * 1024, stream);
|
||
let mut status_line = String::new();
|
||
reader.read_line(&mut status_line)?;
|
||
if status_line.is_empty() {
|
||
bail!("对端在返回状态行前关闭了连接")
|
||
}
|
||
let status: u16 = status_line
|
||
.split_whitespace()
|
||
.nth(1)
|
||
.and_then(|v| v.parse().ok())
|
||
.with_context(|| format!("无法解析状态行:{}", status_line.trim()))?;
|
||
|
||
let mut response_headers = HashMap::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 let Some((name, value)) = line.split_once(':') {
|
||
response_headers.insert(name.trim().to_ascii_lowercase(), value.trim().to_owned());
|
||
}
|
||
}
|
||
|
||
Ok(HttpResponse {
|
||
status,
|
||
headers: response_headers,
|
||
reader,
|
||
})
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
|
||
#[test]
|
||
fn rejects_endpoints_with_path_or_wrong_scheme() {
|
||
let make = |url: &str| PeerClient::new(url, "token", "dev").address();
|
||
assert!(make("https://192.168.1.1:39393").is_err());
|
||
assert!(make("http://192.168.1.1:39393/qft").is_err());
|
||
assert!(make("192.168.1.1:39393").is_err());
|
||
assert!(make("http://127.0.0.1:39393").is_ok());
|
||
// 结尾斜杠应被容忍
|
||
assert!(make("http://127.0.0.1:39393/").is_ok());
|
||
}
|
||
|
||
#[test]
|
||
fn chunk_size_matches_mobile_clients() {
|
||
assert_eq!(desired_chunk_size(1024), CHUNK_SMALL);
|
||
assert_eq!(desired_chunk_size(31 * 1024 * 1024), CHUNK_SMALL);
|
||
assert_eq!(desired_chunk_size(64 * 1024 * 1024), CHUNK_DEFAULT);
|
||
assert_eq!(desired_chunk_size(600 * 1024 * 1024), CHUNK_LARGE);
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod integration_tests {
|
||
use super::*;
|
||
use crate::receiver::{ReceiverEvent, ReceiverServer};
|
||
use std::sync::mpsc;
|
||
|
||
/// 端到端:起一个真实的接收服务,用真实的 HTTP 客户端配对 + 上传,
|
||
/// 校验落盘文件的 SHA-256 与接收端返回值一致。
|
||
/// 这就是 PC↔PC 的完整链路,只是两端在同一进程里。
|
||
#[test]
|
||
fn pairs_then_uploads_a_real_file() {
|
||
let root = std::env::temp_dir().join(format!("qft-pcpc-{}", std::process::id()));
|
||
let inbox = root.join("inbox");
|
||
std::fs::create_dir_all(&inbox).unwrap();
|
||
let source = root.join("payload.bin");
|
||
// 跨越多个分块边界的大小,确保并发路径被覆盖
|
||
let payload: Vec<u8> = (0..(9 * 1024 * 1024 + 777)).map(|i| (i % 251) as u8).collect();
|
||
std::fs::write(&source, &payload).unwrap();
|
||
|
||
let token = crate::pairing::new_session_token();
|
||
let (tx, rx) = mpsc::channel::<ReceiverEvent>();
|
||
let server = ReceiverServer::start(inbox.clone(), token.clone(), tx).unwrap();
|
||
let base_url = format!("http://127.0.0.1:{}", server.port);
|
||
|
||
// 走完整的连接码链路:编码 → 用户输入 → 解码 → 换令牌
|
||
let code = crate::connect_code::ConnectCode::new(
|
||
std::net::IpAddr::V4(std::net::Ipv4Addr::LOCALHOST),
|
||
server.port,
|
||
server.secret,
|
||
);
|
||
let typed = code.encode();
|
||
let parsed = crate::connect_code::ConnectCode::decode(&typed).expect("连接码应能解析");
|
||
assert_eq!(parsed.base_url(), base_url, "码里解出的地址应与实际服务一致");
|
||
|
||
// 错误秘密必须被拒
|
||
assert!(PeerClient::pair(&base_url, "000000", "tester").is_err());
|
||
|
||
let paired = PeerClient::pair(&base_url, &parsed.secret_hex(), "tester").unwrap();
|
||
assert_eq!(paired, token, "配对应返回真实会话令牌");
|
||
|
||
let client = PeerClient::new(base_url, paired, "tester");
|
||
let mut last = Progress { done: 0, total: 0 };
|
||
let sha = client.upload_file(&source, |p| last = p).unwrap();
|
||
assert_eq!(last.done, payload.len() as u64, "进度应抵达文件全长");
|
||
|
||
let landed = inbox.join("payload.bin");
|
||
let saved = std::fs::read(&landed).expect("文件应已落盘");
|
||
assert_eq!(saved.len(), payload.len());
|
||
assert_eq!(saved, payload, "落盘内容必须逐字节一致");
|
||
|
||
use sha2::{Digest, Sha256};
|
||
let expected = Sha256::digest(&payload);
|
||
let expected_hex: String = expected.iter().map(|b| format!("{b:02x}")).collect();
|
||
assert_eq!(sha, expected_hex, "接收端返回的 SHA-256 必须与本地一致");
|
||
|
||
drop(server);
|
||
while rx.try_recv().is_ok() {}
|
||
let _ = std::fs::remove_dir_all(&root);
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod failure_message_tests {
|
||
use super::*;
|
||
|
||
/// 不可达地址必须给出「超时」类的排查建议,而不是一句空洞的失败。
|
||
#[test]
|
||
fn unreachable_host_yields_actionable_timeout_message() {
|
||
// 192.0.2.0/24 是 RFC 5737 保留的文档用网段,不会有真实主机应答
|
||
let error = PeerClient::pair("http://192.0.2.1:39393", "abcdef", "tester")
|
||
.expect_err("不可达地址必须失败");
|
||
let text = format!("{error:#}");
|
||
assert!(text.contains("防火墙") || text.contains("超时") || text.contains("路由"),
|
||
"应给出可执行的排查方向,实得:{text}");
|
||
}
|
||
|
||
/// 本机没人监听的端口会被内核直接拒绝,提示必须与"超时"区分开。
|
||
#[test]
|
||
fn refused_port_says_receiver_not_started() {
|
||
let listener = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
|
||
let port = listener.local_addr().unwrap().port();
|
||
drop(listener); // 端口随即空出,连接会被拒绝
|
||
|
||
let error = PeerClient::pair(&format!("http://127.0.0.1:{port}"), "abcdef", "tester")
|
||
.expect_err("空端口必须失败");
|
||
let text = format!("{error:#}");
|
||
assert!(text.contains("启动接收") || text.contains("拒绝"),
|
||
"被拒绝时应提示对方没启动接收,实得:{text}");
|
||
}
|
||
}
|