use std::collections::HashMap;
use tokio::io::AsyncWriteExt;
use crate::bencode::decode;
use crate::error::{Error, Result};
use crate::tracker::http::{http_body, parse_http_url, urlencode_bytes};
use crate::tracker::policy::{ensure_http_ok, resolve_tracker_socket};
#[derive(Debug, Clone, Copy, Default)]
pub struct ScrapeStats {
pub complete: u32,
pub downloaded: u32,
pub incomplete: u32,
}
pub fn build_scrape_path(base: &str, info_hashes: &[[u8; 20]]) -> String {
let (path, existing_query) = split_path_and_query(base);
let scrape_path = announce_path_to_scrape(path);
let hash_params: Vec<String> = info_hashes
.iter()
.map(|hash| format!("info_hash={}", urlencode_bytes(hash)))
.collect();
let params = hash_params.join("&");
match existing_query {
Some(q) => format!("{scrape_path}?{q}&{params}"),
None => format!("{scrape_path}?{params}"),
}
}
fn announce_path_to_scrape(path: &str) -> String {
if let Some(base) = path.strip_suffix("/announce") {
format!("{base}/scrape")
} else if let Some(base) = path.strip_suffix("/announce.php") {
format!("{base}/scrape.php")
} else {
format!("{path}/scrape")
}
}
pub fn split_path_and_query(path: &str) -> (&str, Option<&str>) {
if let Some((p, q)) = path.split_once('?') {
(p, Some(q))
} else {
(path, None)
}
}
pub fn parse_scrape_response(body: &[u8]) -> Result<HashMap<[u8; 20], ScrapeStats>> {
let value = decode(body)?;
let files = value
.dict_get(b"files".as_ref())
.and_then(|v| v.as_dict())
.ok_or_else(|| Error::Tracker("scrape response missing files".into()))?;
let mut out = HashMap::new();
for (key, entry) in files {
if key.len() != 20 {
continue;
}
let mut hash = [0u8; 20];
hash.copy_from_slice(key);
let complete = entry
.dict_get_str("complete")
.and_then(|v| v.as_int())
.unwrap_or(0) as u32;
let downloaded = entry
.dict_get_str("downloaded")
.and_then(|v| v.as_int())
.unwrap_or(0) as u32;
let incomplete = entry
.dict_get_str("incomplete")
.and_then(|v| v.as_int())
.unwrap_or(0) as u32;
out.insert(
hash,
ScrapeStats {
complete,
downloaded,
incomplete,
},
);
}
Ok(out)
}
pub async fn scrape_http(
announce_url: &str,
info_hashes: &[[u8; 20]],
block_private: bool,
) -> Result<HashMap<[u8; 20], ScrapeStats>> {
let (host, port, use_tls, path) = parse_http_url(announce_url)?;
let request_target = build_scrape_path(&path, info_hashes);
if use_tls {
crate::tracker::https::scrape_https(
&host,
port,
&request_target,
block_private,
)
.await
} else {
scrape_http_raw(&host, port, &request_target, block_private).await
}
}
async fn scrape_http_raw(
host: &str,
port: u16,
request_target: &str,
block_private: bool,
) -> Result<HashMap<[u8; 20], ScrapeStats>> {
crate::security::reject_http_token("tracker host", host)
.map_err(|err| Error::Tracker(err.to_string()))?;
crate::security::reject_http_token("tracker request", request_target)
.map_err(|err| Error::Tracker(err.to_string()))?;
let addr = resolve_tracker_socket(host, port, block_private)?;
let mut stream = crate::net::connect_pinned(addr).await?;
let request = format!(
"GET {request_target} HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\n\r\n"
);
stream.write_all(request.as_bytes()).await?;
let response =
crate::net::read_capped(&mut stream, crate::security::MAX_TRACKER_HTTP_RESPONSE).await
.map_err(|err| Error::Tracker(err.to_string()))?;
ensure_http_ok(&response)?;
let body = http_body(&response)?;
parse_scrape_response(body)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn preserves_passkey_query_on_scrape() {
let path = build_scrape_path(
"/announce?passkey=abc123",
&[[0xAB; 20]],
);
assert!(path.contains("passkey=abc123"));
assert!(path.contains("info_hash="));
}
#[test]
fn derives_scrape_from_announce_path() {
let path = build_scrape_path("/announce", &[[0xCD; 20]]);
assert!(path.contains("scrape"));
}
}