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

//! Owned, validated protocol values; no transport authority.
use super::SharedBlock;
use crate::protocol::peer::message::Message;
use std::{fmt, io, sync::Arc};

#[derive(Clone)]
pub(in crate::engine) struct Frame {
    pub(in crate::engine) bytes: Arc<Vec<u8>>,
}
impl Frame {
    pub(in crate::engine) fn from_message(message: Message<'_>, limit: u32) -> io::Result<Self> {
        let len = message.encoded_len(limit).map_err(io::Error::other)?;
        let mut bytes = vec![0; len];
        message
            .encode(&mut bytes, limit)
            .map_err(io::Error::other)?;
        Ok(Self {
            bytes: Arc::new(bytes),
        })
    }
    pub(in crate::engine) fn wire_len(&self) -> usize {
        self.bytes.len()
    }
    pub(in crate::engine) fn piece_block(&self) -> SharedBlock {
        let Message::Piece { block, .. } = self.message() else {
            unreachable!("Piece frame")
        };
        SharedBlock::from_shared(
            self.bytes.clone(),
            self.bytes.len() - block.len()..self.bytes.len(),
        )
    }
    pub(in crate::engine) fn message(&self) -> Message<'_> {
        Message::decode(&self.bytes, u32::MAX)
            .expect("validated frame")
            .0
    }
}
impl fmt::Debug for Frame {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Frame")
            .field("wire_bytes", &self.bytes.len())
            .finish()
    }
}

use crate::engine::core::fault::peer::invalid_message;
pub(in crate::engine) enum Outbound {
    Encoded(Vec<u8>),
    Piece {
        header: [u8; 13],
        block: crate::engine::core::SharedBlock,
    },
}
impl From<Vec<u8>> for Outbound {
    fn from(bytes: Vec<u8>) -> Self {
        Self::Encoded(bytes)
    }
}
impl Outbound {
    pub(in crate::engine) fn header(&self) -> &[u8] {
        match self {
            Self::Encoded(bytes) => bytes,
            Self::Piece { header, .. } => header,
        }
    }
    pub(in crate::engine) fn payload(&self) -> &[u8] {
        match self {
            Self::Encoded(_) => &[],
            Self::Piece { block, .. } => block,
        }
    }
    pub(in crate::engine) fn len(&self) -> usize {
        self.header().len() + self.payload().len()
    }
    pub(in crate::engine) fn message(&self, limit: u32) -> io::Result<Message<'_>> {
        match self {
            Self::Encoded(bytes) => Message::decode(bytes, limit)
                .map(|(m, _)| m)
                .map_err(invalid_message),
            Self::Piece { header, block } => Ok(Message::Piece {
                index: u32::from_be_bytes(header[5..9].try_into().expect("piece index")),
                begin: u32::from_be_bytes(header[9..13].try_into().expect("piece begin")),
                block,
            }),
        }
    }
    pub(in crate::engine) fn payload_start(&self) -> usize {
        match self.message(u32::MAX) {
            Ok(Message::Piece { block, .. }) => self.len() - block.len(),
            _ => self.len(),
        }
    }
}