use std::collections::BTreeMap;
use crate::bittorrent::bencode::codec::BencodeValue;
use super::{COMPACT_PEER_V4_SIZE, COMPACT_PEER_V6_SIZE, decode_compact_v4, decode_compact_v6};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CompactPeerV4(pub [u8; 6]);
impl CompactPeerV4 {
pub fn ip(&self) -> &[u8; 4] {
self.0[..4].try_into().unwrap()
}
pub fn port(&self) -> u16 {
u16::from_be_bytes([self.0[4], self.0[5]])
}
pub fn to_peer_addr(&self) -> crate::bittorrent::peer::address::PeerAddr {
let ip = std::net::Ipv4Addr::from(*self.ip()).to_string();
crate::bittorrent::peer::address::PeerAddr::new(&ip, self.port())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CompactPeerV6(pub [u8; 18]);
impl CompactPeerV6 {
pub fn ip(&self) -> &[u8; 16] {
self.0[..16].try_into().unwrap()
}
pub fn port(&self) -> u16 {
u16::from_be_bytes([self.0[16], self.0[17]])
}
pub fn to_peer_addr(&self) -> crate::bittorrent::peer::address::PeerAddr {
let ip = std::net::Ipv6Addr::from(*self.ip()).to_string();
crate::bittorrent::peer::address::PeerAddr::new(&ip, self.port())
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UtPexMessage {
pub added: Vec<CompactPeerV4>,
pub added_f: Vec<u8>,
pub added6: Vec<CompactPeerV6>,
pub added6_f: Vec<u8>,
pub dropped: Vec<CompactPeerV4>,
pub dropped6: Vec<CompactPeerV6>,
}
impl UtPexMessage {
pub fn new() -> Self {
Self {
added: Vec::new(),
added_f: Vec::new(),
added6: Vec::new(),
added6_f: Vec::new(),
dropped: Vec::new(),
dropped6: Vec::new(),
}
}
pub fn from_peer_addrs(
added: &[crate::bittorrent::peer::address::PeerAddr],
dropped: &[crate::bittorrent::peer::address::PeerAddr],
) -> Self {
let mut message = Self::new();
for peer in added {
if let Some(compact) = peer.to_compact_v4() {
message.added.push(CompactPeerV4(compact));
message.added_f.push(0);
} else if let Some(compact) = peer.to_compact_v6() {
message.added6.push(CompactPeerV6(compact));
message.added6_f.push(0);
}
}
for peer in dropped {
if let Some(compact) = peer.to_compact_v4() {
message.dropped.push(CompactPeerV4(compact));
} else if let Some(compact) = peer.to_compact_v6() {
message.dropped6.push(CompactPeerV6(compact));
}
}
message
}
pub fn to_payload(&self) -> Vec<u8> {
self.to_bencode_value().encode()
}
pub(crate) fn to_bencode_value(&self) -> BencodeValue {
let mut dict = BTreeMap::new();
if !self.added.is_empty() {
let mut compact = Vec::with_capacity(self.added.len() * COMPACT_PEER_V4_SIZE);
for peer in &self.added {
compact.extend_from_slice(&peer.0);
}
dict.insert(b"added".to_vec(), BencodeValue::Bytes(compact));
if !self.added_f.is_empty() {
dict.insert(
b"added.f".to_vec(),
BencodeValue::Bytes(self.added_f.clone()),
);
}
}
if !self.added6.is_empty() {
let mut compact = Vec::with_capacity(self.added6.len() * COMPACT_PEER_V6_SIZE);
for peer in &self.added6 {
compact.extend_from_slice(&peer.0);
}
dict.insert(b"added6".to_vec(), BencodeValue::Bytes(compact));
if !self.added6_f.is_empty() {
dict.insert(
b"added6.f".to_vec(),
BencodeValue::Bytes(self.added6_f.clone()),
);
}
}
if !self.dropped.is_empty() {
let mut compact = Vec::with_capacity(self.dropped.len() * COMPACT_PEER_V4_SIZE);
for peer in &self.dropped {
compact.extend_from_slice(&peer.0);
}
dict.insert(b"dropped".to_vec(), BencodeValue::Bytes(compact));
}
if !self.dropped6.is_empty() {
let mut compact = Vec::with_capacity(self.dropped6.len() * COMPACT_PEER_V6_SIZE);
for peer in &self.dropped6 {
compact.extend_from_slice(&peer.0);
}
dict.insert(b"dropped6".to_vec(), BencodeValue::Bytes(compact));
}
BencodeValue::Dict(dict)
}
pub fn from_payload(payload: &[u8]) -> Result<Self, String> {
let (val, _) = BencodeValue::decode(payload)
.map_err(|e| format!("Failed to decode ut_pex payload: {}", e))?;
Self::from_bencode_value(&val)
}
pub(crate) fn from_bencode_value(value: &BencodeValue) -> Result<Self, String> {
let dict = value
.as_dict()
.ok_or("ut_pex payload is not a bencoded dict")?;
let added = if let Some(bytes) = dict.get(b"added".as_slice()).and_then(|v| v.as_bytes()) {
decode_compact_v4(bytes)?
} else {
Vec::new()
};
let added_f = dict
.get(b"added.f".as_slice())
.and_then(|v| v.as_bytes())
.map(|b| b.to_vec())
.unwrap_or_default();
let added6 = if let Some(bytes) = dict.get(b"added6".as_slice()).and_then(|v| v.as_bytes())
{
decode_compact_v6(bytes)?
} else {
Vec::new()
};
let added6_f = dict
.get(b"added6.f".as_slice())
.and_then(|v| v.as_bytes())
.map(|b| b.to_vec())
.unwrap_or_default();
let dropped =
if let Some(bytes) = dict.get(b"dropped".as_slice()).and_then(|v| v.as_bytes()) {
decode_compact_v4(bytes)?
} else {
Vec::new()
};
let dropped6 =
if let Some(bytes) = dict.get(b"dropped6".as_slice()).and_then(|v| v.as_bytes()) {
decode_compact_v6(bytes)?
} else {
Vec::new()
};
Ok(Self {
added,
added_f,
added6,
added6_f,
dropped,
dropped6,
})
}
}
impl Default for UtPexMessage {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_pex_empty_message() {
let msg = UtPexMessage::new();
assert!(msg.added.is_empty());
assert!(msg.added6.is_empty());
assert!(msg.added_f.is_empty());
assert!(msg.added6_f.is_empty());
assert!(msg.dropped.is_empty());
assert!(msg.dropped6.is_empty());
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert!(parsed.added.is_empty());
assert!(parsed.added6.is_empty());
assert!(parsed.dropped.is_empty());
assert!(parsed.dropped6.is_empty());
}
#[test]
fn test_pex_v4_peers_roundtrip() {
let mut msg = UtPexMessage::new();
let mut peer1 = [0u8; 6];
peer1[..4].copy_from_slice(&[192, 168, 1, 1]);
peer1[4..6].copy_from_slice(&6881u16.to_be_bytes());
msg.added.push(CompactPeerV4(peer1));
let mut peer2 = [0u8; 6];
peer2[..4].copy_from_slice(&[10, 0, 0, 1]);
peer2[4..6].copy_from_slice(&6882u16.to_be_bytes());
msg.added.push(CompactPeerV4(peer2));
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert_eq!(parsed.added.len(), 2);
assert_eq!(parsed.added[0], CompactPeerV4(peer1));
assert_eq!(parsed.added[1], CompactPeerV4(peer2));
}
#[test]
fn test_pex_v6_peers_roundtrip() {
let mut msg = UtPexMessage::new();
let mut peer1 = [0u8; 18];
peer1[15] = 1; peer1[16..18].copy_from_slice(&6881u16.to_be_bytes());
msg.added6.push(CompactPeerV6(peer1));
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert_eq!(parsed.added6.len(), 1);
assert_eq!(parsed.added6[0], CompactPeerV6(peer1));
}
#[test]
fn test_pex_mixed_v4_v6_roundtrip() {
let mut msg = UtPexMessage::new();
let mut v4 = [0u8; 6];
v4[..4].copy_from_slice(&[172, 16, 0, 1]);
v4[4..6].copy_from_slice(&6883u16.to_be_bytes());
msg.added.push(CompactPeerV4(v4));
let mut v6 = [0u8; 18];
v6[..16].copy_from_slice(&[0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
v6[16..18].copy_from_slice(&6884u16.to_be_bytes());
msg.added6.push(CompactPeerV6(v6));
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert_eq!(parsed.added.len(), 1);
assert_eq!(parsed.added6.len(), 1);
assert_eq!(parsed.added[0].port(), 6883);
assert_eq!(parsed.added6[0].port(), 6884);
}
#[test]
fn test_pex_invalid_v4_data_length() {
let mut dict = BTreeMap::new();
dict.insert(b"added".to_vec(), BencodeValue::Bytes(vec![1, 2, 3, 4, 5]));
let payload = BencodeValue::Dict(dict).encode();
let result = UtPexMessage::from_payload(&payload);
assert!(result.is_err());
assert!(result.unwrap_err().contains("IPv4"));
}
#[test]
fn test_pex_invalid_v6_data_length() {
let mut dict = BTreeMap::new();
dict.insert(b"added6".to_vec(), BencodeValue::Bytes(vec![0u8; 17]));
let payload = BencodeValue::Dict(dict).encode();
let result = UtPexMessage::from_payload(&payload);
assert!(result.is_err());
assert!(result.unwrap_err().contains("IPv6"));
}
#[test]
fn test_pex_not_a_dict() {
let payload = BencodeValue::List(vec![]).encode();
let result = UtPexMessage::from_payload(&payload);
assert!(result.is_err());
assert!(result.unwrap_err().contains("not a bencoded dict"));
}
#[test]
fn test_compact_peer_v4_accessors() {
let mut bytes = [0u8; 6];
bytes[..4].copy_from_slice(&[127, 0, 0, 1]);
bytes[4..6].copy_from_slice(&8080u16.to_be_bytes());
let peer = CompactPeerV4(bytes);
assert_eq!(peer.ip(), &[127, 0, 0, 1]);
assert_eq!(peer.port(), 8080);
}
#[test]
fn test_compact_peer_v6_accessors() {
let mut bytes = [0u8; 18];
bytes[15] = 1; bytes[16..18].copy_from_slice(&9999u16.to_be_bytes());
let peer = CompactPeerV6(bytes);
assert_eq!(peer.port(), 9999);
assert_eq!(peer.ip()[15], 1);
}
#[test]
fn test_pex_dropped_v4_roundtrip() {
let mut msg = UtPexMessage::new();
let mut peer = [0u8; 6];
peer[..4].copy_from_slice(&[192, 168, 1, 1]);
peer[4..6].copy_from_slice(&6881u16.to_be_bytes());
msg.dropped.push(CompactPeerV4(peer));
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert!(parsed.added.is_empty());
assert!(parsed.added6.is_empty());
assert_eq!(parsed.dropped.len(), 1);
assert_eq!(parsed.dropped[0].port(), 6881);
}
#[test]
fn test_pex_dropped_v6_roundtrip() {
let mut msg = UtPexMessage::new();
let mut peer = [0u8; 18];
peer[15] = 1; peer[16..18].copy_from_slice(&6881u16.to_be_bytes());
msg.dropped6.push(CompactPeerV6(peer));
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert!(parsed.added.is_empty());
assert!(parsed.added6.is_empty());
assert_eq!(parsed.dropped6.len(), 1);
assert_eq!(parsed.dropped6[0].port(), 6881);
}
#[test]
fn test_pex_added_f_roundtrip() {
let mut msg = UtPexMessage::new();
let mut peer1 = [0u8; 6];
peer1[..4].copy_from_slice(&[10, 0, 0, 1]);
peer1[4..6].copy_from_slice(&6881u16.to_be_bytes());
msg.added.push(CompactPeerV4(peer1));
let mut peer2 = [0u8; 6];
peer2[..4].copy_from_slice(&[10, 0, 0, 2]);
peer2[4..6].copy_from_slice(&6882u16.to_be_bytes());
msg.added.push(CompactPeerV4(peer2));
msg.added_f = vec![0x01, 0x03];
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert_eq!(parsed.added_f.len(), 2);
assert_eq!(parsed.added_f[0], 0x01);
assert_eq!(parsed.added_f[1], 0x03);
}
#[test]
fn test_pex_added6_f_roundtrip() {
let mut msg = UtPexMessage::new();
let mut peer = [0u8; 18];
peer[..16].copy_from_slice(&[0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);
peer[16..18].copy_from_slice(&6881u16.to_be_bytes());
msg.added6.push(CompactPeerV6(peer));
msg.added6_f = vec![0x02];
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert_eq!(parsed.added6_f.len(), 1);
assert_eq!(parsed.added6_f[0], 0x02);
}
#[test]
fn test_pex_full_bep11_roundtrip() {
let mut msg = UtPexMessage::new();
let mut v4_added = [0u8; 6];
v4_added[..4].copy_from_slice(&[192, 168, 1, 1]);
v4_added[4..6].copy_from_slice(&6881u16.to_be_bytes());
msg.added.push(CompactPeerV4(v4_added));
msg.added_f.push(0x02);
let mut v6_added = [0u8; 18];
v6_added[15] = 1;
v6_added[16..18].copy_from_slice(&6882u16.to_be_bytes());
msg.added6.push(CompactPeerV6(v6_added));
msg.added6_f.push(0x01);
let mut v4_dropped = [0u8; 6];
v4_dropped[..4].copy_from_slice(&[10, 0, 0, 1]);
v4_dropped[4..6].copy_from_slice(&6883u16.to_be_bytes());
msg.dropped.push(CompactPeerV4(v4_dropped));
let mut v6_dropped = [0u8; 18];
v6_dropped[15] = 2;
v6_dropped[16..18].copy_from_slice(&6884u16.to_be_bytes());
msg.dropped6.push(CompactPeerV6(v6_dropped));
let payload = msg.to_payload();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert_eq!(parsed.added.len(), 1);
assert_eq!(parsed.added_f.len(), 1);
assert_eq!(parsed.added_f[0], 0x02);
assert_eq!(parsed.added6.len(), 1);
assert_eq!(parsed.added6_f.len(), 1);
assert_eq!(parsed.added6_f[0], 0x01);
assert_eq!(parsed.dropped.len(), 1);
assert_eq!(parsed.dropped[0].port(), 6883);
assert_eq!(parsed.dropped6.len(), 1);
assert_eq!(parsed.dropped6[0].port(), 6884);
}
#[test]
fn test_pex_parse_dropped6_without_added6() {
let mut dict = BTreeMap::new();
let mut v6_dropped = [0u8; 18];
v6_dropped[15] = 1;
v6_dropped[16..18].copy_from_slice(&6881u16.to_be_bytes());
dict.insert(
b"dropped6".to_vec(),
BencodeValue::Bytes(v6_dropped.to_vec()),
);
let payload = BencodeValue::Dict(dict).encode();
let parsed = UtPexMessage::from_payload(&payload).unwrap();
assert!(parsed.added.is_empty());
assert!(parsed.added6.is_empty());
assert!(parsed.dropped.is_empty());
assert_eq!(parsed.dropped6.len(), 1);
}
}