use tracing::debug;
#[derive(Debug, Clone)]
pub struct TrackerResponse {
pub interval: u32,
pub min_interval: Option<u32>,
pub seeders: Option<u32>,
pub leechers: Option<u32>,
pub downloaded: Option<u64>,
pub peers: Vec<PeerInfo>,
pub peers6: Vec<PeerInfo>,
pub tracker_id: Option<String>,
pub announce_list: Vec<Vec<String>>,
pub warning_message: Option<String>,
pub failure_reason: Option<String>,
}
#[derive(Debug, Clone)]
pub struct PeerInfo {
pub ip: String,
pub port: u16,
pub peer_id: Option<[u8; 20]>,
}
impl TrackerResponse {
pub fn parse(data: &[u8]) -> Result<Self, String> {
use crate::bittorrent::bencode::codec::BencodeValue;
let (root, _) = BencodeValue::decode(data)?;
if !root.is_dict() {
return Err("Tracker response must be a bencoded dictionary".to_string());
}
let failure_reason = root.dict_get_str("failure reason").map(|s| s.to_string());
if failure_reason.is_some() {
return Ok(Self {
interval: 300,
min_interval: None,
seeders: None,
leechers: None,
downloaded: None,
peers: vec![],
peers6: vec![],
tracker_id: None,
announce_list: Vec::new(),
warning_message: None,
failure_reason,
});
}
let interval = root
.dict_get_int("interval")
.filter(|seconds| *seconds > 0)
.map(saturating_u32)
.unwrap_or(0);
let min_interval = root
.dict_get_int("min interval")
.filter(|seconds| *seconds > 0)
.map(saturating_u32);
let seeders = root
.dict_get_int("complete")
.filter(|count| *count >= 0)
.map(saturating_u32);
let leechers = root
.dict_get_int("incomplete")
.filter(|count| *count >= 0)
.map(saturating_u32);
let downloaded = root
.dict_get_int("downloaded")
.and_then(|value| u64::try_from(value).ok());
let warning_message = root.dict_get_str("warning message").map(|s| s.to_string());
let tracker_id = root.dict_get_str("tracker id").map(|s| s.to_string());
let announce_list = Self::parse_announce_list(&root);
let peers = Self::parse_peers(&root);
let peers6 = Self::parse_peers6(&root);
debug!(
"Tracker response: interval={}s, seeders={:?}, leechers={:?}, downloaded={:?}, peers={}, peers6={}, tracker_id={:?}, announce_list={:?}",
interval,
seeders,
leechers,
downloaded,
peers.len(),
peers6.len(),
tracker_id,
announce_list,
);
Ok(Self {
interval,
min_interval,
seeders,
leechers,
downloaded,
peers,
peers6,
tracker_id,
announce_list,
warning_message,
failure_reason: None,
})
}
fn parse_peers(root: &crate::bittorrent::bencode::codec::BencodeValue) -> Vec<PeerInfo> {
match root.dict_get(b"peers") {
Some(crate::bittorrent::bencode::codec::BencodeValue::Bytes(data)) => {
Self::parse_compact_peers(data)
}
Some(crate::bittorrent::bencode::codec::BencodeValue::List(list)) => {
Self::parse_normal_peers(list)
}
_ => Vec::new(),
}
}
fn parse_announce_list(
root: &crate::bittorrent::bencode::codec::BencodeValue,
) -> Vec<Vec<String>> {
let Some(crate::bittorrent::bencode::codec::BencodeValue::List(tiers)) =
root.dict_get(b"announce-list")
else {
return Vec::new();
};
tiers
.iter()
.filter_map(|tier| {
let urls = tier
.as_list()?
.iter()
.filter_map(|url| {
let url = url.as_str()?.trim();
(!url.is_empty()).then(|| url.to_string())
})
.collect::<Vec<_>>();
(!urls.is_empty()).then_some(urls)
})
.collect()
}
fn parse_compact_peers(data: &[u8]) -> Vec<PeerInfo> {
crate::bittorrent::peer::address::decode_compact_v4_peers(data)
.unwrap_or_default()
.into_iter()
.map(|peer| PeerInfo {
ip: peer.ip().to_string(),
port: peer.port(),
peer_id: None,
})
.collect()
}
fn parse_normal_peers(
list: &[crate::bittorrent::bencode::codec::BencodeValue],
) -> Vec<PeerInfo> {
let mut peers = Vec::new();
for item in list {
let Some(dict) = item.as_dict() else {
continue;
};
let ip = dict
.get(&b"ip"[..])
.and_then(|v| v.as_str())
.map(|s| s.to_string())
.unwrap_or_default();
let port = dict
.get(&b"port"[..])
.and_then(|v| v.as_int())
.filter(|port| (1..=i64::from(u16::MAX)).contains(port))
.and_then(|port| u16::try_from(port).ok());
let peer_id = dict
.get(&b"peer id"[..])
.and_then(|v| v.as_bytes())
.filter(|b| b.len() == 20)
.map(|b| {
let mut id = [0u8; 20];
id.copy_from_slice(b);
id
});
if !ip.is_empty()
&& let Some(port) = port
{
peers.push(PeerInfo { ip, port, peer_id });
}
}
peers
}
fn parse_peers6(root: &crate::bittorrent::bencode::codec::BencodeValue) -> Vec<PeerInfo> {
match root.dict_get(b"peers6") {
Some(crate::bittorrent::bencode::codec::BencodeValue::Bytes(data)) => {
Self::parse_compact_peers_v6(data)
}
Some(crate::bittorrent::bencode::codec::BencodeValue::List(list)) => {
Self::parse_normal_peers(list)
}
_ => Vec::new(),
}
}
fn parse_compact_peers_v6(data: &[u8]) -> Vec<PeerInfo> {
crate::bittorrent::peer::address::decode_compact_v6_peers(data)
.unwrap_or_default()
.into_iter()
.map(|peer| PeerInfo {
ip: peer.ip().to_string(),
port: peer.port(),
peer_id: None,
})
.collect()
}
pub fn is_failure(&self) -> bool {
self.failure_reason.is_some()
}
pub fn peer_count(&self) -> usize {
self.peers.len() + self.peers6.len()
}
}
fn saturating_u32(value: i64) -> u32 {
u32::try_from(value).unwrap_or(u32::MAX)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::bittorrent::bencode::codec::BencodeValue;
use std::collections::BTreeMap;
#[test]
fn test_parse_simple_response() {
let mut peers_data = vec![0u8; 12];
peers_data[0..4].copy_from_slice(&[127, 0, 0, 1]);
peers_data[4..6].copy_from_slice(&6881u16.to_be_bytes());
peers_data[6..10].copy_from_slice(&[192, 168, 1, 1]);
peers_data[10..12].copy_from_slice(&6882u16.to_be_bytes());
let mut resp_dict = BTreeMap::new();
resp_dict.insert(b"interval".to_vec(), BencodeValue::Int(900));
resp_dict.insert(b"peers".to_vec(), BencodeValue::Bytes(peers_data));
let root = BencodeValue::Dict(resp_dict);
let encoded = root.encode();
let parsed = TrackerResponse::parse(&encoded).unwrap();
assert_eq!(parsed.interval, 900);
assert_eq!(parsed.peers.len(), 2);
assert_eq!(parsed.peers[0].ip, "127.0.0.1");
assert_eq!(parsed.peers[0].port, 6881);
assert_eq!(parsed.seeders, None);
assert_eq!(parsed.leechers, None);
assert_eq!(parsed.downloaded, None);
assert!(parsed.announce_list.is_empty());
}
#[test]
fn test_parse_failure_response() {
let mut d = BTreeMap::new();
d.insert(
b"failure reason".to_vec(),
BencodeValue::Bytes(b"tracker offline".to_vec()),
);
let root = BencodeValue::Dict(d);
let resp = TrackerResponse::parse(&root.encode()).unwrap();
assert!(resp.is_failure());
assert_eq!(resp.failure_reason.as_deref(), Some("tracker offline"));
}
#[test]
fn test_parse_rejects_non_dictionary_root() {
let error = TrackerResponse::parse(b"i1e").unwrap_err();
assert!(error.contains("must be a bencoded dictionary"));
}
#[test]
fn test_parse_tracker_values_without_integer_wraparound() {
let mut d = BTreeMap::new();
d.insert(b"interval".to_vec(), BencodeValue::Int(i64::MAX));
d.insert(b"min interval".to_vec(), BencodeValue::Int(-1));
d.insert(b"complete".to_vec(), BencodeValue::Int(-1));
d.insert(b"incomplete".to_vec(), BencodeValue::Int(i64::MAX));
d.insert(b"downloaded".to_vec(), BencodeValue::Int(-1));
let response = TrackerResponse::parse(&BencodeValue::Dict(d).encode()).unwrap();
assert_eq!(response.interval, u32::MAX);
assert_eq!(response.min_interval, None);
assert_eq!(response.seeders, None);
assert_eq!(response.leechers, Some(u32::MAX));
assert_eq!(response.downloaded, None);
}
#[test]
fn test_parse_non_positive_interval_as_unspecified() {
let mut d = BTreeMap::new();
d.insert(b"interval".to_vec(), BencodeValue::Int(-1));
let response = TrackerResponse::parse(&BencodeValue::Dict(d).encode()).unwrap();
assert_eq!(response.interval, 0);
}
#[test]
fn test_parse_normal_peers_skips_malformed_entries_and_invalid_ports() {
let peer = |port| {
BencodeValue::Dict(BTreeMap::from([
(b"ip".to_vec(), BencodeValue::Bytes(b"192.0.2.1".to_vec())),
(b"port".to_vec(), BencodeValue::Int(port)),
]))
};
let mut response = BTreeMap::new();
response.insert(
b"peers".to_vec(),
BencodeValue::List(vec![
BencodeValue::Int(1),
peer(-1),
peer(0),
peer(65_536),
peer(65_537),
peer(65_535),
]),
);
let parsed = TrackerResponse::parse(&BencodeValue::Dict(response).encode()).unwrap();
assert_eq!(parsed.peers.len(), 1);
assert_eq!(parsed.peers[0].ip, "192.0.2.1");
assert_eq!(parsed.peers[0].port, u16::MAX);
}
#[test]
fn test_failure_reason_remains_failure_when_interval_is_present() {
let mut d = BTreeMap::new();
d.insert(
b"failure reason".to_vec(),
BencodeValue::Bytes(b"temporarily unavailable".to_vec()),
);
d.insert(b"interval".to_vec(), BencodeValue::Int(60));
let response = TrackerResponse::parse(&BencodeValue::Dict(d).encode()).unwrap();
assert!(response.is_failure());
assert_eq!(
response.failure_reason.as_deref(),
Some("temporarily unavailable")
);
assert!(response.peers.is_empty());
}
#[test]
fn test_parse_tracker_id() {
let mut peers_data = vec![0u8; 6];
peers_data[0..4].copy_from_slice(&[127, 0, 0, 1]);
peers_data[4..6].copy_from_slice(&6881u16.to_be_bytes());
let mut resp_dict = BTreeMap::new();
resp_dict.insert(b"interval".to_vec(), BencodeValue::Int(300));
resp_dict.insert(b"peers".to_vec(), BencodeValue::Bytes(peers_data));
resp_dict.insert(
b"tracker id".to_vec(),
BencodeValue::Bytes(b"my-tracker-42".to_vec()),
);
resp_dict.insert(b"complete".to_vec(), BencodeValue::Int(0));
resp_dict.insert(b"incomplete".to_vec(), BencodeValue::Int(0));
resp_dict.insert(b"downloaded".to_vec(), BencodeValue::Int(0));
let root = BencodeValue::Dict(resp_dict);
let encoded = root.encode();
let parsed = TrackerResponse::parse(&encoded).unwrap();
assert_eq!(parsed.tracker_id.as_deref(), Some("my-tracker-42"));
assert_eq!(parsed.seeders, Some(0));
assert_eq!(parsed.leechers, Some(0));
assert_eq!(parsed.downloaded, Some(0));
}
#[test]
fn test_parse_dynamic_announce_list() {
let mut resp_dict = BTreeMap::new();
resp_dict.insert(b"interval".to_vec(), BencodeValue::Int(300));
resp_dict.insert(
b"peers".to_vec(),
BencodeValue::Bytes(vec![127, 0, 0, 1, 0x1a, 0xe1]),
);
resp_dict.insert(
b"announce-list".to_vec(),
BencodeValue::List(vec![
BencodeValue::List(vec![BencodeValue::Bytes(
b"https://tracker.example/announce".to_vec(),
)]),
BencodeValue::List(vec![BencodeValue::Bytes(
b"udp://tracker.example:6969/announce".to_vec(),
)]),
]),
);
let parsed = TrackerResponse::parse(&BencodeValue::Dict(resp_dict).encode()).unwrap();
assert_eq!(
parsed.announce_list,
vec![
vec!["https://tracker.example/announce".to_string()],
vec!["udp://tracker.example:6969/announce".to_string()],
]
);
}
#[test]
fn test_parse_no_tracker_id() {
let mut peers_data = vec![0u8; 6];
peers_data[0..4].copy_from_slice(&[127, 0, 0, 1]);
peers_data[4..6].copy_from_slice(&6881u16.to_be_bytes());
let mut resp_dict = BTreeMap::new();
resp_dict.insert(b"interval".to_vec(), BencodeValue::Int(300));
resp_dict.insert(b"peers".to_vec(), BencodeValue::Bytes(peers_data));
let root = BencodeValue::Dict(resp_dict);
let encoded = root.encode();
let parsed = TrackerResponse::parse(&encoded).unwrap();
assert!(parsed.tracker_id.is_none());
}
#[test]
fn test_parse_peers6_compact() {
let mut peers_data = vec![0u8; 6];
peers_data[0..4].copy_from_slice(&[127, 0, 0, 1]);
peers_data[4..6].copy_from_slice(&6881u16.to_be_bytes());
let mut peers6_data = Vec::with_capacity(36);
let ipv6_1 = "2001:db8::1".parse::<std::net::Ipv6Addr>().unwrap();
peers6_data.extend_from_slice(&ipv6_1.octets());
peers6_data.extend_from_slice(&6881u16.to_be_bytes());
let ipv6_2 = "::1".parse::<std::net::Ipv6Addr>().unwrap();
peers6_data.extend_from_slice(&ipv6_2.octets());
peers6_data.extend_from_slice(&6882u16.to_be_bytes());
let mut resp_dict = BTreeMap::new();
resp_dict.insert(b"interval".to_vec(), BencodeValue::Int(300));
resp_dict.insert(b"peers".to_vec(), BencodeValue::Bytes(peers_data));
resp_dict.insert(b"peers6".to_vec(), BencodeValue::Bytes(peers6_data));
let root = BencodeValue::Dict(resp_dict);
let encoded = root.encode();
let parsed = TrackerResponse::parse(&encoded).unwrap();
assert_eq!(parsed.peers.len(), 1);
assert_eq!(parsed.peers[0].ip, "127.0.0.1");
assert_eq!(parsed.peers[0].port, 6881);
assert_eq!(parsed.peers6.len(), 2);
assert_eq!(parsed.peers6[0].ip, "2001:db8::1");
assert_eq!(parsed.peers6[0].port, 6881);
assert_eq!(parsed.peers6[1].ip, "::1");
assert_eq!(parsed.peers6[1].port, 6882);
assert_eq!(parsed.peer_count(), 3);
}
#[test]
fn test_parse_peers6_dictionary_list() {
let mut peer = BTreeMap::new();
peer.insert(
b"ip".to_vec(),
BencodeValue::Bytes(b"2001:db8::10".to_vec()),
);
peer.insert(b"port".to_vec(), BencodeValue::Int(6881));
let mut response = BTreeMap::new();
response.insert(
b"peers6".to_vec(),
BencodeValue::List(vec![BencodeValue::Dict(peer)]),
);
let parsed = TrackerResponse::parse(&BencodeValue::Dict(response).encode()).unwrap();
assert_eq!(parsed.peers6.len(), 1);
assert_eq!(parsed.peers6[0].ip, "2001:db8::10");
assert_eq!(parsed.peers6[0].port, 6881);
}
#[test]
fn test_parse_peers6_invalid_length_preserves_ipv4_peers() {
let peers6_data = vec![0u8; 17];
let mut resp_dict = BTreeMap::new();
resp_dict.insert(b"interval".to_vec(), BencodeValue::Int(300));
resp_dict.insert(b"peers".to_vec(), BencodeValue::Bytes(vec![0u8; 6]));
resp_dict.insert(b"peers6".to_vec(), BencodeValue::Bytes(peers6_data));
let root = BencodeValue::Dict(resp_dict);
let encoded = root.encode();
let parsed = TrackerResponse::parse(&encoded).unwrap();
assert_eq!(parsed.peers.len(), 1);
assert!(parsed.peers6.is_empty());
}
#[test]
fn test_parse_compact_peers_invalid_length_preserves_ipv6_peers() {
let mut peers6_data = Vec::with_capacity(18);
peers6_data.extend_from_slice(&std::net::Ipv6Addr::LOCALHOST.octets());
peers6_data.extend_from_slice(&6881u16.to_be_bytes());
let mut response = BTreeMap::new();
response.insert(b"peers".to_vec(), BencodeValue::Bytes(vec![0u8; 7]));
response.insert(b"peers6".to_vec(), BencodeValue::Bytes(peers6_data));
let parsed = TrackerResponse::parse(&BencodeValue::Dict(response).encode()).unwrap();
assert!(parsed.peers.is_empty());
assert_eq!(parsed.peers6.len(), 1);
assert_eq!(parsed.peers6[0].ip, "::1");
assert_eq!(parsed.peers6[0].port, 6881);
}
#[test]
fn test_parse_peers6_empty() {
let mut resp_dict = BTreeMap::new();
resp_dict.insert(b"interval".to_vec(), BencodeValue::Int(300));
resp_dict.insert(b"peers".to_vec(), BencodeValue::Bytes(vec![0u8; 6]));
let root = BencodeValue::Dict(resp_dict);
let encoded = root.encode();
let parsed = TrackerResponse::parse(&encoded).unwrap();
assert!(parsed.peers6.is_empty());
assert_eq!(parsed.peer_count(), 1);
}
#[test]
fn test_parse_failure_response_has_empty_peers6() {
let mut d = BTreeMap::new();
d.insert(
b"failure reason".to_vec(),
BencodeValue::Bytes(b"tracker offline".to_vec()),
);
let root = BencodeValue::Dict(d);
let resp = TrackerResponse::parse(&root.encode()).unwrap();
assert!(resp.peers.is_empty());
assert!(resp.peers6.is_empty());
}
}