nell 0.3.0

Linux netlink interface
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

// Copyright (C) 2020 - Will Glozer. All rights reserved.

use std::cmp::min;
use std::marker::PhantomData;
use std::mem::size_of;
use std::ptr::read_unaligned;
use std::slice;
use std::str::{self, Utf8Error};
use super::{align, Bytes};

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Cursor<'a> {
    ptr: *const u8,
    len: usize,
    pha: PhantomData<&'a ()>,
}

impl<'a> Cursor<'a> {
    fn new(ptr: *const u8, len: usize) -> Self {
        Self { ptr, len, pha: PhantomData }
    }

    pub fn next<T: Bytes>(&mut self) -> Option<(T, Self)> {
        unsafe {
            let size = align(size_of::<T>());
            self.len = self.len.checked_sub(size)?;
            let item = read_unaligned(self.ptr as *const T);
            self.ptr = self.ptr.add(size);

            let max  = self.len;
            let size = min(item.tail(max), max);
            let tail = Self::new(self.ptr, size);

            let size = min(align(size), max);
            self.len = self.len.checked_sub(size)?;
            self.ptr = self.ptr.add(size);

            Some((item, tail))
        }
    }

    pub fn is_empty(&self) -> bool {
        self.len == 0
    }

    pub fn asciiz(self) -> Result<&'a str, Utf8Error> {
        let len = self.len.saturating_sub(1);
        str::from_utf8(self.slice(len))
    }

    pub fn bytes(self) -> &'a [u8] {
        self.slice(self.len)
    }

    pub fn copy<T: Bytes>(self) -> T {
        self.read()
    }

    fn slice(&self, len: usize) -> &'a [u8] {
        assert!(len <= self.len);
        unsafe {
            slice::from_raw_parts(self.ptr, len)
        }
    }

    fn read<T: Bytes>(&self) -> T {
        assert!(size_of::<T>() <= self.len);
        unsafe {
            read_unaligned(self.ptr as *const T)
        }
    }
}

impl Default for Cursor<'_> {
    fn default() -> Self {
        static EMPTY: &[u8] = &[];
        Self {
            ptr: EMPTY.as_ptr(),
            len: 0,
            pha: PhantomData,
        }
    }
}

impl<'a> From<&'a [u8]> for Cursor<'a> {
    fn from(slice: &'a [u8]) -> Self {
        Self::new(slice.as_ptr(), slice.len())
    }
}