use std::io;
use crate::network::OutboundNetworkPolicy;
#[cfg(target_os = "linux")]
use std::os::unix::io::AsRawFd;
#[cfg(target_os = "linux")]
use tokio::io::{AsyncReadExt, AsyncWriteExt};
#[cfg(target_os = "linux")]
use tracing::debug;
#[cfg(target_os = "linux")]
use crate::util::zero_copy::splice_transfer;
#[cfg(target_os = "linux")]
use super::helpers::{
find_header_end, is_chunked, parse_content_length, parse_status_code, set_blocking,
write_all_at_offset,
};
#[cfg(target_os = "linux")]
const MAX_HEADER_SIZE: usize = 8 * 1024;
#[cfg(target_os = "linux")]
pub async fn try_splice_download(
url: &str,
offset: u64,
length: u64,
file: &std::fs::File,
file_offset: u64,
) -> io::Result<u64> {
try_splice_download_with_policy(
url,
offset,
length,
file,
file_offset,
&OutboundNetworkPolicy::direct(),
)
.await
}
#[cfg(target_os = "linux")]
pub async fn try_splice_download_with_policy(
url: &str,
offset: u64,
length: u64,
file: &std::fs::File,
file_offset: u64,
outbound_network_policy: &OutboundNetworkPolicy,
) -> io::Result<u64> {
if length == 0 {
return Ok(0);
}
let parsed = url::Url::parse(url)
.map_err(|e| io::Error::new(io::ErrorKind::InvalidInput, format!("invalid URL: {e}")))?;
if parsed.scheme() != "http" {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"splice requires plain HTTP (no HTTPS)",
));
}
let host = parsed
.host_str()
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "URL has no host"))?;
let port = parsed.port_or_known_default().unwrap_or(80);
let path = if parsed.path().is_empty() {
"/"
} else {
parsed.path()
};
let query = parsed.query().map(|q| format!("?{q}")).unwrap_or_default();
let path_query = format!("{path}{query}");
debug!(host, port, "splice_download: connecting");
let mut stream = outbound_network_policy
.connect_host(host, port)
.await
.map_err(|e| {
io::Error::new(
io::ErrorKind::ConnectionRefused,
format!("TCP connect failed: {e}"),
)
})?;
let _ = stream.set_nodelay(true);
let host_header = if port == 80 {
host.to_string()
} else {
format!("{host}:{port}")
};
let range_value = format!("bytes={}-{}", offset, offset + length.saturating_sub(1));
let request = format!(
"GET {path_query} HTTP/1.1\r\n\
Host: {host_header}\r\n\
Range: {range_value}\r\n\
Connection: close\r\n\
User-Agent: {}\r\n\
Accept: */*\r\n\
\r\n",
crate::constants::USER_AGENT,
);
stream.write_all(request.as_bytes()).await?;
debug!(range = %range_value, "splice_download: request sent");
let mut header_buf = vec![0u8; MAX_HEADER_SIZE];
let mut header_len = 0usize;
let header_end_pos = loop {
if header_len >= MAX_HEADER_SIZE {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"response headers exceed 8 KB",
));
}
let n = stream.read(&mut header_buf[header_len..]).await?;
if n == 0 {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
"connection closed before headers complete",
));
}
header_len += n;
if let Some(pos) = find_header_end(&header_buf[..header_len]) {
break pos;
}
};
let header_bytes = &header_buf[..header_end_pos];
let header_str = std::str::from_utf8(header_bytes).map_err(|e| {
io::Error::new(io::ErrorKind::InvalidData, format!("non-UTF8 headers: {e}"))
})?;
let status = parse_status_code(header_str)?;
if status != 206 {
return Err(io::Error::other(format!(
"expected 206 Partial Content, got {status}"
)));
}
if is_chunked(header_str) {
return Err(io::Error::new(
io::ErrorKind::Unsupported,
"chunked transfer encoding not supported by splice",
));
}
let content_length = parse_content_length(header_str)?
.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidData, "missing Content-Length"))?;
if content_length > length {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("Content-Length ({content_length}) exceeds requested length ({length})"),
));
}
let body_start = header_end_pos + 4; let pre_read = &header_buf[body_start..header_len];
let pre_read_len = pre_read.len() as u64;
if pre_read_len > content_length {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!(
"pre-read body bytes ({pre_read_len}) exceed Content-Length ({content_length})"
),
));
}
if pre_read_len > 0 {
write_all_at_offset(file, pre_read, file_offset)?;
}
let mut written = pre_read_len;
let remaining = content_length - pre_read_len;
if remaining > 0 {
let socket_fd = stream.as_raw_fd();
let file_fd = file.as_raw_fd();
let splice_file_offset = (file_offset + pre_read_len) as i64;
let splice_len = remaining as usize;
let splice_result = tokio::task::spawn_blocking(move || {
set_blocking(socket_fd);
splice_transfer(
socket_fd,
None,
file_fd,
Some(splice_file_offset),
splice_len,
)
})
.await
.map_err(|e| io::Error::other(format!("blocking task failed: {e}")))?
.map_err(|e| io::Error::other(format!("splice failed: {e}")))?;
let spliced = splice_result as u64;
if spliced < remaining {
return Err(io::Error::new(
io::ErrorKind::UnexpectedEof,
format!(
"splice EOF: transferred {} of {} body bytes (pre_read={}, spliced={})",
written + spliced,
content_length,
pre_read_len,
spliced
),
));
}
written += spliced;
}
debug!(
url,
bytes = written,
pre_read = pre_read_len,
spliced = written - pre_read_len,
"splice_download: complete"
);
Ok(written)
}
#[cfg(not(target_os = "linux"))]
pub async fn try_splice_download(
_url: &str,
_offset: u64,
_length: u64,
_file: &std::fs::File,
_file_offset: u64,
) -> io::Result<u64> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"splice not available on this platform",
))
}
#[cfg(not(target_os = "linux"))]
pub async fn try_splice_download_with_policy(
_url: &str,
_offset: u64,
_length: u64,
_file: &std::fs::File,
_file_offset: u64,
_outbound_network_policy: &OutboundNetworkPolicy,
) -> io::Result<u64> {
Err(io::Error::new(
io::ErrorKind::Unsupported,
"splice not available on this platform",
))
}