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, tcp_thread: Option>, udp_thread: Option>, } impl SenderServer { pub fn start(file_path: PathBuf, session_token: String, events: Sender) -> Result { 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, ) -> 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::::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 { let bytes = URL_SAFE_NO_PAD.decode(value?).ok()?; String::from_utf8(bytes).ok() } fn parse_range_start(value: Option<&String>, size: u64) -> Result { 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::().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::(); 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 { 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 } }