koibumi-core 0.0.9

The core library for Koibumi, an experimental Bitmessage 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

use std::io::{self, Read, Write};

use crate::{
    __impl_index,
    io::{ReadFrom, TooLongError, WriteTo},
    message::{InvHash, Message},
    packet::Command,
    var_type::VarInt,
};

/// An "inv" message that is used by a node to advertise
/// what objects it has.
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub struct Inv {
    list: Vec<InvHash>,
}

impl AsRef<[InvHash]> for Inv {
    fn as_ref(&self) -> &[InvHash] {
        &self.list
    }
}

__impl_index!(Inv, list, InvHash);

impl Inv {
    const MAX_COUNT: usize = 50000;

    /// The maximum count of the elements of a list the message can convey.
    /// This is the fixed value due to a historical bug of PyBitmessage.
    pub const MAX_COUNT_FIXED: usize = Self::MAX_COUNT - 1;

    /// Constructs an "inv" message from a list of inventory hashes.
    pub fn new(list: Vec<InvHash>) -> Result<Self, TooLongError> {
        if list.len() > Self::MAX_COUNT_FIXED {
            return Err(TooLongError::new(Self::MAX_COUNT_FIXED, list.len()));
        }
        Ok(Self { list })
    }
}

impl WriteTo for Inv {
    fn write_to(&self, w: &mut dyn Write) -> io::Result<()> {
        let count: VarInt = self.list.len().into();
        count.write_to(w)?;
        for a in &self.list {
            a.write_to(w)?
        }
        Ok(())
    }
}

impl ReadFrom for Inv {
    fn read_from(r: &mut dyn Read) -> io::Result<Self>
    where
        Self: Sized,
    {
        let count = VarInt::read_from(r)?;
        if count.as_u64() > Self::MAX_COUNT as u64 {
            return Err(io::Error::new(
                io::ErrorKind::Other,
                TooLongError::new(Self::MAX_COUNT, count.as_u64() as usize),
            ));
        }
        let mut list = Vec::<InvHash>::new();
        for _ in 0..count.as_u64() {
            list.push(InvHash::read_from(r)?);
        }
        Ok(Self { list })
    }
}

impl Message for Inv {
    const COMMAND: Command = Command::INV;
}

#[test]
fn test_inv_write_to() {
    let inv0 = InvHash::new([0x01; 32]);
    let inv1 = InvHash::new([0x23; 32]);
    let inv2 = InvHash::new([0x45; 32]);
    let test = Inv::new([inv0, inv1, inv2].to_vec()).unwrap();
    let mut bytes = Vec::new();
    test.write_to(&mut bytes).unwrap();
    let expected = [
        3, //
        0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
        0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
        0x01, 0x01, //
        0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
        0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
        0x23, 0x23, //
        0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
        0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
        0x45, 0x45, //
    ];
    assert_eq!(bytes, expected.to_vec());
}

#[test]
fn test_inv_read_from() {
    use std::io::Cursor;

    let mut bytes = Cursor::new(
        [
            3, //
            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
            0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
            0x01, 0x01, 0x01, 0x01, //
            0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
            0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23, 0x23,
            0x23, 0x23, 0x23, 0x23, //
            0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
            0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
            0x45, 0x45, 0x45, 0x45, //
        ]
        .to_vec(),
    );
    let test = Inv::read_from(&mut bytes).unwrap();
    let inv0 = InvHash::new([0x01; 32]);
    let inv1 = InvHash::new([0x23; 32]);
    let inv2 = InvHash::new([0x45; 32]);
    let expected = Inv::new([inv0, inv1, inv2].to_vec()).unwrap();
    assert_eq!(test, expected);
}