torrent 0.1.6

High-level async BitTorrent library — session management, HTTP/UDP tracker communication, DHT networking, peer connections, and file storage. Built on torrent-core with tokio.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

//! High-level DHT query wrappers — BEP 5.
//!
//! Each function accepts a [`DhtRpc`] client, builds the appropriate
//! KRPC message, sends it to the target address, and parses the response.

use std::net::SocketAddr;

use crate::error::{Error, ErrorKind};

use super::{Node, krpc, rpc::DhtRpc};

/// Find nodes close to a target ID (BEP 5 find_node).
///
/// Sends a find_node query and returns the list of closer nodes.
/// Used during DHT bootstrapping and recursive node lookup.
///
/// # Errors
///
/// Returns an error if the RPC call fails or the response is malformed.
pub async fn find_node(
    rpc: &DhtRpc, addr: SocketAddr, tid: krpc::TransactionId, node_id: &[u8; 20],
    target: &[u8; 20], want: Option<&[&str]>,
) -> Result<Vec<Node>, Error> {
    tracing::debug!("DHT find_node to {}", addr);
    let data = krpc::build_find_node(tid, node_id, target, want);
    let response = rpc.query(addr, tid, &data).await?;

    match &response {
        krpc::KrpcMessage::Response { result, .. } => {
            // Check nodes (IPv4 compact, BEP 5) and nodes6 (IPv6 compact, BEP 32).
            let mut nodes = Vec::new();
            if let Some(nodes_bytes) = krpc::dict_get_bytes(result, b"nodes") {
                nodes.extend(krpc::parse_compact_nodes4(nodes_bytes));
            }
            if let Some(nodes6_bytes) = krpc::dict_get_bytes(result, b"nodes6") {
                nodes.extend(krpc::parse_compact_nodes6(nodes6_bytes));
            }
            if nodes.is_empty() {
                Err(Error::new(ErrorKind::Protocol))
            } else {
                Ok(nodes)
            }
        }
        _ => Err(Error::new(ErrorKind::Protocol)),
    }
}

/// Get peers for an info_hash from the DHT (BEP 5 get_peers).
///
/// Queries a DHT node for peers sharing the torrent identified by `info_hash`.
/// The response may contain peer addresses (`Values` variant) or
/// closer DHT nodes for continued recursive lookup (`Nodes` variant).
///
/// # Errors
///
/// Returns an error if the RPC call fails or the response is malformed.
pub async fn get_peers(
    rpc: &DhtRpc, addr: SocketAddr, tid: krpc::TransactionId, node_id: &[u8; 20],
    info_hash: &[u8; 20], want: Option<&[&str]>,
) -> Result<krpc::GetPeersResult, Error> {
    tracing::debug!("DHT get_peers to {}", addr);
    let data = krpc::build_get_peers(tid, node_id, info_hash, want);
    let response = rpc.query(addr, tid, &data).await?;

    krpc::parse_get_peers_response(&response)
}

/// Announce that we are a peer for an info_hash (BEP 5 announce_peer).
///
/// Tells a DHT node that we are downloading the torrent identified by
/// `info_hash` on the given `port`. Requires a `token` obtained from
/// a previous `get_peers` response.
///
/// # Errors
///
/// Returns an error if the RPC call fails or the response is malformed.
pub async fn announce_peer(
    rpc: &DhtRpc, addr: SocketAddr, tid: krpc::TransactionId, node_id: &[u8; 20],
    info_hash: &[u8; 20], port: u16, token: &[u8],
) -> Result<(), Error> {
    tracing::debug!("DHT announce_peer to {} (port {})", addr, port);
    let data = krpc::build_announce_peer(tid, node_id, info_hash, port, token);
    let response = rpc.query(addr, tid, &data).await?;
    // Check for KRPC errors — e.g., "Bad token" from DHT node
    if matches!(&response, krpc::KrpcMessage::Error { .. }) {
        return Err(Error::new(ErrorKind::Protocol));
    }
    Ok(())
}