Struct Header 

#[repr(C)]
pub struct Header {
    pub length: u32,
    pub identifier: u16,
    pub flags: u16,
    pub sequence: u32,
    pub pid: u32,
}

Netlink message header

| length | identifier | flags | sequence | pid |
|--------|------------|-------|----------|-----|
|   u32  |     u16    |  u16  |   u32    | u32 |

Length is the total length of the message in bytes, including the header. Message data comes after the header. The data is 4 byte aligned, which means that the actual length message length might be longer than indicated by the length field.

Fields

length: u32

Message length

identifier: u16

Message identifier

flags: u16

Message flags

sequence: u32

Message sequence

pid: u32

Message process identifier

Implementations

impl Header

pub fn length(&self) -> usize

Returns the length including the header

pub fn data_length(&self) -> usize

Returns the length of the data section

pub fn padding(&self) -> usize

Returns padding length in octets

pub fn aligned_length(&self) -> usize

Returns length including header and padding

pub fn aligned_data_length(&self) -> usize

Returns length of the data section header and padding

pub fn check_pid(&self, pid: u32) -> bool

Check if the message pid equals provided pid or broadcast (0)

pub fn flags(&self) -> MessageFlags

Check if the message sequence number equals the provided sequence number or broadcast (0)

Trait Implementations

impl Display for Header

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl NativePack for Header

fn pack_size(&self) -> usize

fn pack_unchecked(&self, buffer: &mut [u8])

Pack value into slice without failing

fn pack<'a>(&self, buffer: &'a mut [u8]) -> Result<&'a mut [u8]>

Pack value into byte slice, returning the unused part of the slice

impl NativeUnpack for Header

fn unpack_unchecked(buffer: &[u8]) -> Self

Unpack byte slice into value without failing

fn unpack(buffer: &[u8]) -> Result<Self>

Unpack byte slice into value

fn unpack_with_size(buffer: &[u8]) -> Result<(usize, Self)>

Unpack byte slice into value, also returning size used