webtorrent-rs 1.0.2

Streaming torrent client for Rust - 1:1 port of webtorrent
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

use crate::error::Result;
use bytes::Bytes;
use std::collections::HashMap;

/// BitTorrent extension protocol handler
pub struct ExtensionProtocol {
    extensions: HashMap<u8, ExtensionInfo>,
    #[allow(dead_code)]
    handshake: Option<Bytes>,
}

#[derive(Debug, Clone)]
pub struct ExtensionInfo {
    pub id: u8,
    pub name: String,
    pub metadata_size: Option<usize>,
}

/// ut_metadata extension
pub struct UtMetadata {
    metadata: Option<Bytes>,
    metadata_size: Option<usize>,
}

impl UtMetadata {
    pub fn new() -> Self {
        Self {
            metadata: None,
            metadata_size: None,
        }
    }

    pub fn set_metadata(&mut self, metadata: Bytes) {
        let len = metadata.len();
        self.metadata = Some(metadata);
        self.metadata_size = Some(len);
    }

    pub fn get_metadata(&self) -> Option<&Bytes> {
        self.metadata.as_ref()
    }

    pub fn fetch(&self) -> Result<()> {
        // Request metadata from peer
        Ok(())
    }

    pub fn handle_request(&self, piece: usize) -> Result<Option<Bytes>> {
        if let Some(ref metadata) = self.metadata {
            let piece_size = 16 * 1024; // 16 KB per piece
            let start = piece * piece_size;
            let end = (start + piece_size).min(metadata.len());
            if start < metadata.len() {
                return Ok(Some(metadata.slice(start..end)));
            }
        }
        Ok(None)
    }
}

/// ut_pex extension (Peer Exchange)
pub struct UtPex {
    added: Vec<(String, u16)>,
    dropped: Vec<(String, u16)>,
}

impl UtPex {
    pub fn new() -> Self {
        Self {
            added: Vec::new(),
            dropped: Vec::new(),
        }
    }

    pub fn add_peer(&mut self, ip: String, port: u16) {
        self.added.push((ip, port));
    }

    pub fn drop_peer(&mut self, ip: String, port: u16) {
        self.dropped.push((ip, port));
    }

    pub fn get_added(&self) -> &[(String, u16)] {
        &self.added
    }

    pub fn get_dropped(&self) -> &[(String, u16)] {
        &self.dropped
    }

    pub fn reset(&mut self) {
        self.added.clear();
        self.dropped.clear();
    }

    pub fn encode(&self) -> Bytes {
        // Encode peer list in compact format
        let mut buf = Vec::new();
        for (ip, port) in &self.added {
            if let Ok(ip_bytes) = ip.parse::<std::net::Ipv4Addr>() {
                buf.extend_from_slice(&ip_bytes.octets());
                buf.extend_from_slice(&port.to_be_bytes());
            }
        }
        Bytes::from(buf)
    }

    pub fn decode(data: &[u8]) -> Result<Vec<(String, u16)>> {
        let mut peers = Vec::new();
        for chunk in data.chunks_exact(6) {
            let ip = format!("{}.{}.{}.{}", chunk[0], chunk[1], chunk[2], chunk[3]);
            let port = u16::from_be_bytes([chunk[4], chunk[5]]);
            peers.push((ip, port));
        }
        Ok(peers)
    }
}

impl ExtensionProtocol {
    pub fn new() -> Self {
        Self {
            extensions: HashMap::new(),
            handshake: None,
        }
    }

    pub fn register_extension(&mut self, id: u8, name: String) {
        self.extensions.insert(id, ExtensionInfo {
            id,
            name,
            metadata_size: None,
        });
    }

    pub fn get_extension_id(&self, name: &str) -> Option<u8> {
        self.extensions.values()
            .find(|ext| ext.name == name)
            .map(|ext| ext.id)
    }
}