use std::path::{Component, Path};
use std::sync::Arc;
use bytes::Bytes;
use rustls::pki_types::ServerName;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio_rustls::TlsConnector;
use crate::error::{Error, Result};
use crate::session::Session;
use crate::torrent::TorrentInfo;
use crate::tracker::{http_body, is_blocked_ip, resolve_tracker_socket};
#[derive(Debug, Clone)]
struct FileByteRange {
relative: std::path::PathBuf,
start: u64,
end: u64,
}
pub async fn fetch_piece_from_web_seeds(
session: Arc<Session>,
piece: u32,
) -> Result<Vec<u8>> {
let urls = session.web_seeds();
if urls.is_empty() {
return Err(Error::Session("no web seeds configured".into()));
}
let info = session.info();
let piece_size = info.piece_size(piece) as usize;
let ranges = piece_file_ranges(info, piece)?;
let block_private = session.config().tracker_block_private;
let ftp_enabled = session.config().web_seed_ftp_enabled;
for base in urls {
match fetch_piece_from_base(base, info, &ranges, piece_size, block_private, ftp_enabled)
.await
{
Ok(data) if data.len() == piece_size => return Ok(data),
Ok(_) => {}
Err(err) => tracing::debug!(%err, %base, "web seed URL failed"),
}
}
Err(Error::Session(format!("web seed fetch failed for piece {piece}")))
}
async fn fetch_piece_from_base(
base: &str,
info: &TorrentInfo,
ranges: &[FileByteRange],
piece_size: usize,
block_private: bool,
ftp_enabled: bool,
) -> Result<Vec<u8>> {
let mut out = Vec::with_capacity(piece_size);
for range in ranges {
let url = webseed_url_for_file(base, info, &range.relative)?;
let chunk = fetch_range(&url, range.start, range.end, block_private, ftp_enabled).await?;
let expect = (range.end - range.start + 1) as usize;
if chunk.len() != expect {
return Err(Error::Session(format!(
"web seed returned {} bytes, expected {expect}",
chunk.len()
)));
}
out.extend_from_slice(&chunk);
}
Ok(out)
}
fn piece_file_ranges(info: &TorrentInfo, piece: u32) -> Result<Vec<FileByteRange>> {
let piece_len = info.piece_size(piece) as u64;
if piece_len == 0 {
return Err(Error::Session(format!("piece {piece} has zero length")));
}
let mut offset = piece as u64 * info.piece_length as u64;
let mut remaining = piece_len;
let mut cursor = 0u64;
let mut out = Vec::new();
for (relative, length) in &info.files {
if remaining == 0 {
break;
}
let file_end = cursor.saturating_add(*length);
if offset >= file_end {
cursor = file_end;
continue;
}
let file_start = offset.saturating_sub(cursor);
let take = remaining.min(file_end.saturating_sub(offset));
if take == 0 {
cursor = file_end;
continue;
}
out.push(FileByteRange {
relative: relative.clone(),
start: file_start,
end: file_start + take - 1,
});
offset = offset.saturating_add(take);
remaining = remaining.saturating_sub(take);
cursor = file_end;
}
if remaining != 0 || out.is_empty() {
return Err(Error::Session(format!(
"piece {piece} does not map onto torrent files"
)));
}
Ok(out)
}
pub fn webseed_url_for_file(base: &str, info: &TorrentInfo, file_rel: &Path) -> Result<String> {
if !base.ends_with('/') {
if !is_single_file(info) {
return Err(Error::Session(
"non-slash web seed URL is only valid for single-file torrents".into(),
));
}
return Ok(base.to_string());
}
let mut url = base.to_string();
url.push_str(&info.name);
if !is_single_file(info) {
let path = file_rel
.strip_prefix(&info.name)
.unwrap_or(file_rel);
for component in path.components() {
let Component::Normal(part) = component else {
continue;
};
let Some(text) = part.to_str() else {
return Err(Error::Session(
"web seed path component is not utf-8".into(),
));
};
url.push('/');
url.push_str(text);
}
}
Ok(url)
}
fn is_single_file(info: &TorrentInfo) -> bool {
info.files.len() == 1 && info.files[0].0.as_path() == Path::new(&info.name)
}
async fn fetch_range(
url: &str,
start: u64,
end: u64,
block_private: bool,
ftp_enabled: bool,
) -> Result<Vec<u8>> {
const IO_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(30);
let fut = async {
if let Some(rest) = url.strip_prefix("http://") {
fetch_http_range(rest, false, start, end, block_private).await
} else if let Some(rest) = url.strip_prefix("https://") {
fetch_http_range(rest, true, start, end, block_private).await
} else if let Some(rest) = url.strip_prefix("ftp://") {
if !ftp_enabled {
return Err(Error::Session(
"ftp web seeds disabled (set web-seed-ftp-enabled #true in host config)".into(),
));
}
fetch_ftp_range(rest, start, end, block_private).await
} else {
Err(Error::Session(format!("unsupported web seed url: {url}")))
}
};
tokio::time::timeout(IO_TIMEOUT, fut)
.await
.map_err(|_| Error::Session(format!("web seed I/O timed out for {url}")))?
}
async fn fetch_http_range(
rest: &str,
tls: bool,
start: u64,
end: u64,
block_private: bool,
) -> Result<Vec<u8>> {
let (host, port, path) = parse_host_port_path(rest, tls)?;
crate::security::reject_http_token("web seed host", &host)?;
crate::security::reject_http_token("web seed path", &path)?;
let addr = resolve_tracker_socket(&host, port, block_private)?;
let request = format!(
"GET {path} HTTP/1.1\r\nHost: {host}\r\nRange: bytes={start}-{end}\r\nConnection: close\r\n\r\n"
);
let max_response = (end.saturating_sub(start).saturating_add(1) as usize)
.saturating_add(crate::security::MAX_HTTP_HEADER_SLACK);
let response = if tls {
let stream = crate::net::connect_pinned(addr).await?;
let config = rustls::ClientConfig::builder()
.with_root_certificates(rustls_root_store())
.with_no_client_auth();
let connector = TlsConnector::from(std::sync::Arc::new(config));
let domain = ServerName::try_from(host.clone())
.map_err(|_| Error::Session(format!("invalid web seed host: {host}")))?;
let mut tls = connector
.connect(domain, stream)
.await
.map_err(|err| Error::Session(format!("web seed tls failed: {err}")))?;
tls.write_all(request.as_bytes()).await?;
crate::net::read_capped(&mut tls, max_response).await?
} else {
let mut stream = crate::net::connect_pinned(addr).await?;
stream.write_all(request.as_bytes()).await?;
crate::net::read_capped(&mut stream, max_response).await?
};
ensure_http_partial_content(&response, start, end)
.map_err(|err| Error::Session(err.to_string()))?;
Ok(http_body(&response)?.to_vec())
}
fn ensure_http_partial_content(response: &[u8], start: u64, end: u64) -> Result<()> {
let line_end = response
.iter()
.position(|b| *b == b'\n')
.unwrap_or(response.len());
let status = std::str::from_utf8(&response[..line_end])
.map_err(|_| Error::Session("web seed status line is not utf-8".into()))?
.trim_end_matches('\r');
let is_206 = status.starts_with("HTTP/1.1 206 ") || status.starts_with("HTTP/1.0 206 ");
if !is_206 {
let is_200 = status.starts_with("HTTP/1.1 200 ") || status.starts_with("HTTP/1.0 200 ");
if !is_200 {
return Err(Error::Session(format!(
"web seed expected 206 Partial Content, got: {status}"
)));
}
}
let headers = std::str::from_utf8(response)
.unwrap_or("")
.split("\r\n\r\n")
.next()
.unwrap_or("");
let expected = format!("bytes {start}-{end}/");
let has_range = headers
.lines()
.any(|line| line.to_ascii_lowercase().starts_with("content-range:") && line.contains(&expected));
if !has_range && !is_206 {
return Err(Error::Session(
"web seed 200 response missing matching Content-Range".into(),
));
}
if is_206 && !has_range {
return Ok(());
}
Ok(())
}
async fn fetch_ftp_range(
rest: &str,
start: u64,
end: u64,
block_private: bool,
) -> Result<Vec<u8>> {
let (host, port, path) = parse_host_port_path_ftp(rest)?;
crate::security::reject_http_token("ftp web seed host", &host)?;
crate::security::reject_http_token("ftp web seed path", &path)?;
let control_addr = resolve_tracker_socket(&host, port, block_private)?;
let mut control = crate::net::connect_pinned(control_addr).await?;
read_ftp_line(&mut control).await?;
control.write_all(b"USER anonymous\r\n").await?;
read_ftp_line(&mut control).await?;
control.write_all(b"PASS guest@\r\n").await?;
read_ftp_line(&mut control).await?;
control.write_all(b"PASV\r\n").await?;
let pasv = read_ftp_line(&mut control).await?;
let control_peer = control
.peer_addr()
.map_err(|err| Error::Session(format!("ftp control peer_addr: {err}")))?;
let data_port = parse_pasv_port(&pasv)?;
let data_addr = std::net::SocketAddr::new(control_peer.ip(), data_port);
if block_private && is_blocked_ip(data_addr.ip()) {
return Err(Error::Session(format!(
"ftp data address {} is blocked",
data_addr.ip()
)));
}
let rest_cmd = if end >= start {
format!("REST {start}\r\n")
} else {
String::new()
};
if !rest_cmd.is_empty() {
control.write_all(rest_cmd.as_bytes()).await?;
read_ftp_line(&mut control).await?;
}
control
.write_all(format!("RETR {path}\r\n").as_bytes())
.await?;
read_ftp_line(&mut control).await?;
let mut data = crate::net::connect_pinned(data_addr).await?;
let want = (end.saturating_sub(start).saturating_add(1)) as usize;
let mut body = crate::net::read_capped(&mut data, want).await?;
read_ftp_line(&mut control).await?;
control.write_all(b"QUIT\r\n").await?;
if body.len() > want {
body.truncate(want);
}
Ok(body)
}
fn parse_host_port_path(rest: &str, tls: bool) -> Result<(String, u16, String)> {
let (host_port, path) = rest
.split_once('/')
.map(|(hp, p)| (hp, format!("/{p}")))
.unwrap_or((rest, "/".into()));
let (host, port) = if let Some((host, port)) = host_port.split_once(':') {
(
host.to_string(),
port.parse::<u16>()
.map_err(|_| Error::Session("invalid web seed port".into()))?,
)
} else {
(host_port.to_string(), if tls { 443 } else { 80 })
};
Ok((host, port, path))
}
fn parse_host_port_path_ftp(rest: &str) -> Result<(String, u16, String)> {
let (host_port, path) = rest
.split_once('/')
.map(|(hp, p)| (hp, format!("/{p}")))
.unwrap_or((rest, "/".into()));
let (host, port) = if let Some((host, port)) = host_port.split_once(':') {
(
host.to_string(),
port.parse::<u16>()
.map_err(|_| Error::Session("invalid ftp web seed port".into()))?,
)
} else {
(host_port.to_string(), 21)
};
Ok((host, port, path))
}
async fn read_ftp_line(stream: &mut TcpStream) -> Result<String> {
let mut buf = Vec::new();
let mut byte = [0u8; 1];
loop {
stream.read_exact(&mut byte).await?;
buf.push(byte[0]);
if buf.len() >= 2 && buf[buf.len() - 2..] == *b"\r\n" {
break;
}
if buf.len() > 512 {
return Err(Error::Session("ftp response too long".into()));
}
}
String::from_utf8(buf).map_err(|_| Error::Session("invalid ftp response".into()))
}
fn parse_pasv_port(line: &str) -> Result<u16> {
let start = line
.find('(')
.ok_or_else(|| Error::Session("ftp PASV missing address".into()))?;
let end = line
.find(')')
.ok_or_else(|| Error::Session("ftp PASV missing address".into()))?;
let parts: Vec<u8> = line[start + 1..end]
.split(',')
.map(|p| {
p.trim()
.parse::<u8>()
.map_err(|_| Error::Session("invalid ftp PASV address".into()))
})
.collect::<Result<Vec<u8>>>()?;
if parts.len() != 6 {
return Err(Error::Session("invalid ftp PASV address".into()));
}
Ok(u16::from(parts[4]) * 256 + u16::from(parts[5]))
}
fn rustls_root_store() -> rustls::RootCertStore {
let mut store = rustls::RootCertStore::empty();
store.extend(webpki_roots::TLS_SERVER_ROOTS.iter().cloned());
store
}
pub fn piece_byte_range(info: &TorrentInfo, piece: u32) -> (u64, u64) {
let offset = piece as u64 * info.piece_length as u64;
let len = info.piece_size(piece) as u64;
(offset, offset + len - 1)
}
pub async fn try_web_seed_piece(session: Arc<Session>, piece: u32) -> Option<Bytes> {
if !session.config().web_seed_enabled || session.web_seeds().is_empty() {
return None;
}
{
let picker_arc = session.picker();
let picker = picker_arc.read().await;
if !picker.is_wanted(piece) || picker.has_piece(piece) {
return None;
}
}
match fetch_piece_from_web_seeds(session, piece).await {
Ok(data) => Some(Bytes::from(data)),
Err(err) => {
tracing::debug!(%err, piece, "web seed piece fetch failed");
None
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::torrent::InfoHash;
use std::path::PathBuf;
fn single_file_info() -> TorrentInfo {
crate::torrent::TorrentInfo {
info_hash: InfoHash::from_bytes([0; 20]),
info_hash_v2: None,
name: "test.bin".into(),
piece_length: 16384,
pieces: vec![[0; 20]; 4],
files: vec![(PathBuf::from("test.bin"), 65536)],
total_len: 65536,
private: false,
meta_version: crate::torrent::MetaVersion::V1,
v2: None,
}
}
fn multi_file_info() -> TorrentInfo {
crate::torrent::TorrentInfo {
info_hash: InfoHash::from_bytes([0; 20]),
info_hash_v2: None,
name: "bundle".into(),
piece_length: 16384,
pieces: vec![[0; 20]; 2],
files: vec![
(PathBuf::from("bundle/a.txt"), 10000),
(PathBuf::from("bundle/b.txt"), 22768),
],
total_len: 32768,
private: false,
meta_version: crate::torrent::MetaVersion::V1,
v2: None,
}
}
#[test]
fn piece_byte_range_single_file() {
let info = single_file_info();
assert_eq!(piece_byte_range(&info, 1), (16384, 32767));
}
#[test]
fn parses_host_port_path() {
let (host, port, path) =
parse_host_port_path("example.com/files/a.bin", false).expect("parse");
assert_eq!(host, "example.com");
assert_eq!(port, 80);
assert_eq!(path, "/files/a.bin");
}
#[test]
fn ftp_default_port_is_21() {
let (host, port, path) = parse_host_port_path_ftp("example.com/a.bin").expect("parse");
assert_eq!(host, "example.com");
assert_eq!(port, 21);
assert_eq!(path, "/a.bin");
}
#[test]
fn parses_pasv_port() {
let port = parse_pasv_port("227 Entering Passive Mode (127,0,0,1,195,145)").expect("pasv");
assert_eq!(port, 50065);
}
#[tokio::test]
async fn ftp_rejected_when_host_disabled() {
let err = fetch_range("ftp://example.com/x", 0, 10, true, false)
.await
.expect_err("ftp disabled");
assert!(err.to_string().contains("ftp web seeds disabled"));
}
#[test]
fn bep19_slash_url_appends_name_and_path() {
let info = multi_file_info();
let url = webseed_url_for_file(
"http://mirror.example/pub/",
&info,
Path::new("bundle/a.txt"),
)
.expect("url");
assert_eq!(url, "http://mirror.example/pub/bundle/a.txt");
}
#[test]
fn bep19_exact_url_single_file_only() {
let single = single_file_info();
let url = webseed_url_for_file("http://mirror.example/exact.bin", &single, Path::new("test.bin"))
.expect("url");
assert_eq!(url, "http://mirror.example/exact.bin");
let multi = multi_file_info();
assert!(webseed_url_for_file(
"http://mirror.example/exact.bin",
&multi,
Path::new("bundle/a.txt"),
)
.is_err());
}
#[test]
fn piece_spanning_files_splits_ranges() {
let info = multi_file_info();
let ranges = piece_file_ranges(&info, 0).expect("ranges");
assert_eq!(ranges.len(), 2);
assert_eq!(ranges[0].start, 0);
assert_eq!(ranges[0].end, 9999);
assert_eq!(ranges[1].start, 0);
assert_eq!(ranges[1].end, 6383);
}
}