use std::net::SocketAddr;
pub const MAX_COMPACT_PEERS: usize = 256;
pub const MAX_COMPACT_NODES: usize = 256;
#[derive(Debug, Clone)]
pub struct CompactNode {
pub id: [u8; 20],
pub addr: SocketAddr,
}
pub fn decode_peers(raw: &[u8], ipv6: bool) -> Vec<SocketAddr> {
let stride = if ipv6 { 18 } else { 6 };
if !raw.len().is_multiple_of(stride) {
return Vec::new();
}
let cap = raw.len() / stride;
if cap > MAX_COMPACT_PEERS {
return Vec::new();
}
raw.chunks_exact(stride)
.filter_map(|chunk| decode_compact_peer(chunk, ipv6))
.collect()
}
pub fn peers_stride(raw: &[u8]) -> Option<usize> {
if raw.is_empty() {
return None;
}
let v4 = raw.len().is_multiple_of(6);
let v6 = raw.len().is_multiple_of(18);
match (v4, v6) {
(true, _) => Some(6),
(false, true) => Some(18),
_ => None,
}
}
pub fn decode_peers_auto(raw: &[u8]) -> Vec<SocketAddr> {
peers_stride(raw)
.map(|stride| decode_peers(raw, stride == 18))
.unwrap_or_default()
}
pub fn nodes_stride(raw: &[u8]) -> Option<usize> {
if raw.is_empty() {
return None;
}
let v4 = raw.len().is_multiple_of(26);
let v6 = raw.len().is_multiple_of(38);
if v6 && !v4 {
Some(38)
} else if v4 {
Some(26)
} else {
None
}
}
pub fn decode_nodes_auto(raw: &[u8]) -> Vec<CompactNode> {
nodes_stride(raw)
.map(|stride| decode_nodes(raw, stride == 38))
.unwrap_or_default()
}
pub fn decode_nodes(raw: &[u8], ipv6: bool) -> Vec<CompactNode> {
let stride = if ipv6 { 38 } else { 26 };
if !raw.len().is_multiple_of(stride) {
return Vec::new();
}
let cap = raw.len() / stride;
if cap > MAX_COMPACT_NODES {
return Vec::new();
}
raw.chunks_exact(stride)
.map(|chunk| {
let mut id = [0u8; 20];
id.copy_from_slice(&chunk[..20]);
let addr = if ipv6 {
let mut ip = [0u8; 16];
ip.copy_from_slice(&chunk[20..36]);
let port = u16::from_be_bytes([chunk[36], chunk[37]]);
SocketAddr::new(std::net::IpAddr::from(ip), port)
} else {
let ip = std::net::Ipv4Addr::new(chunk[20], chunk[21], chunk[22], chunk[23]);
let port = u16::from_be_bytes([chunk[24], chunk[25]]);
SocketAddr::V4(std::net::SocketAddrV4::new(ip, port))
};
CompactNode { id, addr }
})
.collect()
}
pub fn decode_peer_values(value: &crate::bencode::BencodeValue) -> Vec<SocketAddr> {
let Some(list) = value.as_list() else {
return Vec::new();
};
if list.len() > MAX_COMPACT_PEERS {
return Vec::new();
}
list.iter()
.filter_map(|entry| {
let bytes = entry.as_bytes()?;
decode_compact_peer(bytes, bytes.len() == 18)
})
.collect()
}
fn decode_compact_peer(chunk: &[u8], ipv6: bool) -> Option<SocketAddr> {
if ipv6 && chunk.len() == 18 {
let mut ip = [0u8; 16];
ip.copy_from_slice(&chunk[..16]);
let port = u16::from_be_bytes([chunk[16], chunk[17]]);
return Some(SocketAddr::new(std::net::IpAddr::from(ip), port));
}
if !ipv6 && chunk.len() == 6 {
let ip = std::net::Ipv4Addr::new(chunk[0], chunk[1], chunk[2], chunk[3]);
let port = u16::from_be_bytes([chunk[4], chunk[5]]);
return Some(SocketAddr::V4(std::net::SocketAddrV4::new(ip, port)));
}
None
}
pub fn encode_peers(peers: &[SocketAddr], ipv6: bool) -> Vec<u8> {
let stride = if ipv6 { 18 } else { 6 };
let mut out = Vec::with_capacity(peers.len().min(MAX_COMPACT_PEERS) * stride);
for peer in peers.iter().take(MAX_COMPACT_PEERS) {
match peer {
SocketAddr::V4(v4) if !ipv6 => {
out.extend(v4.ip().octets());
out.extend(v4.port().to_be_bytes());
}
SocketAddr::V6(v6) if ipv6 => {
out.extend(v6.ip().octets());
out.extend(v6.port().to_be_bytes());
}
_ => {}
}
}
out
}
pub fn encode_peer_values_list(
peers: &[SocketAddr],
ipv6: bool,
) -> Option<crate::bencode::BencodeValue> {
use crate::bencode::BencodeValue;
let mut list = Vec::new();
for peer in peers.iter().take(MAX_COMPACT_PEERS) {
match peer {
SocketAddr::V4(v4) if !ipv6 => {
let mut bytes = Vec::with_capacity(6);
bytes.extend(v4.ip().octets());
bytes.extend(v4.port().to_be_bytes());
list.push(BencodeValue::Bytes(bytes));
}
SocketAddr::V6(v6) if ipv6 => {
let mut bytes = Vec::with_capacity(18);
bytes.extend(v6.ip().octets());
bytes.extend(v6.port().to_be_bytes());
list.push(BencodeValue::Bytes(bytes));
}
_ => {}
}
}
if list.is_empty() {
None
} else {
Some(BencodeValue::List(list))
}
}
pub fn encode_nodes(nodes: &[CompactNode], ipv6: bool) -> Vec<u8> {
let stride = if ipv6 { 38 } else { 26 };
let matching: Vec<&CompactNode> = nodes
.iter()
.filter(|node| match node.addr {
SocketAddr::V4(_) => !ipv6,
SocketAddr::V6(_) => ipv6,
})
.take(MAX_COMPACT_NODES)
.collect();
let mut out = vec![0u8; matching.len() * stride];
for (idx, node) in matching.iter().enumerate() {
let base = idx * stride;
out[base..base + 20].copy_from_slice(&node.id);
match node.addr {
SocketAddr::V4(v4) => {
out[base + 20..base + 24].copy_from_slice(&v4.ip().octets());
out[base + 24..base + 26].copy_from_slice(&v4.port().to_be_bytes());
}
SocketAddr::V6(v6) => {
out[base + 20..base + 36].copy_from_slice(&v6.ip().octets());
out[base + 36..base + 38].copy_from_slice(&v6.port().to_be_bytes());
}
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn rejects_oversized_compact_peer_blob() {
let raw = vec![0u8; 6 * (MAX_COMPACT_PEERS + 1)];
assert!(decode_peers(&raw, false).is_empty());
}
#[test]
fn encode_nodes_skips_mismatched_family() {
let v4 = CompactNode {
id: [1u8; 20],
addr: SocketAddr::from(([1, 2, 3, 4], 6881)),
};
let v6 = CompactNode {
id: [2u8; 20],
addr: SocketAddr::from(([0, 0, 0, 0, 0, 0, 0, 1], 6881)),
};
let encoded = encode_nodes(&[v4.clone(), v6.clone()], false);
assert_eq!(encoded.len(), 26);
let decoded = decode_nodes(&encoded, false);
assert_eq!(decoded.len(), 1);
assert_eq!(decoded[0].id, v4.id);
let encoded6 = encode_nodes(&[v4, v6], true);
assert_eq!(encoded6.len(), 38);
assert_eq!(decode_nodes(&encoded6, true).len(), 1);
}
#[test]
fn encode_peer_values_list_separates_families() {
use crate::bencode::BencodeValue;
let v4 = SocketAddr::from(([1, 2, 3, 4], 6881));
let v6 = SocketAddr::from(([0x2001, 0xdb8, 0, 0, 0, 0, 0, 1], 6881));
let list4 = encode_peer_values_list(&[v4, v6], false).expect("v4 list");
let BencodeValue::List(items4) = list4 else {
panic!("expected list");
};
assert_eq!(items4.len(), 1);
assert_eq!(items4[0].as_bytes().map(|b| b.len()), Some(6));
let list6 = encode_peer_values_list(&[v4, v6], true).expect("v6 list");
let BencodeValue::List(items6) = list6 else {
panic!("expected list");
};
assert_eq!(items6.len(), 1);
assert_eq!(items6[0].as_bytes().map(|b| b.len()), Some(18));
}
}