rsmnl 0.1.0

A rust netlink library imitating libmnl
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

use errno::Errno;
use libc::{self, nlmsgerr};
use {CbResult, CbStatus, Msghdr};

pub const NOCB: Option<fn(&Msghdr) -> CbResult> = None;

fn noop(_nlh: &Msghdr) -> CbResult {
    Ok(CbStatus::Ok)
}

fn error(nlh: &Msghdr) -> CbResult {
    let err = nlh.payload::<nlmsgerr>()?;
    match err.error {
        e if e < 0 => crate::gen_errno!(-err.error),
        e if e > 0 => crate::gen_errno!(err.error),
        _ => Ok(CbStatus::Stop),
    }
}

fn stop(_nlh: &Msghdr) -> CbResult {
    Ok(CbStatus::Stop)
}

const DEFAULT_CB_ARRAY: [Option<fn(&Msghdr) -> CbResult>; libc::NLMSG_MIN_TYPE as usize] = [
    None,
    Some(noop),  // NLMSG_NOOP:		0x1
    Some(error), // NLMSG_ERROR:		0x2
    Some(stop),  // NLMSG_DONE:		0x3
    Some(noop),  // NLMSG_OVERRUN:	0x4
    // ..Default::default()
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

// T might be a dyn FnMut and U is fn
fn __run<'a, T, U>(
    buf: &'a [u8],
    seq: u32,
    portid: u32,
    mut cb_data: Option<T>,
    cb_ctl_array: &mut [Option<U>],
) -> CbResult
where
    T: FnMut(&'a Msghdr<'a>) -> CbResult,
    U: FnMut(&'a Msghdr<'a>) -> CbResult,
{
    let mut nlh = unsafe { &*(buf.as_ptr() as *const _ as *const Msghdr) };
    let mut len = buf.len() as isize;
    if !nlh.ok(len) {
        return crate::gen_errno!(libc::EBADMSG);
    }

    loop {
        nlh.portid_ok(portid)?;
        nlh.seq_ok(seq)?;
        // dump was interrupted
        if nlh.nlmsg_flags & libc::NLM_F_DUMP_INTR as u16 != 0 {
            return crate::gen_errno!(libc::EINTR);
        }
        if nlh.nlmsg_type >= libc::NLMSG_MIN_TYPE as u16 {
            if let Some(ref mut cb) = cb_data {
                match cb(&nlh) {
                    Ok(CbStatus::Ok) => {}
                    ret @ _ => return ret,
                }
            }
        } else if nlh.nlmsg_type < cb_ctl_array.len() as u16 {
            if let Some(ref mut ctl_cb) = cb_ctl_array[nlh.nlmsg_type as usize] {
                match ctl_cb(&nlh) {
                    Ok(CbStatus::Ok) => {}
                    ret @ _ => return ret,
                }
            }
        } else if let Some(default_cb) = DEFAULT_CB_ARRAY[nlh.nlmsg_type as usize] {
            match default_cb(&nlh) {
                Ok(CbStatus::Ok) => {}
                ret @ _ => return ret,
            }
        }
        nlh = unsafe { nlh.next(&mut len) };
        if !nlh.ok(len) {
            break;
        }
    }
    Ok(CbStatus::Ok)
}

/// You can set the cb_ctl_array to NULL if you want to use the default control
/// callback handlers, in that case, the parameter cb_ctl_array_len is not
/// checked.
///
/// Your callback may return three possible values:
/// 	- MNL_CB_ERROR (<=-1): an error has occurred. Stop callback runqueue.
/// 	- MNL_CB_STOP (=0): stop callback runqueue.
/// 	- MNL_CB_OK (>=1): no problem has occurred.
///
/// This function propagates the callback return value. On error, it returns
/// -1 and errno is explicitly set. If the portID is not the expected, errno
/// is set to ESRCH. If the sequence number is not the expected, errno is set
/// to EPROTO. If the dump was interrupted, errno is set to EINTR and you should
/// request a new fresh dump again.
///
/// @imitates: [libmnl::mnl_cb_run2]
pub fn run2<T, U>(
    buf: &[u8],
    seq: u32,
    portid: u32,
    cb_data: Option<T>,
    cb_ctl_array: &mut [Option<U>],
) -> CbResult
where
    T: FnMut(&Msghdr) -> CbResult,
    U: FnMut(&Msghdr) -> CbResult,
{
    __run(buf, seq, portid, cb_data, cb_ctl_array)
}

/// This function is like mnl_cb_run2() but it does not allow you to set
/// the control callback handlers.
///
/// Your callback may return three possible values:
/// 	- MNL_CB_ERROR (<=-1): an error has occurred. Stop callback runqueue.
/// 	- MNL_CB_STOP (=0): stop callback runqueue.
/// 	- MNL_CB_OK (>=1): no problems has occurred.
///
/// This function propagates the callback return value.
///
/// @imitates: [libmnl::mnl_cb_run]
pub fn run<U: FnMut(&Msghdr) -> CbResult>(
    buf: &[u8],
    seq: u32,
    portid: u32,
    cb_data: Option<U>,
) -> CbResult {
    __run(buf, seq, portid, cb_data, &mut [] as &mut [Option<U>])
}