nlrs 0.2.1

A minimal rust crate for simple and efficient Netlink requests
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

// SPDX-License-Identifier: MIT
use std::io::{Read, Write};

/// generic netlink wrapper of
/// [`crate::socket::NetlinkSocket`]
#[derive(Debug)]
pub struct GenericNetlinkSocket<
    Snd: Write + AsRef<[u8]>,
    Rcv: Write + AsRef<[u8]> + AsMut<[u8]>,
    Fd: Read + Write,
> {
    pub family_id: u16,
    pub socket: crate::socket::NetlinkSocket<Snd, Rcv, Fd>,
}

impl<Snd: Write + AsRef<[u8]>, Rcv: Write + AsRef<[u8]> + AsMut<[u8]>, Fd: Read + Write>
    GenericNetlinkSocket<Snd, Rcv, Fd>
where
    std::io::Cursor<Snd>: Write,
{
    pub fn from_netlink_socket(
        mut socket: crate::socket::NetlinkSocket<Snd, Rcv, Fd>,
        family_name: String,
    ) -> Result<Self, crate::ResponseError<super::msg::ResolveFamilyIdParseError>> {
        use crate::socket::RequestBuilder;

        let resolve_family_id: super::msg::ResolveFamilyIdMsgBuilder<_> =
            socket.message_builder(family_name);

        let family_resolution = resolve_family_id.call()?;

        Ok(Self {
            family_id: family_resolution.family_id,
            socket,
        })
    }
}

impl<'a, Snd: Write + AsRef<[u8]>, Rcv: Write + AsRef<[u8]> + AsMut<[u8]>, Fd: Read + Write>
    GenericNetlinkSocket<Snd, Rcv, Fd>
{
    /// get a generic message builder writing to the socket buffer
    pub fn message_builder<M: super::GenericMessageBuilder<'a, Buffer = Self>>(
        &'a mut self,
        input: M::Input,
    ) -> M {
        self.message_builder_and_sequence_id(input).0
    }

    /// get a generic message builder writing to the socket buffer, and the sequence id used with the messages
    pub fn message_builder_and_sequence_id<M: super::GenericMessageBuilder<'a, Buffer = Self>>(
        &'a mut self,
        input: M::Input,
    ) -> (M, u32) {
        self.socket.sequence_number = self.socket.sequence_number.wrapping_add(1);
        M::new(self, self.family_id, self.socket.sequence_number, input)
    }

    /// get a generic message builder writing to the socket buffer, by providing a custom netlink message header
    pub fn message_builder_with_nelink_header<
        M: super::GenericMessageBuilder<'a, Buffer = Self>,
    >(
        &'a mut self,
        nl_msg_header: crate::netlink::msg::NlMsgHeader,
        input: M::Input,
    ) -> M {
        M::new_with_header(self, nl_msg_header, self.family_id, input)
    }
}

impl<Snd: Write + AsRef<[u8]>, Rcv: Write + AsRef<[u8]> + AsMut<[u8]>, Fd: Read + Write>
    std::ops::Deref for GenericNetlinkSocket<Snd, Rcv, Fd>
{
    type Target = crate::socket::NetlinkSocket<Snd, Rcv, Fd>;

    fn deref(&self) -> &Self::Target {
        &self.socket
    }
}

impl<Snd: Write + AsRef<[u8]>, Rcv: Write + AsRef<[u8]> + AsMut<[u8]>, Fd: Read + Write>
    std::ops::DerefMut for GenericNetlinkSocket<Snd, Rcv, Fd>
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.socket
    }
}

impl<Snd: Write + AsRef<[u8]>, Rcv: Write + AsRef<[u8]> + AsMut<[u8]>, Fd: Read + Write> Read
    for GenericNetlinkSocket<Snd, Rcv, Fd>
{
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        self.rcv_buffer.read(buf)
    }
}

impl<Snd: Write + AsRef<[u8]>, Rcv: Write + AsRef<[u8]> + AsMut<[u8]>, Fd: Read + Write> Write
    for GenericNetlinkSocket<Snd, Rcv, Fd>
where
    std::io::Cursor<Snd>: Write,
{
    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
        self.snd_buffer.write(buf)
    }

    fn flush(&mut self) -> std::io::Result<()> {
        self.snd_buffer.flush()
    }
}

/// helper trait to make request from a [`GenericNetlinkSocket`]'s generic message builder
pub trait GenericRequestBuilder<Buffer, Output, ParseError>: Sized {
    /// send request
    fn send(self) -> Result<usize, std::io::Error>;
    /// send request, receive response and parse it
    fn call(self) -> Result<Output, crate::ResponseError<ParseError>>;
}

impl<'a, T, Snd, Rcv, Fd>
    GenericRequestBuilder<GenericNetlinkSocket<Snd, Rcv, Fd>, T::Output, T::ParseError> for T
where
    Snd: Write + AsRef<[u8]> + 'a,
    Rcv: Write + AsRef<[u8]> + AsMut<[u8]> + 'a,
    Fd: Read + Write + 'a,
    T: crate::genetlink::GenericMessageBuilder<'a, Buffer = GenericNetlinkSocket<Snd, Rcv, Fd>>,
{
    fn send(self) -> Result<usize, std::io::Error> {
        let (socket, _) = self.build()?;
        socket.send()
    }

    fn call(self) -> Result<T::Output, crate::ResponseError<T::ParseError>> {
        let (socket, _) = self.build()?;
        socket.send().map_err(crate::ResponseError::Io)?;
        socket.receive().map_err(crate::ResponseError::Io)?;
        T::parse_response(socket)
    }
}