torrentdht 0.1.1

DHT discovery with mTLS handshake handoff; optional BitTorrent when the host opts in
Documentation
//! BEP 11 — Peer Exchange (ut_pex).

use std::net::SocketAddr;

use crate::error::{Error, Result};
use crate::wire::{decode_peers, decode_peers_auto, encode_peers};

#[derive(Debug, Clone, Default)]
pub struct PexDelta {
    pub added: Vec<SocketAddr>,
    pub dropped: Vec<SocketAddr>,
}

pub fn encode_pex(delta: &PexDelta) -> Result<Vec<u8>> {
    use std::collections::BTreeMap;

    use crate::bencode::{encode, BencodeValue};

    let added_v4 = encode_peers(&delta.added, false);
    let added_v6 = encode_peers(&delta.added, true);
    let dropped_v4 = encode_peers(&delta.dropped, false);
    let dropped_v6 = encode_peers(&delta.dropped, true);

    let mut dict = BTreeMap::new();
    if !added_v4.is_empty() {
        dict.insert(b"added".to_vec(), BencodeValue::Bytes(added_v4));
    }
    if !added_v6.is_empty() {
        dict.insert(b"added6".to_vec(), BencodeValue::Bytes(added_v6));
    }
    if !dropped_v4.is_empty() {
        dict.insert(b"dropped".to_vec(), BencodeValue::Bytes(dropped_v4));
    }
    if !dropped_v6.is_empty() {
        dict.insert(b"dropped6".to_vec(), BencodeValue::Bytes(dropped_v6));
    }
    if dict.is_empty() {
        return Err(Error::Peer("empty pex message".into()));
    }
    Ok(encode(&BencodeValue::Dict(dict)))
}

pub fn decode_pex(payload: &[u8]) -> Result<PexDelta> {
    let value = crate::bencode::decode_with_limits(payload, crate::security::DecodeLimits::NETWORK)?;
    let mut added = value
        .dict_get(b"added".as_ref())
        .and_then(|v| v.as_bytes())
        .map(decode_peers_auto)
        .unwrap_or_default();
    if let Some(raw) = value.dict_get(b"added6".as_ref()).and_then(|v| v.as_bytes()) {
        added.extend(decode_peers(raw, true));
    }
    let mut dropped = value
        .dict_get(b"dropped".as_ref())
        .and_then(|v| v.as_bytes())
        .map(decode_peers_auto)
        .unwrap_or_default();
    if let Some(raw) = value.dict_get(b"dropped6".as_ref()).and_then(|v| v.as_bytes()) {
        dropped.extend(decode_peers(raw, true));
    }
    if added.is_empty() && dropped.is_empty() {
        return Err(Error::Peer("empty pex message".into()));
    }
    Ok(PexDelta { added, dropped })
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::net::{Ipv4Addr, Ipv6Addr, SocketAddrV4, SocketAddrV6};

    #[test]
    fn pex_roundtrip_ipv4() {
        let addr = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(192, 168, 1, 1), 6881));
        let payload = encode_pex(&PexDelta {
            added: vec![addr],
            dropped: vec![],
        })
        .expect("encode");
        let decoded = decode_pex(&payload).expect("decode");
        assert_eq!(decoded.added, vec![addr]);
    }

    #[test]
    fn pex_roundtrip_ipv6() {
        let addr = SocketAddr::V6(SocketAddrV6::new(Ipv6Addr::LOCALHOST, 6881, 0, 0));
        let payload = encode_pex(&PexDelta {
            added: vec![addr],
            dropped: vec![],
        })
        .expect("encode");
        let decoded = decode_pex(&payload).expect("decode");
        assert_eq!(decoded.added, vec![addr]);
    }
}