rbit 0.2.2

A BitTorrent library implementing BEP specifications
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};

/// A peer returned from a tracker.
///
/// This struct includes the optional peer ID which may be present in
/// non-compact tracker responses.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Peer {
    /// The peer's socket address (IP and port).
    pub addr: SocketAddr,
    /// The peer's 20-byte ID (optional, not present in compact responses).
    pub peer_id: Option<[u8; 20]>,
}

impl Peer {
    /// Creates a new peer with just an address.
    pub fn new(addr: SocketAddr) -> Self {
        Self {
            addr,
            peer_id: None,
        }
    }

    /// Creates a new peer with address and peer ID.
    pub fn with_id(addr: SocketAddr, peer_id: [u8; 20]) -> Self {
        Self {
            addr,
            peer_id: Some(peer_id),
        }
    }

    /// Parses a peer from compact IPv4 format (6 bytes).
    ///
    /// Format: 4 bytes IP + 2 bytes port (big-endian).
    pub fn from_compact_v4(bytes: &[u8]) -> Option<Self> {
        if bytes.len() < 6 {
            return None;
        }
        let ip = Ipv4Addr::new(bytes[0], bytes[1], bytes[2], bytes[3]);
        let port = u16::from_be_bytes([bytes[4], bytes[5]]);
        Some(Self {
            addr: SocketAddr::new(IpAddr::V4(ip), port),
            peer_id: None,
        })
    }

    /// Parses a peer from compact IPv6 format (18 bytes).
    ///
    /// Format: 16 bytes IP + 2 bytes port (big-endian).
    pub fn from_compact_v6(bytes: &[u8]) -> Option<Self> {
        if bytes.len() < 18 {
            return None;
        }
        let mut ip_bytes = [0u8; 16];
        ip_bytes.copy_from_slice(&bytes[..16]);
        let ip = Ipv6Addr::from(ip_bytes);
        let port = u16::from_be_bytes([bytes[16], bytes[17]]);
        Some(Self {
            addr: SocketAddr::new(IpAddr::V6(ip), port),
            peer_id: None,
        })
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TrackerEvent {
    None,
    Started,
    Stopped,
    Completed,
}

impl TrackerEvent {
    pub fn as_str(&self) -> &'static str {
        match self {
            TrackerEvent::None => "",
            TrackerEvent::Started => "started",
            TrackerEvent::Stopped => "stopped",
            TrackerEvent::Completed => "completed",
        }
    }

    pub fn as_udp_id(&self) -> u32 {
        match self {
            TrackerEvent::None => 0,
            TrackerEvent::Completed => 1,
            TrackerEvent::Started => 2,
            TrackerEvent::Stopped => 3,
        }
    }
}

#[derive(Debug, Clone)]
pub struct AnnounceResponse {
    pub interval: u32,
    pub min_interval: Option<u32>,
    pub complete: Option<u32>,
    pub incomplete: Option<u32>,
    pub peers: Vec<SocketAddr>,
    pub peers6: Vec<SocketAddr>,
    pub warning_message: Option<String>,
    pub tracker_id: Option<String>,
}

impl AnnounceResponse {
    pub fn new(interval: u32) -> Self {
        Self {
            interval,
            min_interval: None,
            complete: None,
            incomplete: None,
            peers: Vec::new(),
            peers6: Vec::new(),
            warning_message: None,
            tracker_id: None,
        }
    }

    pub fn all_peers(&self) -> impl Iterator<Item = &SocketAddr> {
        self.peers.iter().chain(self.peers6.iter())
    }
}

#[derive(Debug, Clone)]
pub struct ScrapeResponse {
    pub files: Vec<ScrapeFile>,
}

#[derive(Debug, Clone)]
pub struct ScrapeFile {
    pub info_hash: [u8; 20],
    pub complete: u32,
    pub incomplete: u32,
    pub downloaded: u32,
}

#[derive(Debug, Clone, Copy)]
pub struct CompactPeer {
    pub ip: IpAddr,
    pub port: u16,
}

impl CompactPeer {
    pub fn from_v4_bytes(bytes: &[u8]) -> Option<Self> {
        if bytes.len() < 6 {
            return None;
        }
        let ip = Ipv4Addr::new(bytes[0], bytes[1], bytes[2], bytes[3]);
        let port = u16::from_be_bytes([bytes[4], bytes[5]]);
        Some(Self {
            ip: IpAddr::V4(ip),
            port,
        })
    }

    pub fn from_v6_bytes(bytes: &[u8]) -> Option<Self> {
        if bytes.len() < 18 {
            return None;
        }
        let mut ip_bytes = [0u8; 16];
        ip_bytes.copy_from_slice(&bytes[..16]);
        let ip = Ipv6Addr::from(ip_bytes);
        let port = u16::from_be_bytes([bytes[16], bytes[17]]);
        Some(Self {
            ip: IpAddr::V6(ip),
            port,
        })
    }

    pub fn to_socket_addr(&self) -> SocketAddr {
        SocketAddr::new(self.ip, self.port)
    }
}

pub fn parse_compact_peers(data: &[u8]) -> Vec<SocketAddr> {
    data.chunks_exact(6)
        .filter_map(CompactPeer::from_v4_bytes)
        .map(|p| p.to_socket_addr())
        .collect()
}

pub fn parse_compact_peers6(data: &[u8]) -> Vec<SocketAddr> {
    data.chunks_exact(18)
        .filter_map(CompactPeer::from_v6_bytes)
        .map(|p| p.to_socket_addr())
        .collect()
}