rxdp 0.3.1

Bindings for interoperating with XDP programs and eBPF maps.
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

use crate::error::XDPError;
use crate::result::XDPResult;
use libc::if_nametoindex;
use std::{
    convert::TryInto,
    ffi::{CStr, CString},
    os::raw::c_char,
};

pub(crate) fn str_to_cstring(s: &str) -> XDPResult<CString> {
    match CString::new(s) {
        Ok(c) => Ok(c),
        Err(e) => {
            fail!("Error creating C string: {:?}", e);
        }
    }
}

pub(crate) fn lookup_interface_by_name(name: &str) -> XDPResult<i32> {
    let index = unsafe { if_nametoindex(str_to_cstring(name)?.as_ptr()) };
    if index == 0 {
        fail!("Error finding interface index for {}", name);
    }

    match (index as i32).try_into() {
        Ok(i) => Ok(i),
        Err(e) => fail!("Error converting interface index to 'i32': {}", e),
    }
}

pub(crate) fn cstring_to_str(char_ptr: *const c_char) -> String {
    let cs = unsafe { CStr::from_ptr(char_ptr) };
    match cs.to_str() {
        Ok(s) => String::from(s),
        Err(_) => String::new(),
    }
}

// Returns the number of possible cpus
pub(crate) fn num_cpus() -> XDPResult<usize> {
    let contents = match std::fs::read_to_string("/sys/devices/system/cpu/possible") {
        Ok(c) => c,
        Err(e) => fail!("Error getting the number of cpus: {:?}", e),
    };

    if contents.trim() == "0" {
        return Ok(1);
    }

    let parts: Vec<&str> = contents.trim().split("-").collect();
    if parts.len() != 2 {
        fail!("Unable to determine number of cpus");
    }

    let lower = parts[0].parse::<u32>().unwrap_or(0);
    let upper = parts[1].parse::<u32>().unwrap_or(0);

    if upper == 0 {
        fail!("Unable to determine number of cpus");
    }

    Ok((upper - lower) as usize + 1 as usize)
}