feat: 提交0.4加速版二维码直传与自动配网优化
This commit is contained in:
+242
-4
@@ -5,21 +5,25 @@ mod pairing;
|
||||
mod protocol;
|
||||
mod qr;
|
||||
mod receiver;
|
||||
mod sender;
|
||||
|
||||
use eframe::egui::{self, FontData, FontDefinitions, FontFamily, TextureHandle, TextureOptions};
|
||||
use optical_cache::OpticalPrefetcher;
|
||||
use pairing::{PairingPayload, WifiCredentials};
|
||||
use pairing::{PairingDirection, PairingPayload, WifiCredentials};
|
||||
use protocol::{hex_sha256, TransferSource};
|
||||
use receiver::{ReceiverEvent, ReceiverServer};
|
||||
use sender::{SenderEvent, SenderServer};
|
||||
use std::{
|
||||
path::{Path, PathBuf},
|
||||
sync::{mpsc, Arc},
|
||||
time::{Duration, Instant},
|
||||
};
|
||||
|
||||
const DEFAULT_CHUNK_SIZE: u16 = 450;
|
||||
// A lower-density symbol gains more from reliable 25~30 FPS recognition than
|
||||
// a nominally larger page that is only decoded 10~18 times per second.
|
||||
const DEFAULT_CHUNK_SIZE: u16 = 320;
|
||||
const UI_FONT_NAME: &str = "qft-ui";
|
||||
const APP_VERSION: &str = "0.4.0-rc2";
|
||||
const APP_VERSION: &str = "0.4.0-rc6";
|
||||
|
||||
fn main() -> eframe::Result {
|
||||
let options = eframe::NativeOptions {
|
||||
@@ -41,6 +45,7 @@ enum Screen {
|
||||
Home,
|
||||
OpticalSend,
|
||||
PhoneToPc,
|
||||
PcToPhone,
|
||||
}
|
||||
|
||||
struct OpticalState {
|
||||
@@ -82,12 +87,27 @@ struct ReceiveState {
|
||||
rate_bps: f64,
|
||||
}
|
||||
|
||||
struct SendState {
|
||||
file: Option<PathBuf>,
|
||||
file_size: u64,
|
||||
sha256: Option<String>,
|
||||
use_direct_ap: bool,
|
||||
server: Option<SenderServer>,
|
||||
direct_ap: Option<direct_ap::DirectAp>,
|
||||
events: Option<mpsc::Receiver<SenderEvent>>,
|
||||
pair_texture: Option<TextureHandle>,
|
||||
session_token: String,
|
||||
status: String,
|
||||
connected_device: String,
|
||||
}
|
||||
|
||||
struct QftApp {
|
||||
screen: Screen,
|
||||
font_status: String,
|
||||
local_device: String,
|
||||
optical: OpticalState,
|
||||
receive: ReceiveState,
|
||||
send: SendState,
|
||||
}
|
||||
|
||||
impl QftApp {
|
||||
@@ -109,7 +129,7 @@ impl QftApp {
|
||||
page_index: 0,
|
||||
round: 0,
|
||||
playing: false,
|
||||
fps: 45.0,
|
||||
fps: 30.0,
|
||||
cache_mib: 256,
|
||||
control_width: 330.0,
|
||||
qr_zoom: 1.0,
|
||||
@@ -139,6 +159,19 @@ impl QftApp {
|
||||
transfer_started: None,
|
||||
rate_bps: 0.0,
|
||||
},
|
||||
send: SendState {
|
||||
file: None,
|
||||
file_size: 0,
|
||||
sha256: None,
|
||||
use_direct_ap: true,
|
||||
server: None,
|
||||
direct_ap: None,
|
||||
events: None,
|
||||
pair_texture: None,
|
||||
session_token: String::new(),
|
||||
status: "选择文件后生成二维码;手机扫码会自动配网并开始下载。".into(),
|
||||
connected_device: "等待 Android 扫码".into(),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -153,6 +186,7 @@ impl QftApp {
|
||||
if self.screen != Screen::Home && ui.button("← 返回首页").clicked() {
|
||||
match self.screen {
|
||||
Screen::PhoneToPc => self.stop_receiver(),
|
||||
Screen::PcToPhone => self.stop_sender(),
|
||||
Screen::OpticalSend => { self.optical.playing = false; self.optical.prefetch = None; },
|
||||
Screen::Home => {}
|
||||
}
|
||||
@@ -203,6 +237,17 @@ impl QftApp {
|
||||
});
|
||||
});
|
||||
ui.add_space(18.0);
|
||||
ui.group(|ui| {
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
ui.heading("电脑 → Android · 扫码自动直传");
|
||||
ui.separator();
|
||||
ui.label("选择文件 · 生成 QFTSEND2 · 手机扫码后自动配网并下载到 Downloads/QFT");
|
||||
if ui.add_sized([220.0, 42.0], egui::Button::new("直传文件到手机")).clicked() {
|
||||
self.screen = Screen::PcToPhone;
|
||||
}
|
||||
});
|
||||
});
|
||||
ui.add_space(18.0);
|
||||
ui.group(|ui| {
|
||||
ui.label(format!("本机设备:{}", self.local_device));
|
||||
ui.small(&self.font_status);
|
||||
@@ -495,6 +540,88 @@ impl QftApp {
|
||||
}
|
||||
}
|
||||
|
||||
fn pc_to_phone_ui(&mut self, ui: &mut egui::Ui, ctx: &egui::Context) {
|
||||
self.poll_sender_events();
|
||||
ctx.request_repaint_after(Duration::from_millis(100));
|
||||
let running = self.send.server.is_some();
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
ui.heading("电脑 → Android · 扫码自动直传");
|
||||
ui.separator();
|
||||
ui.label("QFTSEND2 · 自动连接本地 Wi-Fi · 扫码后立即下载");
|
||||
});
|
||||
ui.add_space(10.0);
|
||||
|
||||
ui.group(|ui| {
|
||||
ui.heading("1 · 选择发送文件");
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
if ui.add_enabled(!running, egui::Button::new("选择文件")).clicked() {
|
||||
if let Some(path) = rfd::FileDialog::new().pick_file() {
|
||||
match TransferSource::open(&path, DEFAULT_CHUNK_SIZE) {
|
||||
Ok(source) => {
|
||||
self.send.file_size = source.manifest.file_size;
|
||||
self.send.sha256 = Some(hex_sha256(&source.manifest.sha256));
|
||||
self.send.file = Some(path);
|
||||
self.send.status = "文件已就绪;生成二维码后,手机扫码会自动开始下载。".into();
|
||||
}
|
||||
Err(e) => self.send.status = format!("读取文件失败:{e:#}"),
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(path) = &self.send.file {
|
||||
ui.label(format!("{} · {}", path.display(), human_bytes(self.send.file_size)));
|
||||
} else {
|
||||
ui.label("尚未选择文件");
|
||||
}
|
||||
});
|
||||
if let Some(sha) = &self.send.sha256 { ui.small(format!("SHA-256:{sha}")); }
|
||||
});
|
||||
ui.add_space(8.0);
|
||||
|
||||
ui.group(|ui| {
|
||||
ui.heading("2 · 连接方式");
|
||||
ui.add_enabled_ui(!running, |ui| {
|
||||
ui.radio_value(&mut self.send.use_direct_ap, true, "QFT Direct(推荐)· Windows 自动创建临时 Wi-Fi");
|
||||
ui.radio_value(&mut self.send.use_direct_ap, false, "当前局域网(备用)· 手机和电脑已在同一 Wi-Fi/LAN");
|
||||
});
|
||||
ui.small("手机扫描二维码后会自动请求连接;已经批准过同一台电脑的 QFT Direct 网络时,系统通常无需再次确认。");
|
||||
});
|
||||
ui.add_space(8.0);
|
||||
|
||||
ui.group(|ui| {
|
||||
ui.heading("3 · 生成二维码并自动发送");
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
if ui.add_enabled(!running && self.send.file.is_some(), egui::Button::new("启动直传并生成二维码")).clicked() {
|
||||
self.start_sender(ctx);
|
||||
}
|
||||
if ui.add_enabled(running, egui::Button::new("停止直传")).clicked() { self.stop_sender(); }
|
||||
});
|
||||
ui.label(&self.send.status);
|
||||
});
|
||||
|
||||
if self.send.server.is_some() {
|
||||
ui.add_space(10.0);
|
||||
ui.columns(2, |cols| {
|
||||
cols[0].group(|ui| {
|
||||
ui.heading("手机扫码 · QFTSEND2");
|
||||
if let Some(texture) = &self.send.pair_texture {
|
||||
let side = ui.available_width().min(420.0).max(260.0);
|
||||
ui.vertical_centered(|ui| { ui.image((texture.id(), egui::vec2(side, side))); });
|
||||
}
|
||||
if let Some(ap) = &self.send.direct_ap {
|
||||
ui.label(format!("临时网络:{}", ap.ssid));
|
||||
}
|
||||
});
|
||||
cols[1].group(|ui| {
|
||||
ui.heading("发送状态");
|
||||
ui.label(format!("电脑:{}", self.local_device));
|
||||
ui.label(format!("手机:{}", self.send.connected_device));
|
||||
ui.label(self.send.file.as_ref().map(|v| format!("文件:{}", v.display())).unwrap_or_default());
|
||||
ui.small("二维码只在本次直传会话有效;停止直传后立即失效。");
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
fn optical_pick_file(&mut self, ctx: &egui::Context) {
|
||||
let Some(path) = rfd::FileDialog::new().pick_file() else { return };
|
||||
match TransferSource::open(&path, DEFAULT_CHUNK_SIZE) {
|
||||
@@ -632,6 +759,10 @@ impl QftApp {
|
||||
port: server.port,
|
||||
endpoints: pairing::local_ipv4_endpoints(server.port),
|
||||
wifi,
|
||||
direction: PairingDirection::Upload,
|
||||
file_name: None,
|
||||
file_size: None,
|
||||
sha256: None,
|
||||
};
|
||||
let pair_text = match payload.encode_text() {
|
||||
Ok(v) => v,
|
||||
@@ -663,6 +794,112 @@ impl QftApp {
|
||||
};
|
||||
}
|
||||
|
||||
fn start_sender(&mut self, ctx: &egui::Context) {
|
||||
let Some(file) = self.send.file.clone() else { return };
|
||||
let Some(sha256) = self.send.sha256.clone() else { return };
|
||||
let file_name = file.file_name().and_then(|v| v.to_str()).unwrap_or("qft-download.bin").to_owned();
|
||||
self.stop_sender();
|
||||
self.send.status = "正在初始化电脑发送服务…".into();
|
||||
let token = pairing::new_session_token();
|
||||
let (tx, rx) = mpsc::channel();
|
||||
let server = match SenderServer::start(file, token.clone(), tx) {
|
||||
Ok(v) => v,
|
||||
Err(e) => { self.send.status = format!("发送服务启动失败:{e:#}"); return; }
|
||||
};
|
||||
|
||||
let mut direct_ap = None;
|
||||
let wifi = if self.send.use_direct_ap {
|
||||
let (ssid, passphrase) = match pairing::load_or_create_direct_ap_credentials(&self.local_device) {
|
||||
Ok(v) => v,
|
||||
Err(e) => {
|
||||
drop(server);
|
||||
self.send.status = format!("读取 QFT Direct 配网身份失败:{e:#}");
|
||||
return;
|
||||
}
|
||||
};
|
||||
match direct_ap::DirectAp::start(ssid.clone(), passphrase.clone()) {
|
||||
Ok(ap) => {
|
||||
direct_ap = Some(ap);
|
||||
Some(WifiCredentials { ssid, passphrase, security: "WPA2".into() })
|
||||
}
|
||||
Err(e) => {
|
||||
drop(server);
|
||||
self.send.status = format!("QFT Direct 启动失败:{e:#}\n可切换到“当前局域网”备用模式。");
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else { None };
|
||||
|
||||
if direct_ap.is_some() { std::thread::sleep(Duration::from_millis(250)); }
|
||||
let payload = PairingPayload {
|
||||
v: 2,
|
||||
session: token.clone(),
|
||||
pc_name: self.local_device.clone(),
|
||||
transport: "http-download-v2".into(),
|
||||
port: server.port,
|
||||
endpoints: pairing::local_ipv4_endpoints(server.port),
|
||||
wifi,
|
||||
direction: PairingDirection::Download,
|
||||
file_name: Some(file_name),
|
||||
file_size: Some(self.send.file_size),
|
||||
sha256: Some(sha256),
|
||||
};
|
||||
let pair_text = match payload.encode_text() {
|
||||
Ok(v) => v,
|
||||
Err(e) => { self.send.status = format!("发送二维码信息生成失败:{e:#}"); return; }
|
||||
};
|
||||
let image = match qr::render_pair_qr(&pair_text, 520) {
|
||||
Ok(v) => v,
|
||||
Err(e) => { self.send.status = format!("发送二维码生成失败:{e:#}"); return; }
|
||||
};
|
||||
let port = server.port;
|
||||
self.send.server = Some(server);
|
||||
self.send.direct_ap = direct_ap;
|
||||
self.send.events = Some(rx);
|
||||
self.send.pair_texture = Some(ctx.load_texture("qft-send-code", image, TextureOptions::NEAREST));
|
||||
self.send.session_token = token;
|
||||
self.send.connected_device = "等待 Android 扫码".into();
|
||||
self.send.status = if self.send.use_direct_ap {
|
||||
format!("直传已就绪 · TCP {port} · 手机扫码后会自动配网并开始下载。")
|
||||
} else {
|
||||
format!("直传已就绪 · TCP {port} · 请让手机扫码并使用当前局域网。")
|
||||
};
|
||||
}
|
||||
|
||||
fn stop_sender(&mut self) {
|
||||
self.send.events = None;
|
||||
self.send.server = None;
|
||||
self.send.direct_ap = None;
|
||||
self.send.pair_texture = None;
|
||||
self.send.session_token.clear();
|
||||
self.send.connected_device = "等待 Android 扫码".into();
|
||||
self.send.status = "直传已停止。".into();
|
||||
}
|
||||
|
||||
fn poll_sender_events(&mut self) {
|
||||
let mut pending = Vec::new();
|
||||
if let Some(rx) = &self.send.events {
|
||||
while let Ok(event) = rx.try_recv() { pending.push(event); }
|
||||
}
|
||||
for event in pending {
|
||||
match event {
|
||||
SenderEvent::ClientConnected { device } => {
|
||||
self.send.connected_device = device;
|
||||
self.send.status = "Android 已确认本次二维码会话,正在准备下载。".into();
|
||||
}
|
||||
SenderEvent::DownloadStarted { device, file_name, size } => {
|
||||
self.send.connected_device = device;
|
||||
self.send.status = format!("正在发送 {file_name} · {}", human_bytes(size));
|
||||
}
|
||||
SenderEvent::DownloadCompleted { device, file_name } => {
|
||||
self.send.connected_device = device;
|
||||
self.send.status = format!("发送完成:{file_name} 已由手机保存到 Downloads/QFT。");
|
||||
}
|
||||
SenderEvent::Error(message) => self.send.status = message,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn stop_receiver(&mut self) {
|
||||
self.receive.events = None;
|
||||
self.receive.server = None;
|
||||
@@ -737,6 +974,7 @@ impl eframe::App for QftApp {
|
||||
Screen::Home => self.home_ui(ui),
|
||||
Screen::OpticalSend => self.optical_ui(ui, &ctx),
|
||||
Screen::PhoneToPc => self.receive_ui(ui, &ctx),
|
||||
Screen::PcToPhone => self.pc_to_phone_ui(ui, &ctx),
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
+54
-3
@@ -2,7 +2,7 @@ use anyhow::{Context, Result};
|
||||
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
|
||||
use rand::RngCore;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::json;
|
||||
use serde_json::{json, Value};
|
||||
use std::{
|
||||
fs,
|
||||
net::{IpAddr, Ipv4Addr},
|
||||
@@ -10,6 +10,7 @@ use std::{
|
||||
};
|
||||
|
||||
pub const PAIR_PREFIX: &str = "QFTPAIR2:";
|
||||
pub const SEND_PREFIX: &str = "QFTSEND2:";
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct PairingPayload {
|
||||
@@ -20,6 +21,18 @@ pub struct PairingPayload {
|
||||
pub port: u16,
|
||||
pub endpoints: Vec<String>,
|
||||
pub wifi: Option<WifiCredentials>,
|
||||
/// `upload` means Android uploads to this PC. `download` means the PC has
|
||||
/// selected a file and Android downloads it immediately after pairing.
|
||||
pub direction: PairingDirection,
|
||||
pub file_name: Option<String>,
|
||||
pub file_size: Option<u64>,
|
||||
pub sha256: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub enum PairingDirection {
|
||||
Upload,
|
||||
Download,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
@@ -51,7 +64,7 @@ impl PairingPayload {
|
||||
self.endpoints.iter().take(3).map(String::as_str).collect()
|
||||
};
|
||||
let wifi = self.wifi.as_ref().map(|w| json!([w.ssid, w.passphrase]));
|
||||
let value = json!({
|
||||
let mut value = json!({
|
||||
"v": 2,
|
||||
"s": self.session,
|
||||
"n": self.pc_name,
|
||||
@@ -59,8 +72,21 @@ impl PairingPayload {
|
||||
"e": endpoints,
|
||||
"w": wifi,
|
||||
});
|
||||
// Keep the common Android → PC QR as small as before. File metadata is
|
||||
// needed only for the new PC → Android automatic-download QR.
|
||||
if self.direction == PairingDirection::Download {
|
||||
let object = value.as_object_mut().expect("pairing JSON object");
|
||||
object.insert("d".into(), Value::String("d".into()));
|
||||
object.insert("f".into(), serde_json::to_value(&self.file_name)?);
|
||||
object.insert("z".into(), serde_json::to_value(self.file_size)?);
|
||||
object.insert("h".into(), serde_json::to_value(&self.sha256)?);
|
||||
}
|
||||
let json = serde_json::to_vec(&value).context("serialize pairing payload")?;
|
||||
Ok(format!("{PAIR_PREFIX}{}", URL_SAFE_NO_PAD.encode(json)))
|
||||
let prefix = match self.direction {
|
||||
PairingDirection::Upload => PAIR_PREFIX,
|
||||
PairingDirection::Download => SEND_PREFIX,
|
||||
};
|
||||
Ok(format!("{prefix}{}", URL_SAFE_NO_PAD.encode(json)))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -176,3 +202,28 @@ pub fn local_ipv4_endpoints(port: u16) -> Vec<String> {
|
||||
.map(|ip| format!("http://{ip}:{port}"))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn download_pairing_uses_dedicated_short_prefix() {
|
||||
let payload = PairingPayload {
|
||||
v: 2,
|
||||
session: "abcdefghijklmnopqrstuvwxyz012345".into(),
|
||||
pc_name: "DESKTOP-QFT".into(),
|
||||
transport: "http-download-v2".into(),
|
||||
port: 39393,
|
||||
endpoints: vec!["http://192.168.49.1:39393".into()],
|
||||
wifi: None,
|
||||
direction: PairingDirection::Download,
|
||||
file_name: Some("sample.bin".into()),
|
||||
file_size: Some(42),
|
||||
sha256: Some("00".repeat(32)),
|
||||
};
|
||||
let text = payload.encode_text().unwrap();
|
||||
assert!(text.starts_with(SEND_PREFIX));
|
||||
assert!(text.len() < 800);
|
||||
}
|
||||
}
|
||||
|
||||
+46
-12
@@ -46,6 +46,13 @@ struct UploadSession {
|
||||
}
|
||||
|
||||
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,
|
||||
@@ -65,23 +72,31 @@ impl ReceiverServer {
|
||||
|
||||
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()));
|
||||
|
||||
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 tcp_thread = thread::spawn(move || {
|
||||
while !stop_tcp.load(Ordering::Relaxed) {
|
||||
match listener.accept() {
|
||||
Ok((stream, _)) => {
|
||||
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();
|
||||
thread::spawn(move || {
|
||||
if let Err(e) = handle_client(stream, &dir, &token, &tx, &sessions) {
|
||||
let _ = tx.send(ReceiverEvent::Error(format!("接收失败:{e:#}")));
|
||||
if let Err(e) = handle_client(&mut stream, &dir, &token, &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));
|
||||
}
|
||||
});
|
||||
}
|
||||
@@ -147,11 +162,12 @@ impl Drop for ReceiverServer {
|
||||
}
|
||||
|
||||
fn handle_client(
|
||||
mut stream: TcpStream,
|
||||
stream: &mut TcpStream,
|
||||
save_dir: &Path,
|
||||
token: &str,
|
||||
events: &Sender<ReceiverEvent>,
|
||||
sessions: &SessionMap,
|
||||
completed: &CompletedMap,
|
||||
) -> Result<()> {
|
||||
stream.set_nodelay(true).ok();
|
||||
stream.set_read_timeout(Some(Duration::from_secs(120)))?;
|
||||
@@ -180,7 +196,7 @@ fn handle_client(
|
||||
|
||||
let supplied = headers.get("x-qft-token").map(String::as_str).unwrap_or("");
|
||||
if supplied != token {
|
||||
return write_response(&mut stream, 403, "text/plain", b"invalid session");
|
||||
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());
|
||||
@@ -188,27 +204,27 @@ fn handle_client(
|
||||
|
||||
if method == "GET" && path == "/qft/ping" {
|
||||
let body = json!({"ok": true, "protocol": 2, "parallel": true}).to_string();
|
||||
return write_response(&mut stream, 200, "application/json", body.as_bytes());
|
||||
return write_response(stream, 200, "application/json", body.as_bytes());
|
||||
}
|
||||
|
||||
if method == "POST" && path == "/qft/upload/init" {
|
||||
return init_parallel_upload(&mut stream, save_dir, &headers, &device, events, sessions);
|
||||
return init_parallel_upload(stream, save_dir, &headers, &device, events, sessions);
|
||||
}
|
||||
|
||||
if method == "POST" && path.starts_with("/qft/upload/chunk/") {
|
||||
return receive_parallel_chunk(&mut stream, &mut reader, path, &headers, events, sessions);
|
||||
return receive_parallel_chunk(stream, &mut reader, path, &headers, events, sessions);
|
||||
}
|
||||
|
||||
if method == "POST" && path.starts_with("/qft/upload/finish/") {
|
||||
return finish_parallel_upload(&mut stream, path, events, sessions);
|
||||
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(&mut stream, &mut reader, save_dir, &headers, &device, events);
|
||||
return receive_legacy_stream(stream, &mut reader, save_dir, &headers, &device, events);
|
||||
}
|
||||
|
||||
write_response(&mut stream, 404, "text/plain", b"not found")
|
||||
write_response(stream, 404, "text/plain", b"not found")
|
||||
}
|
||||
|
||||
fn init_parallel_upload(
|
||||
@@ -336,12 +352,24 @@ fn finish_parallel_upload(
|
||||
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().context("上传会话不存在或已完成")?
|
||||
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!("上传会话损坏"))?;
|
||||
@@ -363,6 +391,12 @@ fn finish_parallel_upload(
|
||||
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(),
|
||||
});
|
||||
|
||||
@@ -0,0 +1,290 @@
|
||||
use anyhow::{bail, Context, Result};
|
||||
use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine as _};
|
||||
use serde_json::json;
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
fs::File,
|
||||
io::{BufRead, BufReader, Read, Write},
|
||||
net::{TcpListener, TcpStream, UdpSocket},
|
||||
path::PathBuf,
|
||||
sync::{
|
||||
atomic::{AtomicBool, Ordering},
|
||||
mpsc::Sender,
|
||||
Arc,
|
||||
},
|
||||
thread::{self, JoinHandle},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
pub const PREFERRED_PORT: u16 = 39393;
|
||||
pub const DISCOVERY_PORT: u16 = 39392;
|
||||
const IO_BUFFER: usize = 1024 * 1024;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub enum SenderEvent {
|
||||
ClientConnected { device: String },
|
||||
DownloadStarted { device: String, file_name: String, size: u64 },
|
||||
DownloadCompleted { device: String, file_name: String },
|
||||
Error(String),
|
||||
}
|
||||
|
||||
/// A short-lived, token-protected local HTTP server for PC → Android transfer.
|
||||
/// The actual file remains on disk and is streamed only after a phone scans the
|
||||
/// QFTSEND2 QR, joins the advertised local network, and presents that token.
|
||||
pub struct SenderServer {
|
||||
pub port: u16,
|
||||
stop: Arc<AtomicBool>,
|
||||
tcp_thread: Option<JoinHandle<()>>,
|
||||
udp_thread: Option<JoinHandle<()>>,
|
||||
}
|
||||
|
||||
impl SenderServer {
|
||||
pub fn start(file_path: PathBuf, session_token: String, events: Sender<SenderEvent>) -> Result<Self> {
|
||||
let file_name = file_path.file_name()
|
||||
.and_then(|v| v.to_str())
|
||||
.filter(|v| !v.is_empty())
|
||||
.unwrap_or("qft-download.bin")
|
||||
.to_owned();
|
||||
let size = std::fs::metadata(&file_path)
|
||||
.with_context(|| format!("读取发送文件 {} 失败", file_path.display()))?
|
||||
.len();
|
||||
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 tcp_stop = stop.clone();
|
||||
let tcp_token = session_token.clone();
|
||||
let tcp_events = events.clone();
|
||||
let tcp_thread = thread::spawn(move || {
|
||||
while !tcp_stop.load(Ordering::Relaxed) {
|
||||
match listener.accept() {
|
||||
Ok((mut stream, _)) => {
|
||||
let token = tcp_token.clone();
|
||||
let path = file_path.clone();
|
||||
let name = file_name.clone();
|
||||
let tx = tcp_events.clone();
|
||||
thread::spawn(move || {
|
||||
if let Err(e) = handle_client(&mut stream, &path, &name, size, &token, &tx) {
|
||||
let message = format!("向手机发送失败:{e:#}");
|
||||
let _ = write_response(&mut stream, 500, "text/plain", message.as_bytes());
|
||||
let _ = tx.send(SenderEvent::Error(message));
|
||||
}
|
||||
});
|
||||
}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => thread::sleep(Duration::from_millis(12)),
|
||||
Err(e) => {
|
||||
let _ = tcp_events.send(SenderEvent::Error(format!("发送端口监听失败:{e}")));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let udp_stop = stop.clone();
|
||||
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(SenderEvent::Error(format!("快速发现端口 {DISCOVERY_PORT} 不可用:{e}")));
|
||||
return;
|
||||
}
|
||||
};
|
||||
let _ = socket.set_read_timeout(Some(Duration::from_millis(250)));
|
||||
let expected = format!("QFTDISC2:{session_token}");
|
||||
let response = format!("QFTHERE2:{session_token}:{port}");
|
||||
let mut buf = [0u8; 512];
|
||||
while !udp_stop.load(Ordering::Relaxed) {
|
||||
match socket.recv_from(&mut buf) {
|
||||
Ok((n, peer)) if std::str::from_utf8(&buf[..n]).ok() == Some(expected.as_str()) => {
|
||||
let _ = socket.send_to(response.as_bytes(), peer);
|
||||
}
|
||||
Ok(_) => {}
|
||||
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), udp_thread: Some(udp_thread) })
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for SenderServer {
|
||||
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(); }
|
||||
}
|
||||
}
|
||||
|
||||
fn handle_client(
|
||||
stream: &mut TcpStream,
|
||||
file_path: &PathBuf,
|
||||
file_name: &str,
|
||||
size: u64,
|
||||
token: &str,
|
||||
events: &Sender<SenderEvent>,
|
||||
) -> Result<()> {
|
||||
stream.set_nodelay(true).ok();
|
||||
stream.set_read_timeout(Some(Duration::from_secs(20)))?;
|
||||
stream.set_write_timeout(Some(Duration::from_secs(120)))?;
|
||||
let cloned = stream.try_clone()?;
|
||||
let mut reader = BufReader::with_capacity(32 * 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 headers.get("x-qft-token").map(String::as_str).unwrap_or("") != 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(SenderEvent::ClientConnected { device: device.clone() });
|
||||
if method == "GET" && path == "/qft/ping" {
|
||||
let body = json!({"ok": true, "protocol": 2, "direction": "download"}).to_string();
|
||||
return write_response(stream, 200, "application/json", body.as_bytes());
|
||||
}
|
||||
if method != "GET" || path != "/qft/download" {
|
||||
return write_response(stream, 404, "text/plain", b"not found");
|
||||
}
|
||||
|
||||
let mut input = File::open(file_path)
|
||||
.with_context(|| format!("发送文件已不可读取:{}", file_path.display()))?;
|
||||
if input.metadata()?.len() != size {
|
||||
bail!("发送文件在二维码生成后发生变化,请重新选择文件并生成二维码")
|
||||
}
|
||||
let offset = parse_range_start(headers.get("range"), size)?;
|
||||
let remaining = size.saturating_sub(offset);
|
||||
let _ = events.send(SenderEvent::DownloadStarted { device: device.clone(), file_name: file_name.to_owned(), size });
|
||||
if offset == 0 {
|
||||
write!(stream,
|
||||
"HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nAccept-Ranges: bytes\r\nConnection: close\r\nX-QFT-Filename: {}\r\n\r\n",
|
||||
URL_SAFE_NO_PAD.encode(file_name.as_bytes()),
|
||||
)?;
|
||||
} else {
|
||||
write!(stream,
|
||||
"HTTP/1.1 206 Partial Content\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nContent-Range: bytes {offset}-{}/{}\r\nAccept-Ranges: bytes\r\nConnection: close\r\nX-QFT-Filename: {}\r\n\r\n",
|
||||
size - 1,
|
||||
size,
|
||||
URL_SAFE_NO_PAD.encode(file_name.as_bytes()),
|
||||
)?;
|
||||
}
|
||||
use std::io::{Seek, SeekFrom};
|
||||
input.seek(SeekFrom::Start(offset))?;
|
||||
let mut buf = vec![0u8; IO_BUFFER];
|
||||
loop {
|
||||
let n = input.read(&mut buf)?;
|
||||
if n == 0 { break }
|
||||
stream.write_all(&buf[..n])?;
|
||||
}
|
||||
stream.flush()?;
|
||||
let _ = events.send(SenderEvent::DownloadCompleted { device, file_name: file_name.to_owned() });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_response(stream: &mut TcpStream, code: u16, content_type: &str, body: &[u8]) -> Result<()> {
|
||||
let reason = match code { 200 => "OK", 403 => "Forbidden", 404 => "Not Found", _ => "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 bytes = URL_SAFE_NO_PAD.decode(value?).ok()?;
|
||||
String::from_utf8(bytes).ok()
|
||||
}
|
||||
|
||||
fn parse_range_start(value: Option<&String>, size: u64) -> Result<u64> {
|
||||
let Some(value) = value else { return Ok(0) };
|
||||
let suffix = value.trim().strip_prefix("bytes=").context("Range 格式无效")?;
|
||||
let start = suffix.strip_suffix('-').context("只支持单段 Range")?
|
||||
.parse::<u64>().context("Range 起点无效")?;
|
||||
if start >= size { bail!("Range 超出文件范围") }
|
||||
Ok(start)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::{handle_client, parse_range_start, SenderEvent};
|
||||
use std::{
|
||||
fs,
|
||||
io::{Read, Write},
|
||||
net::{TcpListener, TcpStream},
|
||||
sync::mpsc,
|
||||
thread,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn accepts_only_a_valid_resumable_byte_range() {
|
||||
assert_eq!(parse_range_start(None, 10).unwrap(), 0);
|
||||
assert_eq!(parse_range_start(Some(&"bytes=4-".to_owned()), 10).unwrap(), 4);
|
||||
assert!(parse_range_start(Some(&"bytes=10-".to_owned()), 10).is_err());
|
||||
assert!(parse_range_start(Some(&"bytes=-4".to_owned()), 10).is_err());
|
||||
assert!(parse_range_start(Some(&"items=4-".to_owned()), 10).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn download_endpoint_returns_the_requested_range() {
|
||||
let path = std::env::temp_dir().join(format!("qft-sender-{}-range.bin", std::process::id()));
|
||||
fs::write(&path, b"abcdef").unwrap();
|
||||
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
|
||||
let address = listener.local_addr().unwrap();
|
||||
let (events, _receiver) = mpsc::channel::<SenderEvent>();
|
||||
let path_for_server = path.clone();
|
||||
let server = thread::spawn(move || {
|
||||
for _ in 0..2 {
|
||||
let (mut stream, _) = listener.accept().unwrap();
|
||||
handle_client(&mut stream, &path_for_server, "range.bin", 6, "session", &events).unwrap();
|
||||
}
|
||||
});
|
||||
|
||||
let full = request(address, None);
|
||||
assert_response(&full, "HTTP/1.1 200 OK", "abcdef");
|
||||
let resumed = request(address, Some("bytes=2-"));
|
||||
assert_response(&resumed, "HTTP/1.1 206 Partial Content", "cdef");
|
||||
let header = String::from_utf8_lossy(&resumed[..header_end(&resumed)]);
|
||||
assert!(header.contains("Content-Range: bytes 2-5/6"));
|
||||
|
||||
server.join().unwrap();
|
||||
fs::remove_file(path).unwrap();
|
||||
}
|
||||
|
||||
fn request(address: std::net::SocketAddr, range: Option<&str>) -> Vec<u8> {
|
||||
let mut stream = TcpStream::connect(address).unwrap();
|
||||
write!(
|
||||
stream,
|
||||
"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\n{}\r\n",
|
||||
range.map(|v| format!("Range: {v}\r\n")).unwrap_or_default(),
|
||||
).unwrap();
|
||||
stream.flush().unwrap();
|
||||
let mut bytes = Vec::new();
|
||||
stream.read_to_end(&mut bytes).unwrap();
|
||||
bytes
|
||||
}
|
||||
|
||||
fn assert_response(response: &[u8], status: &str, body: &str) {
|
||||
let end = header_end(response);
|
||||
assert!(String::from_utf8_lossy(&response[..end]).starts_with(status));
|
||||
assert_eq!(&response[end..], body.as_bytes());
|
||||
}
|
||||
|
||||
fn header_end(bytes: &[u8]) -> usize {
|
||||
bytes.windows(4).position(|v| v == b"\r\n\r\n").unwrap() + 4
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user