aria2-protocol 0.3.7

Multi-protocol networking stack for aria2-rust: HTTP/HTTPS client, FTP/SFTP, full BitTorrent (DHT/PEX/MSE), and Metalink V3/V4 parser
Documentation
use super::super::{DhtEngine, DhtEngineConfig};
use crate::bittorrent::bencode::codec::BencodeValue;
use crate::bittorrent::dht::message::{DhtMessage, DhtMessageBuilder};
use std::collections::BTreeMap;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::time::Duration;
use tokio::net::UdpSocket;

async fn assert_lookup_uses_only_socket_family(use_ipv6: bool, use_find_node: bool) {
    const INFO_HASH: [u8; 20] = [0x45; 20];
    let ipv4_node = UdpSocket::bind("127.0.0.1:0")
        .await
        .expect("IPv4 candidate should bind");
    let ipv4_node_addr = ipv4_node.local_addr().unwrap();
    let ipv6_node = UdpSocket::bind("[::1]:0")
        .await
        .expect("IPv6 candidate should bind");
    let ipv6_node_addr = ipv6_node.local_addr().unwrap();
    let IpAddr::V4(ipv4_node_ip) = ipv4_node_addr.ip() else {
        unreachable!("fixture is bound to IPv4 loopback")
    };
    let IpAddr::V6(ipv6_node_ip) = ipv6_node_addr.ip() else {
        unreachable!("fixture is bound to IPv6 loopback")
    };
    let bind_addr = if use_ipv6 { "[::1]:0" } else { "127.0.0.1:0" };
    let responder = UdpSocket::bind(bind_addr)
        .await
        .expect("loopback DHT responder should bind");
    let responder_addr = responder.local_addr().unwrap();
    let responder_task = tokio::spawn(async move {
        let mut packet = [0u8; 4096];
        loop {
            let (length, source) =
                tokio::time::timeout(Duration::from_secs(2), responder.recv_from(&mut packet))
                    .await
                    .expect("engine should issue DHT queries")
                    .expect("receive DHT query");
            let query = DhtMessage::decode(&packet[..length]).expect("valid DHT query");
            match query.q.as_ref().map(|method| method.0.as_str()) {
                Some("ping") => {
                    let response = DhtMessageBuilder::ping_response(&query.t, &[0x30; 20]);
                    responder.send_to(&response.encode(), source).await.unwrap();
                }
                Some("get_peers") | Some("find_node") => {
                    let mut nodes = vec![0x31; 20];
                    nodes.extend_from_slice(&ipv4_node_ip.octets());
                    nodes.extend_from_slice(&ipv4_node_addr.port().to_be_bytes());
                    let mut nodes6 = vec![0x32; 20];
                    nodes6.extend_from_slice(&ipv6_node_ip.octets());
                    nodes6.extend_from_slice(&ipv6_node_addr.port().to_be_bytes());

                    let mut result = BTreeMap::new();
                    result.insert(b"id".to_vec(), BencodeValue::Bytes([0x30; 20].to_vec()));
                    result.insert(b"token".to_vec(), BencodeValue::Bytes(b"token".to_vec()));
                    result.insert(b"nodes".to_vec(), BencodeValue::Bytes(nodes));
                    result.insert(b"nodes6".to_vec(), BencodeValue::Bytes(nodes6));
                    result.insert(
                        b"values".to_vec(),
                        BencodeValue::List(vec![
                            BencodeValue::Bytes(vec![127, 0, 0, 1, 0x1A, 0xE1]),
                            BencodeValue::Bytes(
                                Ipv6Addr::LOCALHOST
                                    .octets()
                                    .into_iter()
                                    .chain(6882u16.to_be_bytes())
                                    .collect(),
                            ),
                        ]),
                    );
                    let response = DhtMessage::new_response(query.t, BencodeValue::Dict(result));
                    responder.send_to(&response.encode(), source).await.unwrap();
                    break;
                }
                method => panic!("unexpected DHT query: {method:?}"),
            }
        }
    });

    let local_ip = if use_ipv6 {
        IpAddr::V6(Ipv6Addr::LOCALHOST)
    } else {
        IpAddr::V4(Ipv4Addr::LOCALHOST)
    };
    let engine = DhtEngine::start(DhtEngineConfig {
        listen_addr: Some(local_ip),
        query_timeout: Duration::from_millis(30),
        ..DhtEngineConfig::local()
    })
    .await
    .expect("DHT engine should start");
    engine.add_node(responder_addr).await;

    if use_find_node {
        let result = crate::bittorrent::dht::lookup::iterative_find_node(
            &INFO_HASH,
            &engine.context.task_context.self_id,
            &engine.context.task_context.routing_table,
            &engine.context.task_context.socket,
            &engine.context.task_context.tracker,
            Duration::from_millis(30),
        )
        .await;
        assert!(
            result
                .closest_nodes
                .iter()
                .all(|node| node.addr().is_ipv6() == use_ipv6),
            "find_node must not admit nodes from the other address family: {:?}",
            result.closest_nodes
        );
    } else {
        let result = engine
            .find_peers(&INFO_HASH)
            .await
            .expect("peer lookup should complete");
        let expected_peer: SocketAddr = if use_ipv6 {
            "[::1]:6882".parse().unwrap()
        } else {
            "127.0.0.1:6881".parse().unwrap()
        };
        assert_eq!(result.peers, vec![expected_peer]);
    }
    assert_eq!(engine.stats().await.total_nodes, 2);

    engine.shutdown_async().await;
    responder_task.await.expect("DHT responder should finish");
}

#[tokio::test]
async fn ipv4_lookup_ignores_ipv6_nodes_and_peers_from_dual_stack_reply() {
    assert_lookup_uses_only_socket_family(false, false).await;
}

#[tokio::test]
async fn ipv6_lookup_ignores_ipv4_nodes_and_peers_from_dual_stack_reply() {
    assert_lookup_uses_only_socket_family(true, false).await;
}

#[tokio::test]
async fn ipv4_find_node_ignores_ipv6_nodes_from_dual_stack_reply() {
    assert_lookup_uses_only_socket_family(false, true).await;
}

#[tokio::test]
async fn ipv6_find_node_ignores_ipv4_nodes_from_dual_stack_reply() {
    assert_lookup_uses_only_socket_family(true, true).await;
}