317 lines
13 KiB
Rust
317 lines
13 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 range = parse_range(headers.get("range"), size)?;
|
|
let offset = range.start;
|
|
let end = range.end;
|
|
let remaining = if size == 0 { 0 } else { end.saturating_sub(offset).saturating_add(1) };
|
|
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",
|
|
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",
|
|
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];
|
|
let mut left = remaining;
|
|
while left > 0 {
|
|
let want = left.min(buf.len() as u64) as usize;
|
|
let n = input.read(&mut buf[..want])?;
|
|
if n == 0 { break }
|
|
stream.write_all(&buf[..n])?;
|
|
left -= n as u64;
|
|
}
|
|
if left != 0 { bail!("发送文件读取提前结束:还缺 {left} 字节") }
|
|
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()
|
|
}
|
|
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
|
struct ByteRange {
|
|
start: u64,
|
|
end: u64,
|
|
}
|
|
|
|
fn parse_range(value: Option<&String>, size: u64) -> Result<ByteRange> {
|
|
if size == 0 {
|
|
if value.is_some() { bail!("空文件没有可下载的字节范围") }
|
|
return Ok(ByteRange { start: 0, end: 0 });
|
|
}
|
|
let Some(value) = value else { return Ok(ByteRange { start: 0, end: size - 1 }) };
|
|
let suffix = value.trim().strip_prefix("bytes=").context("Range 格式无效")?;
|
|
let (start_text, end_text) = suffix.split_once('-').context("Range 格式无效")?;
|
|
if start_text.is_empty() { bail!("不支持后缀 Range") }
|
|
let start = start_text.parse::<u64>().context("Range 起点无效")?;
|
|
let end = if end_text.is_empty() {
|
|
size - 1
|
|
} else {
|
|
end_text.parse::<u64>().context("Range 终点无效")?
|
|
};
|
|
if start >= size || end >= size || end < start { bail!("Range 超出文件范围") }
|
|
Ok(ByteRange { start, end })
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::{handle_client, parse_range, ByteRange, SenderEvent};
|
|
use std::{
|
|
fs,
|
|
io::{Read, Write},
|
|
net::{TcpListener, TcpStream},
|
|
sync::mpsc,
|
|
thread,
|
|
};
|
|
|
|
#[test]
|
|
fn accepts_open_and_bounded_byte_ranges() {
|
|
assert_eq!(parse_range(None, 10).unwrap(), ByteRange { start: 0, end: 9 });
|
|
assert_eq!(parse_range(None, 0).unwrap(), ByteRange { start: 0, end: 0 });
|
|
assert_eq!(parse_range(Some(&"bytes=4-".to_owned()), 10).unwrap(), ByteRange { start: 4, end: 9 });
|
|
assert_eq!(parse_range(Some(&"bytes=2-6".to_owned()), 10).unwrap(), ByteRange { start: 2, end: 6 });
|
|
assert!(parse_range(Some(&"bytes=10-".to_owned()), 10).is_err());
|
|
assert!(parse_range(Some(&"bytes=6-2".to_owned()), 10).is_err());
|
|
assert!(parse_range(Some(&"bytes=-4".to_owned()), 10).is_err());
|
|
assert!(parse_range(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..3 {
|
|
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"));
|
|
let bounded = request(address, Some("bytes=1-3"));
|
|
assert_response(&bounded, "HTTP/1.1 206 Partial Content", "bcd");
|
|
|
|
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
|
|
}
|
|
}
|