use std::collections::BTreeMap;
use crate::bittorrent::bencode::codec::BencodeValue;
use crate::bittorrent::extension::mse_crypto::MseCryptoState;
use crate::bittorrent::peer::connection::PeerAddr;
#[derive(Debug, Clone)]
pub struct PexAddedPeer {
pub addr: PeerAddr,
pub flags: u8,
}
#[derive(Debug, Clone)]
pub enum PexMessage {
Added {
peers: Vec<PexAddedPeer>,
dropped: Vec<PeerAddr>,
},
Removed(Vec<PeerAddr>),
}
pub struct PexHandler;
impl PexHandler {
pub const EXTENSION_NAME: &'static str = "ut_pex";
pub const EXTENSION_ID: u8 = 1;
pub const DEFAULT_MAX_PEERS: usize = 50;
pub fn parse_pex_data(data: &[u8]) -> Result<PexMessage, String> {
let (value, _) = BencodeValue::decode(data)
.map_err(|e| format!("Failed to decode PEX bencode: {}", e))?;
if !value.is_dict() {
return Err("PEX message must be a bencoded dictionary".to_string());
}
let mut added_peers = Vec::new();
if let Some(added_data) = value.dict_get("added").and_then(|v| v.as_bytes()) {
added_peers = decode_compact_peers_v4(added_data)?;
}
let mut flags = Vec::new();
if let Some(flags_data) = value.dict_get("added.f").and_then(|v| v.as_bytes()) {
flags = flags_data.to_vec();
}
if let Some(added6_data) = value.dict_get("added6").and_then(|v| v.as_bytes()) {
let v6_peers = decode_compact_peers_v6(added6_data)?;
added_peers.extend(v6_peers);
}
if let Some(flags6_data) = value.dict_get("added6.f").and_then(|v| v.as_bytes()) {
let v4_count = flags.len();
let v6_count = flags6_data.len();
flags.resize(v4_count + v6_count, 0u8);
flags[v4_count..].copy_from_slice(flags6_data);
}
let mut dropped_peers =
if let Some(dropped_data) = value.dict_get("dropped").and_then(|v| v.as_bytes()) {
decode_compact_peers_v4(dropped_data)?
} else {
Vec::new()
};
if let Some(dropped6_data) = value.dict_get("dropped6").and_then(|v| v.as_bytes()) {
let v6_dropped = decode_compact_peers_v6(dropped6_data)?;
dropped_peers.extend(v6_dropped);
}
let peers_with_flags: Vec<PexAddedPeer> = added_peers
.into_iter()
.enumerate()
.map(|(i, addr)| PexAddedPeer {
addr,
flags: flags.get(i).copied().unwrap_or(0),
})
.collect();
Ok(PexMessage::Added {
peers: peers_with_flags,
dropped: dropped_peers,
})
}
pub fn build_pex_message(added: &[PeerAddr], removed: &[PeerAddr]) -> BencodeValue {
let mut dict = BTreeMap::new();
let (added_v4, added_v6) = partition_peers_by_ip(added);
let (dropped_v4, dropped_v6) = partition_peers_by_ip(removed);
if !added_v4.is_empty() {
let compact = encode_compact_peers_v4(&added_v4);
let flags = vec![0u8; added_v4.len()];
dict.insert(b"added".to_vec(), BencodeValue::Bytes(compact));
dict.insert(b"added.f".to_vec(), BencodeValue::Bytes(flags));
}
if !added_v6.is_empty() {
let compact = encode_compact_peers_v6(&added_v6);
let flags = vec![0u8; added_v6.len()];
dict.insert(b"added6".to_vec(), BencodeValue::Bytes(compact));
dict.insert(b"added6.f".to_vec(), BencodeValue::Bytes(flags));
}
if !dropped_v4.is_empty() {
let compact = encode_compact_peers_v4(&dropped_v4);
dict.insert(b"dropped".to_vec(), BencodeValue::Bytes(compact));
}
if !dropped_v6.is_empty() {
let compact = encode_compact_peers_v6(&dropped_v6);
dict.insert(b"dropped6".to_vec(), BencodeValue::Bytes(compact));
}
BencodeValue::Dict(dict)
}
pub fn is_supported_by_peer(extension_ids: &[Option<u8>]) -> bool {
extension_ids.contains(&Some(Self::EXTENSION_ID))
}
pub fn build_pex_added(
known_peers: &[PeerAddr],
remote_addr: &PeerAddr,
max_peers: usize,
) -> BencodeValue {
let filtered: Vec<PeerAddr> = known_peers
.iter()
.filter(|peer| **peer != *remote_addr)
.take(max_peers)
.cloned()
.collect();
Self::build_pex_message(&filtered, &[])
}
pub fn process_received_pex(
data: &[u8],
local_addr: &PeerAddr,
) -> Result<(Vec<PeerAddr>, Vec<PeerAddr>), String> {
let msg = Self::parse_pex_data(data)?;
match msg {
PexMessage::Added { peers, dropped } => {
let added: Vec<PeerAddr> = peers
.into_iter()
.map(|p| p.addr)
.filter(|addr| addr != local_addr)
.collect();
let dropped_filtered: Vec<PeerAddr> = dropped
.into_iter()
.filter(|addr| addr != local_addr)
.collect();
let added_deduped = deduplicate_peers(&added);
let dropped_deduped = deduplicate_peers(&dropped_filtered);
Ok((added_deduped, dropped_deduped))
}
PexMessage::Removed(peers) => {
let filtered: Vec<PeerAddr> = peers
.into_iter()
.filter(|addr| addr != local_addr)
.collect();
let deduped = deduplicate_peers(&filtered);
Ok((vec![], deduped))
}
}
}
pub fn encrypt_payload(payload: &[u8], cipher: &mut MseCryptoState) -> Result<Vec<u8>, String> {
if !cipher.is_encrypted() {
return Ok(payload.to_vec());
}
let mut encrypted = payload.to_vec();
cipher.encrypt(&mut encrypted);
Ok(encrypted)
}
pub fn decrypt_payload(
encrypted: &[u8],
cipher: &mut MseCryptoState,
) -> Result<Vec<u8>, String> {
if !cipher.is_encrypted() {
return Ok(encrypted.to_vec());
}
let mut decrypted = encrypted.to_vec();
cipher.decrypt(&mut decrypted);
Ok(decrypted)
}
}
fn partition_peers_by_ip(peers: &[PeerAddr]) -> (Vec<PeerAddr>, Vec<PeerAddr>) {
let mut v4 = Vec::new();
let mut v6 = Vec::new();
for peer in peers {
if peer.ip.parse::<std::net::Ipv4Addr>().is_ok() {
v4.push(peer.clone());
} else if peer.ip.parse::<std::net::Ipv6Addr>().is_ok() {
v6.push(peer.clone());
}
}
(v4, v6)
}
fn encode_compact_peers_v4(peers: &[PeerAddr]) -> Vec<u8> {
let mut result = Vec::with_capacity(peers.len() * PeerAddr::COMPACT_SIZE_V4);
for peer in peers {
if let Ok(ipv4) = peer.ip.parse::<std::net::Ipv4Addr>() {
let mut buf = [0u8; 6];
buf[..4].copy_from_slice(&ipv4.octets());
buf[4..6].copy_from_slice(&peer.port.to_be_bytes());
result.extend_from_slice(&buf);
}
}
result
}
fn encode_compact_peers_v6(peers: &[PeerAddr]) -> Vec<u8> {
let mut result = Vec::with_capacity(peers.len() * PeerAddr::COMPACT_SIZE_V6);
for peer in peers {
if let Some(buf) = peer.to_compact_v6() {
result.extend_from_slice(&buf);
}
}
result
}
fn decode_compact_peers_v4(data: &[u8]) -> Result<Vec<PeerAddr>, String> {
if data.is_empty() {
return Ok(Vec::new());
}
if !data.len().is_multiple_of(PeerAddr::COMPACT_SIZE_V4) {
return Err(format!(
"Invalid compact IPv4 peer data length: {} (must be multiple of {})",
data.len(),
PeerAddr::COMPACT_SIZE_V4
));
}
let count = data.len() / PeerAddr::COMPACT_SIZE_V4;
let mut peers = Vec::with_capacity(count);
for i in 0..count {
let start = i * PeerAddr::COMPACT_SIZE_V4;
let end = start + PeerAddr::COMPACT_SIZE_V4;
let peer = PeerAddr::from_compact(&data[start..end])
.ok_or_else(|| format!("Failed to parse IPv4 peer at index {}", i))?;
peers.push(peer);
}
Ok(peers)
}
fn decode_compact_peers_v6(data: &[u8]) -> Result<Vec<PeerAddr>, String> {
if data.is_empty() {
return Ok(Vec::new());
}
if !data.len().is_multiple_of(PeerAddr::COMPACT_SIZE_V6) {
return Err(format!(
"Invalid compact IPv6 peer data length: {} (must be multiple of {})",
data.len(),
PeerAddr::COMPACT_SIZE_V6
));
}
let count = data.len() / PeerAddr::COMPACT_SIZE_V6;
let mut peers = Vec::with_capacity(count);
for i in 0..count {
let start = i * PeerAddr::COMPACT_SIZE_V6;
let end = start + PeerAddr::COMPACT_SIZE_V6;
let peer = PeerAddr::from_compact_v6(&data[start..end])
.ok_or_else(|| format!("Failed to parse IPv6 peer at index {}", i))?;
peers.push(peer);
}
Ok(peers)
}
fn deduplicate_peers(peers: &[PeerAddr]) -> Vec<PeerAddr> {
let mut seen = std::collections::HashSet::new();
peers
.iter()
.filter(|peer| seen.insert((peer.ip.clone(), peer.port)))
.cloned()
.collect()
}
#[cfg(test)]
mod tests;