diff --git a/desktop/src/sender.rs b/desktop/src/sender.rs index 6c05021..b3452b7 100644 --- a/desktop/src/sender.rs +++ b/desktop/src/sender.rs @@ -138,14 +138,47 @@ fn handle_client( stream.set_write_timeout(Some(Duration::from_secs(120)))?; let cloned = stream.try_clone()?; let mut reader = BufReader::with_capacity(32 * 1024, cloned); + + // 同一条连接上循环处理请求。此前每个响应都写死 Connection: close, + // 于是并行下载的每个分块都要新建一次 TCP —— 1 GB 是 64 次, + // 10 GB 是 640 次,既慢又是"短连接频繁断开"的直接来源。 + loop { + match serve_one(stream, &mut reader, file_path, file_name, size, token, events)? { + KeepAlive::Continue => {} + KeepAlive::Close => return Ok(()), + } + } +} + +/// 单个请求的处理结果:是否可以在同一条连接上继续。 +enum KeepAlive { + Continue, + Close, +} + +fn serve_one( + stream: &mut TcpStream, + reader: &mut BufReader, + file_path: &PathBuf, + file_name: &str, + size: u64, + token: &str, + events: &Sender, +) -> Result { let mut request_line = String::new(); - reader.read_line(&mut request_line)?; + // 读到 0 字节说明对端正常关闭了连接,这是 keep-alive 下的常态,不是错误 + if reader.read_line(&mut request_line)? == 0 { + return Ok(KeepAlive::Close); + } + if request_line.trim().is_empty() { + return Ok(KeepAlive::Close); + } 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 n == 0 { return Ok(KeepAlive::Close) } if line == "\r\n" || line == "\n" { break } if line.len() > 16 * 1024 { bail!("请求头过长") } if let Some((k, v)) = line.split_once(':') { @@ -155,17 +188,29 @@ fn handle_client( let mut parts = request_line.split_whitespace(); let method = parts.next().unwrap_or(""); let path = parts.next().unwrap_or(""); + let version = parts.next().unwrap_or("HTTP/1.1"); + // HTTP/1.1 默认复用;客户端显式要求 close 或用 1.0 时才断开 + let keep_alive = version.eq_ignore_ascii_case("HTTP/1.1") + && !headers + .get("connection") + .map(|v| v.eq_ignore_ascii_case("close")) + .unwrap_or(false); + let connection_header = if keep_alive { "keep-alive" } else { "close" }; + if headers.get("x-qft-token").map(String::as_str).unwrap_or("") != token { - return write_response(stream, 403, "text/plain", b"invalid session"); + write_response(stream, 403, "text/plain", b"invalid session")?; + return Ok(KeepAlive::Close); } 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()); + write_response(stream, 200, "application/json", body.as_bytes())?; + return Ok(if keep_alive { KeepAlive::Continue } else { KeepAlive::Close }); } if method != "GET" || path != "/qft/download" { - return write_response(stream, 404, "text/plain", b"not found"); + write_response(stream, 404, "text/plain", b"not found")?; + return Ok(KeepAlive::Close); } let mut input = File::open(file_path) @@ -180,12 +225,12 @@ fn handle_client( let _ = events.send(SenderEvent::DownloadStarted { device: device.clone(), file_name: file_name.to_owned(), size }); if headers.get("range").is_none() { 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", + "HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nAccept-Ranges: bytes\r\nConnection: {connection_header}\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}-{end}/{}\r\nAccept-Ranges: bytes\r\nConnection: close\r\nX-QFT-Filename: {}\r\n\r\n", + "HTTP/1.1 206 Partial Content\r\nContent-Type: application/octet-stream\r\nContent-Length: {remaining}\r\nContent-Range: bytes {offset}-{end}/{}\r\nAccept-Ranges: bytes\r\nConnection: {connection_header}\r\nX-QFT-Filename: {}\r\n\r\n", size, URL_SAFE_NO_PAD.encode(file_name.as_bytes()), )?; @@ -203,7 +248,7 @@ fn handle_client( } stream.flush()?; let _ = events.send(SenderEvent::DownloadCompleted { device, file_name: file_name.to_owned() }); - Ok(()) + Ok(if keep_alive { KeepAlive::Continue } else { KeepAlive::Close }) } fn write_response(stream: &mut TcpStream, code: u16, content_type: &str, body: &[u8]) -> Result<()> { @@ -328,7 +373,7 @@ mod tests { let mut client = TcpStream::connect(address).unwrap(); client.write_all( - b"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\n\r\n", + b"GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\nConnection: close\r\n\r\n", ).unwrap(); client.flush().unwrap(); thread::sleep(Duration::from_millis(50)); @@ -346,7 +391,7 @@ mod tests { 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", + "GET /qft/download HTTP/1.1\r\nHost: localhost\r\nX-QFT-Token: session\r\nConnection: close\r\n{}\r\n", range.map(|v| format!("Range: {v}\r\n")).unwrap_or_default(), ).unwrap(); stream.flush().unwrap(); @@ -365,3 +410,85 @@ mod tests { bytes.windows(4).position(|v| v == b"\r\n\r\n").unwrap() + 4 } } + +#[cfg(test)] +mod keep_alive_tests { + use super::{handle_client, SenderEvent}; + use std::{ + fs, + io::{BufRead, BufReader, Read, Write}, + net::{TcpListener, TcpStream}, + sync::mpsc, + thread, + }; + + /// 在**同一条** TCP 上连发多个 Range 请求,全部必须成功。 + /// + /// 此前每个响应都写死 Connection: close,并行下载的每个分块都要 + /// 重建一次 TCP —— 1 GB 64 次、10 GB 640 次,既是"短连接频繁断开" + /// 的来源,也白白付出握手与慢启动的代价。 + #[test] + fn serves_multiple_ranges_on_one_connection() { + let path = std::env::temp_dir().join(format!("qft-keepalive-{}.bin", std::process::id())); + let payload: Vec = (0..4096u32).map(|i| (i % 251) as u8).collect(); + fs::write(&path, &payload).unwrap(); + + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap(); + let (events, _rx) = mpsc::channel::(); + let served = path.clone(); + let server = thread::spawn(move || { + let (mut stream, _) = listener.accept().unwrap(); + handle_client(&mut stream, &served, "p.bin", payload.len() as u64, "tok", &events) + }); + + let mut stream = TcpStream::connect(address).unwrap(); + let mut reader = BufReader::new(stream.try_clone().unwrap()); + + // 三段互不重叠的 Range,全部走同一条连接 + for (start, end) in [(0u64, 1023u64), (1024, 2047), (2048, 4095)] { + write!( + stream, + "GET /qft/download HTTP/1.1\r\nHost: x\r\nX-QFT-Token: tok\r\nRange: bytes={start}-{end}\r\n\r\n" + ).unwrap(); + stream.flush().unwrap(); + + let mut status = String::new(); + reader.read_line(&mut status).unwrap(); + assert!(status.starts_with("HTTP/1.1 206"), "第 {start} 段状态行:{status}"); + + let mut length = 0usize; + let mut keep_alive = false; + loop { + let mut line = String::new(); + reader.read_line(&mut line).unwrap(); + if line == "\r\n" { break } + if let Some((name, value)) = line.split_once(':') { + match name.trim().to_ascii_lowercase().as_str() { + "content-length" => length = value.trim().parse().unwrap(), + "connection" => keep_alive = value.trim().eq_ignore_ascii_case("keep-alive"), + _ => {} + } + } + } + assert!(keep_alive, "响应必须声明 keep-alive,否则客户端会关掉连接"); + assert_eq!(length as u64, end - start + 1, "Content-Length 应等于该段长度"); + + let mut body = vec![0u8; length]; + reader.read_exact(&mut body).unwrap(); + let expected: Vec = (start..=end).map(|i| ((i as u32) % 251) as u8).collect(); + assert_eq!(body, expected, "第 {start} 段内容不符"); + } + + // 显式要求关闭时应断开,服务端随之正常收尾 + write!(stream, "GET /qft/ping HTTP/1.1\r\nHost: x\r\nX-QFT-Token: tok\r\nConnection: close\r\n\r\n").unwrap(); + stream.flush().unwrap(); + let mut rest = Vec::new(); + reader.read_to_end(&mut rest).unwrap(); + let text = String::from_utf8_lossy(&rest); + assert!(text.contains("Connection: close"), "显式 close 时应回 close:{text}"); + + server.join().unwrap().unwrap(); + fs::remove_file(path).unwrap(); + } +}