levin 0.1.0

Library for the Levin p2p protocol
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

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

use crate::constants::*;
use crate::error::Result;

#[derive(Debug, Default)]
pub struct Header {
    signature: u64,
    payload_length: u64,
    expect_reponse: bool,
    command: u32,
    return_code: u32,
    flags: u32,
    version: u32,
}

impl Header {
    pub fn new_request(command: u32) -> Self {
        Self::new_unfragmented(true, command, 0, LevinMessage::Request)
    }

    pub fn new_response(command: u32, return_code: u32) -> Self {
        Self::new_unfragmented(false, command, return_code, LevinMessage::Response)
    }

    pub fn new_notification(command: u32) -> Self {
        Self::new_unfragmented(false, command, 0, LevinMessage::Notification)
    }

    pub fn from_reader<R: Read>(mut reader: R) -> Result<Self> {
        let mut res = Self::default();
        res.signature = read_fixed_u64(&mut reader)?;
        res.payload_length = read_fixed_u64(&mut reader)?;
        res.expect_reponse = read_bool(&mut reader)?;
        res.command = read_fixed_u32(&mut reader)?;
        res.return_code = read_fixed_u32(&mut reader)?;
        res.flags = read_fixed_u32(&mut reader)?;
        res.version = read_fixed_u32(&mut reader)?;
        Ok(res)
    }

    pub fn to_writer<W: Write>(&self, mut writer: W) -> Result<()> {
        write_fixed_u64(&mut writer, self.signature)?;
        write_fixed_u64(&mut writer, self.payload_length)?;
        write_bool(&mut writer, self.expect_reponse)?;
        write_fixed_u32(&mut writer, self.command)?;
        write_fixed_u32(&mut writer, self.return_code)?;
        write_fixed_u32(&mut writer, self.flags)?;
        write_fixed_u32(&mut writer, self.version)?;
        Ok(())
    }

    pub fn set_payload_length(&mut self, length: usize) {
        self.payload_length = length as u64;
    }

    fn new_unfragmented(
        expect_reponse: bool,
        command: u32,
        return_code: u32,
        msg_type: LevinMessage,
    ) -> Self {
        Self {
            signature: u64::from_le_bytes(LEVIN_SIGNATURE),
            payload_length: 0,
            expect_reponse,
            command,
            return_code,
            flags: make_flags(msg_type, LevinFragment::Unfragmented),
            version: LEVIN_VERSION,
        }
    }
}

fn make_flags(msg_type: LevinMessage, frag_type: LevinFragment) -> u32 {
    let msg_mask = match msg_type {
        LevinMessage::Request => LEVIN_REQUEST_BIT,
        LevinMessage::Notification => LEVIN_REQUEST_BIT,
        LevinMessage::Response => LEVIN_RESPONSE_BIT,
        LevinMessage::Dummy => 0,
    };

    let frag_mask = match frag_type {
        LevinFragment::Begin => LEVIN_FRAG_BEGIN_BIT,
        LevinFragment::Middle => 0,
        LevinFragment::Unfragmented => 0,
        LevinFragment::End => LEVIN_FRAG_END_BIT,
        LevinFragment::Dummy => LEVIN_FRAG_BEGIN_BIT | LEVIN_FRAG_END_BIT,
    };

    return msg_mask | frag_mask;
}

fn read_fixed_u32<R: Read>(r: &mut R) -> std::io::Result<u32> {
    let mut ibytes = [0u8; 4];
    r.read_exact(&mut ibytes)?;
    Ok(u32::from_le_bytes(ibytes))
}

fn read_fixed_u64<R: Read>(r: &mut R) -> std::io::Result<u64> {
    let mut ibytes = [0u8; 8];
    r.read_exact(&mut ibytes)?;
    Ok(u64::from_le_bytes(ibytes))
}

fn read_bool<R: Read>(r: &mut R) -> std::io::Result<bool> {
    let mut bbyte = 0u8;
    r.read_exact(std::slice::from_mut(&mut bbyte))?;
    Ok(bbyte != 0)
}

fn write_fixed_u32<W: Write>(w: &mut W, val: u32) -> std::io::Result<()> {
    let ibytes = val.to_le_bytes();
    w.write_all(&ibytes)
}

fn write_fixed_u64<W: Write>(w: &mut W, val: u64) -> std::io::Result<()> {
    let ibytes = val.to_le_bytes();
    w.write_all(&ibytes)
}

fn write_bool<W: Write>(w: &mut W, val: bool) -> std::io::Result<()> {
    let bbyte = if val { 1u8 } else { 0 };
    w.write(std::slice::from_ref(&bbyte))?;
    Ok(())
}