From 58206b983fe2d17b17efbf01a3c662457c7ccda4 Mon Sep 17 00:00:00 2001 From: Erwan Leboucher Date: Mon, 27 Jul 2026 21:14:58 +0200 Subject: [PATCH] fix(media): serve media in full instead of honoring Range requests --- src-tauri/src/network/media_protocol.rs | 200 +----------------------- 1 file changed, 8 insertions(+), 192 deletions(-) diff --git a/src-tauri/src/network/media_protocol.rs b/src-tauri/src/network/media_protocol.rs index 29dd85b02..536e2344c 100644 --- a/src-tauri/src/network/media_protocol.rs +++ b/src-tauri/src/network/media_protocol.rs @@ -1,7 +1,7 @@ use std::{ collections::HashMap, fs, - io::{Read, Seek, SeekFrom}, + io::Read, path::{Path, PathBuf}, sync::{ atomic::{AtomicBool, Ordering}, @@ -48,7 +48,6 @@ const MAX_CONCURRENT_DOWNLOAD_REQUESTS: usize = 6; // may arrive first. `` never retries, so waiting beats answering 503. const SESSION_WAIT: Duration = Duration::from_secs(5); const MAX_CACHE_BYTES: u64 = 512 * 1024 * 1024; -const MAX_RANGE_CHUNK: u64 = 2 * 1024 * 1024; // Short: a 4xx stops being true once an unreachable remote server comes back. const NEGATIVE_CACHE_TTL: Duration = Duration::from_secs(600); const MAX_NEGATIVE_CACHE_ENTRIES: usize = 512; @@ -379,10 +378,9 @@ pub fn respond( .and_then(|value| value.to_str().ok()) .map(str::to_owned) }; - let range = header_value(header::RANGE); let origin = header_value(header::ORIGIN); tauri::async_runtime::spawn(async move { - let mut response = handle_request(&app, uri, range) + let mut response = handle_request(&app, uri) .await .unwrap_or_else(error_response); apply_cors_headers(&mut response, origin.as_deref()); @@ -393,7 +391,6 @@ pub fn respond( async fn handle_request( app: &AppHandle, uri: Uri, - range: Option, ) -> Result>, StatusCode> { let target = percent_encoding::percent_decode_str(uri.path().trim_start_matches('/')) .decode_utf8() @@ -429,16 +426,12 @@ async fn handle_request( let (content_type, in_memory_body, disk_path) = ensure_cached(&state, &session, &key, media_url, dir, temp_dir).await?; - match (range, in_memory_body) { - (Some(range_header), Some(body)) => { - Ok(serve_range_memory(&body, &content_type, &range_header)) - } - (Some(range_header), None) => serve_range(disk_path, content_type, range_header).await, - (None, Some(body)) => { + match in_memory_body { + Some(body) => { let vec_body = Arc::try_unwrap(body).unwrap_or_else(|b| (*b).clone()); Ok(ok_response(vec_body, &content_type)) } - (None, None) => Ok(ok_response(read_full(disk_path).await?, &content_type)), + None => Ok(ok_response(read_full(disk_path).await?, &content_type)), } } @@ -974,80 +967,6 @@ async fn read_full(body_path: PathBuf) -> Result, StatusCode> { .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) } -async fn serve_range( - body_path: PathBuf, - content_type: String, - range_header: String, -) -> Result>, StatusCode> { - tokio::task::spawn_blocking(move || { - let mut file = fs::File::open(&body_path).map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; - let total = file - .metadata() - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)? - .len(); - - let Some((start, end)) = parse_range(&range_header, total) else { - return Ok(range_not_satisfiable(total)); - }; - - let end = end.min(start + MAX_RANGE_CHUNK - 1); - let length = end - start + 1; - - let mut buf = vec![0_u8; length as usize]; - file.seek(SeekFrom::Start(start)) - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; - file.read_exact(&mut buf) - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?; - - Ok(partial_response(buf, &content_type, start, end, total)) - }) - .await - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)? -} - -// Serve a Range request from an in-memory body. Mirrors serve_range but slices -// the buffer instead of seeking. -fn serve_range_memory(body: &[u8], content_type: &str, range_header: &str) -> Response> { - let total = body.len() as u64; - let Some((start, end)) = parse_range(range_header, total) else { - return range_not_satisfiable(total); - }; - let end = end.min(start + MAX_RANGE_CHUNK - 1); - let buf = body[start as usize..=(end as usize)].to_vec(); - partial_response(buf, content_type, start, end, total) -} - -// First byte range of a `Range: bytes=...` header as inclusive (start, end); None → 416. -fn parse_range(header: &str, total: u64) -> Option<(u64, u64)> { - if total == 0 { - return None; - } - - let spec = header.strip_prefix("bytes=")?; - let (start_str, end_str) = spec.split(',').next()?.trim().split_once('-')?; - - let (start, end) = if start_str.is_empty() { - let suffix: u64 = end_str.parse().ok()?; - if suffix == 0 { - return None; - } - (total.saturating_sub(suffix), total - 1) - } else { - let start: u64 = start_str.parse().ok()?; - let end = if end_str.is_empty() { - total - 1 - } else { - end_str.parse::().ok()?.min(total - 1) - }; - (start, end) - }; - - if start > end || start >= total { - return None; - } - Some((start, end)) -} - // Trim oldest-first when the cache exceeds its byte budget. fn evict_directory_if_needed(dir: &Path, max_bytes: u64) { let Ok(entries) = fs::read_dir(dir) else { @@ -1083,8 +1002,8 @@ fn evict_directory_if_needed(dir: &Path, max_bytes: u64) { } } -// Shared 200/206 headers. Media is content-addressed and the URL is session-scoped, so -// it is safe to let the webview cache it as immutable and to advertise Range support. +// Shared response headers. Media is content-addressed and the URL is session-scoped, so +// it is safe to let the webview cache it as immutable. fn media_response_builder(status: StatusCode, content_type: &str) -> ResponseBuilder { let cache_control = if content_type == "application/octet-stream" { "no-store" @@ -1094,7 +1013,6 @@ fn media_response_builder(status: StatusCode, content_type: &str) -> ResponseBui Response::builder() .status(status) .header(header::CONTENT_TYPE, content_type) - .header(header::ACCEPT_RANGES, "bytes") .header(header::CACHE_CONTROL, cache_control) .header(header::X_CONTENT_TYPE_OPTIONS, "nosniff") .header( @@ -1111,32 +1029,6 @@ fn ok_response(body: Vec, content_type: &str) -> Response> { .expect("failed to build media response") } -fn partial_response( - body: Vec, - content_type: &str, - start: u64, - end: u64, - total: u64, -) -> Response> { - let content_length = body.len(); - media_response_builder(StatusCode::PARTIAL_CONTENT, content_type) - .header(header::CONTENT_LENGTH, content_length) - .header( - header::CONTENT_RANGE, - format!("bytes {start}-{end}/{total}"), - ) - .body(body) - .expect("failed to build partial media response") -} - -fn range_not_satisfiable(total: u64) -> Response> { - Response::builder() - .status(StatusCode::RANGE_NOT_SATISFIABLE) - .header(header::CONTENT_RANGE, format!("bytes */{total}")) - .body(Vec::new()) - .expect("failed to build range error response") -} - fn session_unavailable_response() -> Response> { Response::builder() .status(StatusCode::SERVICE_UNAVAILABLE) @@ -1181,10 +1073,7 @@ mod tests { use tauri::http::{header, StatusCode}; - use super::{ - cache_key, ok_response, parse_range, partial_response, serve_range_memory, - MediaSessionState, - }; + use super::{cache_key, ok_response, MediaSessionState}; #[test] fn cache_miss_gates_are_reused_and_expired_entries_are_cleaned() { @@ -1345,79 +1234,6 @@ mod tests { response.headers().get(header::CACHE_CONTROL).unwrap(), "private, max-age=31536000, immutable" ); - assert_eq!( - response.headers().get(header::ACCEPT_RANGES).unwrap(), - "bytes" - ); - } - - #[test] - fn parse_range_handles_the_common_forms() { - assert_eq!(parse_range("bytes=0-499", 1000), Some((0, 499))); - assert_eq!(parse_range("bytes=500-", 1000), Some((500, 999))); - assert_eq!(parse_range("bytes=0-", 1000), Some((0, 999))); - // End past the file is clamped to the last byte. - assert_eq!(parse_range("bytes=990-5000", 1000), Some((990, 999))); - // Suffix range: the last N bytes. - assert_eq!(parse_range("bytes=-200", 1000), Some((800, 999))); - } - - #[test] - fn parse_range_rejects_unsatisfiable_and_malformed() { - assert_eq!(parse_range("bytes=1000-1001", 1000), None); - assert_eq!(parse_range("bytes=500-400", 1000), None); - assert_eq!(parse_range("bytes=abc-def", 1000), None); - assert_eq!(parse_range("items=0-1", 1000), None); - assert_eq!(parse_range("bytes=0-0", 0), None); - } - - #[test] - fn partial_response_reports_the_served_range() { - let response = partial_response(vec![0_u8; 100], "video/mp4", 0, 99, 5000); - assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT); - assert_eq!( - response.headers().get(header::CONTENT_LENGTH).unwrap(), - "100" - ); - assert_eq!( - response.headers().get(header::CONTENT_RANGE).unwrap(), - "bytes 0-99/5000" - ); - assert_eq!( - response.headers().get(header::ACCEPT_RANGES).unwrap(), - "bytes" - ); - } - - #[test] - fn serve_range_memory_slices_the_in_memory_body() { - let body: Vec = (0..200u8).collect(); - let response = serve_range_memory(&body, "application/octet-stream", "bytes=10-19"); - assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT); - assert_eq!(response.body(), &body[10..=19]); - assert_eq!( - response.headers().get(header::CONTENT_RANGE).unwrap(), - "bytes 10-19/200" - ); - } - - #[test] - fn serve_range_memory_caps_at_max_range_chunk() { - let body = vec![7_u8; (super::MAX_RANGE_CHUNK * 2) as usize]; - let response = serve_range_memory(&body, "application/octet-stream", "bytes=0-"); - assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT); - assert_eq!(response.body().len() as u64, super::MAX_RANGE_CHUNK); - let total = super::MAX_RANGE_CHUNK * 2; - assert_eq!( - response.headers().get(header::CONTENT_RANGE).unwrap(), - &format!("bytes 0-{}/{total}", super::MAX_RANGE_CHUNK - 1) - ); - } - - #[test] - fn serve_range_memory_rejects_unsatisfiable_range() { - let response = serve_range_memory(&[], "application/octet-stream", "bytes=0-0"); - assert_eq!(response.status(), StatusCode::RANGE_NOT_SATISFIABLE); } #[test]