spill 0.5.1

Modern torrent client
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

//! Shared ownership without a self-referential parse tree. Byte fields are
//! offsets into immutable source bytes; layout paths own their components.

use super::*;
use std::sync::Arc;

/// Cheaply cloned, Send + Sync v1 metainfo with no caller-buffer lifetime.
/// Original outer/info bytes are retained verbatim, including noncanonical
/// encodings, duplicate/unknown fields and binary values. Identity never uses
/// re-encoding. No storage, networking or daemon admission policy lives here.
///
/// The same bencode input/string/node/depth budgets as Metainfo::parse bound
/// validation, retained source bytes, file/path metadata and copied path bytes.
/// The owned layout adds at most one copy of each retained path component; no
/// second piece-hash array or persistent decoded tree is retained. Allocation
/// overhead is additional and proportional to admitted bytes/nodes. Cloning
/// shares both the source and validated layout; it does not parse/copy either.
#[derive(Clone, Debug)]
pub struct OwnedMetainfo {
    data: Arc<Data>,
}

#[derive(Debug)]
struct Data {
    source: Arc<[u8]>,
    index: Index,
    limits: Limits,
}
#[derive(Debug)]
struct Index {
    info: Range<usize>,
    name: Range<usize>,
    hashes: Range<usize>,
    info_hash: InfoHashV1,
    private: bool,
    layout: Layout<'static>,
}

impl OwnedMetainfo {
    /// Validate before copying input. Only input.len() bytes are retained, not
    /// any spare capacity in a caller's Vec. Temporary decoder metadata is freed
    /// after validation/indexing; owned-allocation work is input/node bounded.
    pub fn parse(input: &[u8], limits: Limits) -> Result<Self, Error> {
        let parsed = Metainfo::parse(input, limits)?;
        let index = Index::new(input, parsed);
        Ok(Self {
            data: Arc::new(Data {
                source: Arc::from(input),
                index,
                limits,
            }),
        })
    }

    /// Borrow validated content fields without decoding/copying the catalog.
    pub fn view(&self) -> MetainfoView<'_> {
        MetainfoView {
            info_hash: self.info_hash(),
            layout: self.layout(),
            hashes: &self.data.source[self.data.index.hashes.clone()],
        }
    }
    pub fn source_bytes(&self) -> &[u8] {
        &self.data.source
    }
    pub fn info_bytes(&self) -> &[u8] {
        &self.data.source[self.data.index.info.clone()]
    }
    pub fn info_hash(&self) -> InfoHashV1 {
        self.data.index.info_hash
    }
    pub fn name(&self) -> &[u8] {
        &self.data.source[self.data.index.name.clone()]
    }
    pub fn is_private(&self) -> bool {
        self.data.index.private
    }
    pub fn layout(&self) -> &Layout<'static> {
        &self.data.index.layout
    }
    pub fn piece_hash(&self, index: u32) -> Option<&[u8; 20]> {
        hash_at(
            &self.data.source[self.data.index.hashes.clone()],
            index,
            self.layout().piece_count(),
        )
    }

    /// Explicitly decode outer discovery/unknown fields on demand. Allocates a
    /// temporary borrowed tree using the original admission budgets; not called
    /// by content/layout/hash accessors. The immutable validated source cannot
    /// become invalid between calls. Returned strings/spans borrow this handle.
    pub fn decode_document(&self) -> Node<'_> {
        bencode::decode(&self.data.source, self.data.limits)
            .expect("immutable validated metainfo document")
    }
}

impl Index {
    fn new(source: &[u8], parsed: Metainfo<'_>) -> Self {
        let Metainfo {
            info_bytes,
            info_hash,
            name,
            private,
            piece_hashes,
            layout,
            ..
        } = parsed;
        Self {
            info: span(source, info_bytes),
            name: span(source, name),
            hashes: span(source, piece_hashes),
            info_hash,
            private,
            layout: Layout {
                files: layout
                    .files
                    .into_iter()
                    .map(|file| File {
                        path: file
                            .path
                            .into_iter()
                            .map(|part| Cow::Owned(part.into_owned()))
                            .collect(),
                        offset: file.offset,
                        length: file.length,
                        kind: file.kind,
                    })
                    .collect(),
                total_length: layout.total_length,
                piece_length: layout.piece_length,
                piece_count: layout.piece_count,
                multi_file: layout.multi_file,
            },
        }
    }
}

// All inputs come from this module's validated borrowed parser. Preserve exact
// positions, not a byte-content search (identical fields may have different spans).
fn span(source: &[u8], part: &[u8]) -> Range<usize> {
    let start = (part.as_ptr() as usize)
        .checked_sub(source.as_ptr() as usize)
        .expect("decoded metainfo subslice");
    let end = start
        .checked_add(part.len())
        .filter(|&end| end <= source.len())
        .expect("decoded metainfo span within source");
    start..end
}