Files
QFT/windows/src/sender.rs
T

291 lines
12 KiB
Rust

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
}
}