use std::net::SocketAddr;
use tokio::io::AsyncWriteExt;
use crate::bencode::decode_with_limits;
use crate::error::{Error, Result};
use crate::security::DecodeLimits;
use crate::tracker::policy::{ensure_http_ok, resolve_tracker_socket};
use crate::tracker::AnnounceEvent;
use crate::wire::decode_peers_auto;
#[derive(Debug, Clone, Default)]
pub struct AnnounceResponse {
pub peers: Vec<SocketAddr>,
pub interval_secs: Option<u32>,
pub min_interval_secs: Option<u32>,
}
pub async fn announce_http(
host: &str,
port: u16,
_path: &str,
request_target: &str,
block_private: bool,
) -> Result<AnnounceResponse> {
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_tracker_response(body)
}
#[allow(clippy::too_many_arguments)]
pub fn build_announce_path(
base: &str,
info_hash: &[u8; 20],
peer_id: &[u8; 20],
port: u16,
uploaded: u64,
downloaded: u64,
left: u64,
event: AnnounceEvent,
ipv6: Option<&[u8; 18]>,
announce_ip: Option<std::net::Ipv4Addr>,
) -> Result<String> {
let event_str = match event {
AnnounceEvent::None => None,
AnnounceEvent::Started => Some("started"),
AnnounceEvent::Completed => Some("completed"),
AnnounceEvent::Stopped => Some("stopped"),
};
let (path, existing_query) = crate::tracker::scrape::split_path_and_query(base);
let mut params = format!(
"info_hash={}&peer_id={}&port={port}&uploaded={uploaded}&downloaded={downloaded}&left={left}&compact=1&numwant=50",
urlencode_bytes(info_hash),
urlencode_bytes(peer_id),
);
if let Some(ev) = event_str {
params.push_str("&event=");
params.push_str(ev);
}
if let Some(compact) = ipv6 {
params.push_str("&ipv6=");
params.push_str(&urlencode_bytes(compact));
}
if let Some(ip) = announce_ip {
params.push_str("&ip=");
params.push_str(&urlencode_bytes(&ip.octets()));
}
Ok(match existing_query {
Some(q) => format!("{path}?{q}&{params}"),
None => format!("{path}?{params}"),
})
}
pub fn parse_tracker_response(body: &[u8]) -> Result<AnnounceResponse> {
let value = decode_with_limits(body, DecodeLimits::TRACKER)?;
if let Some(reason) = value
.dict_get(b"failure reason".as_ref())
.and_then(|v| v.as_bytes())
{
let text = String::from_utf8_lossy(reason);
return Err(Error::Tracker(format!("tracker failure reason: {text}")));
}
let interval_secs = value
.dict_get(b"interval".as_ref())
.and_then(|v| v.as_int())
.filter(|&v| v > 0)
.map(|v| v as u32);
let min_interval_secs = value
.dict_get(b"min interval".as_ref())
.and_then(|v| v.as_int())
.filter(|&v| v > 0)
.map(|v| v as u32);
let peers = if let Some(raw) = value.dict_get(b"peers".as_ref()).and_then(|v| v.as_bytes()) {
decode_peers_auto(raw)
} else if let Some(list) = value.dict_get(b"peers".as_ref()).and_then(|v| v.as_list()) {
let mut out = Vec::new();
for entry in list.iter().take(crate::wire::MAX_COMPACT_PEERS) {
let ip = entry
.dict_get_str("ip")
.and_then(|v| v.as_bytes())
.and_then(|b| String::from_utf8(b.to_vec()).ok())
.ok_or_else(|| Error::Tracker("peer entry missing ip".into()))?;
let port = entry
.dict_get_str("port")
.and_then(|v| v.as_int())
.ok_or_else(|| Error::Tracker("peer entry missing port".into()))? as u16;
if let Ok(addr) = format!("{ip}:{port}").parse() {
out.push(addr);
}
}
out
} else {
Vec::new()
};
Ok(AnnounceResponse {
peers,
interval_secs,
min_interval_secs,
})
}
pub fn http_body(response: &[u8]) -> Result<&[u8]> {
let header_end = response
.windows(4)
.position(|window| window == b"\r\n\r\n")
.ok_or_else(|| Error::Tracker("tracker response missing headers".into()))?;
Ok(&response[header_end + 4..])
}
pub fn parse_http_url(url: &str) -> Result<(String, u16, bool, String)> {
let (use_tls, rest) = if let Some(rest) = url.strip_prefix("https://") {
(true, rest)
} else if let Some(rest) = url.strip_prefix("http://") {
(false, rest)
} else {
return Err(Error::Tracker(format!("unsupported tracker url: {url}")));
};
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::Tracker("invalid tracker port".into()))?,
)
} else {
(host_port.to_string(), if use_tls { 443 } else { 80 })
};
Ok((host, port, use_tls, path))
}
pub fn parse_udp_url(url: &str) -> Result<(String, u16)> {
let rest = url
.strip_prefix("udp://")
.ok_or_else(|| Error::Tracker(format!("unsupported udp tracker url: {url}")))?;
let host_port = rest.split('/').next().unwrap_or(rest);
if let Some((host, port)) = host_port.split_once(':') {
let port = port
.parse::<u16>()
.map_err(|_| Error::Tracker("invalid udp tracker port".into()))?;
return Ok((host.to_string(), port));
}
Ok((host_port.to_string(), 6969))
}
pub fn urlencode_bytes(bytes: &[u8]) -> String {
bytes.iter().map(|byte| format!("%{byte:02X}")).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn builds_announce_path() {
let path = build_announce_path(
"/announce",
&[0xAB; 20],
&[0xCD; 20],
6881,
0,
0,
1000,
AnnounceEvent::Started,
None,
None,
)
.expect("path");
assert!(path.contains("info_hash="));
assert!(path.contains("event=started"));
}
#[test]
fn includes_ipv6_when_present() {
let compact = [0xABu8; 18];
let path = build_announce_path(
"/announce",
&[0xAB; 20],
&[0xCD; 20],
6881,
0,
0,
1000,
AnnounceEvent::Started,
Some(&compact),
None,
)
.expect("path");
assert!(path.contains("ipv6="));
}
#[test]
fn preserves_passkey_in_announce_path() {
let path = build_announce_path(
"/announce?passkey=secret",
&[0xAB; 20],
&[0xCD; 20],
6881,
0,
0,
1000,
AnnounceEvent::Started,
None,
None,
)
.expect("path");
assert!(path.contains("passkey=secret"));
assert!(path.contains("&info_hash=") || path.contains("?passkey=secret&info_hash="));
}
#[test]
fn parses_udp_tracker_url() {
let (host, port) = parse_udp_url("udp://tracker.example.com:8080/announce").expect("parse");
assert_eq!(host, "tracker.example.com");
assert_eq!(port, 8080);
let (host, port) = parse_udp_url("udp://tracker.example.com/announce").expect("default port");
assert_eq!(host, "tracker.example.com");
assert_eq!(port, 6969);
}
#[test]
fn rejects_failure_reason() {
let body = b"d14:failure reason20:unregistered torrente";
let err = parse_tracker_response(body).expect_err("failure");
assert!(
err.to_string().contains("failure reason"),
"{err}"
);
}
#[test]
fn parses_interval_keys() {
let body = b"d8:intervali1800e12:min intervali900e5:peers0:e";
let resp = parse_tracker_response(body).expect("ok");
assert_eq!(resp.interval_secs, Some(1800));
assert_eq!(resp.min_interval_secs, Some(900));
assert!(resp.peers.is_empty());
}
}