feat: 提交0.4加速版二维码直传与自动配网优化
This commit is contained in:
@@ -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