Struct neli::nlattr::Nlattr

pub struct Nlattr<T, P> {
    pub nla_len: u16,
    pub nla_nested: bool,
    pub nla_network_order: bool,
    pub nla_type: T,
    pub payload: P,
}

Struct representing netlink attributes and payloads

Fields

nla_len: u16

Length of the attribute header and payload together

nla_nested: bool

If true, the payload contains nested attributes.

nla_network_order: bool

If true, the payload is in net work byte order.

nla_type: T

Enum representing the type of the attribute payload

payload: P

Payload of the attribute - either parsed or a binary buffer

Methods

impl<T, P> Nlattr<T, P> where
    T: NlAttrType,
    P: Nl, 

pub fn payload_size(&self) -> usize

Get the size of the payload only

impl<T> Nlattr<T, Vec<u8>> where
    T: NlAttrType, 

pub fn new<P>(
    nla_len: Option<u16>,
    nla_type: T,
    payload: P
) -> Result<Self, SerError> where
    P: Nl, 

This function will serialize the provided payload

pub fn new_with_bitflags<P>(
    nla_len: Option<u16>,
    nla_nested: bool,
    nla_network_order: bool,
    nla_type: T,
    payload: P
) -> Result<Self, SerError> where
    P: Nl, 

Create a new Nlattr with parameters for setting bitflags in the header.

pub fn set_payload<P>(&mut self, payload: P) -> Result<(), SerError> where
    P: Nl, 

Set the payload to a data type that implements Nl - this function will overwrite the current payload

pub fn add_nested_attribute<TT, P>(
    &mut self,
    attr: &Nlattr<TT, P>
) -> Result<(), SerError> where
    TT: NlAttrType,
    P: Nl, 

Add a nested attribute to the end of the payload

pub fn get_payload_as<R>(&self) -> Result<R, DeError> where
    R: Nl, 

Get an Nlattr payload as a provided type

pub fn get_nested_attributes<R>(&self) -> Result<AttrHandle<R>, DeError> where
    R: NlAttrType, 

Return an AttrHandle for attributes nested in the given attribute payload

Trait Implementations

impl<T: Debug, P: Debug> Debug for Nlattr<T, P>

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

Formats the value using the given formatter.

impl<T, P> Nl for Nlattr<T, P> where
    T: NlAttrType,
    P: Nl, 

fn serialize(&self, mem: &mut StreamWriteBuffer) -> Result<(), SerError>

Serialization method

fn deserialize<B>(mem: &mut StreamReadBuffer<B>) -> Result<Self, DeError> where
    B: AsRef<[u8]>, 

Stateless deserialization method

fn size(&self) -> usize

The size of the binary representation of a struct - not aligned to word size

fn asize(&self) -> usize

The size of the binary representation of a struct - aligned to word size

fn pad(&self, m: &mut StreamWriteBuffer) -> Result<(), SerError>

Pad the data serialized data structure to alignment

fn strip<T>(&self, m: &mut StreamReadBuffer<T>) -> Result<(), DeError> where
    T: AsRef<[u8]>, 

Strip padding from the deserialization buffer

impl<T: PartialEq, P: PartialEq> PartialEq<Nlattr<T, P>> for Nlattr<T, P>

fn eq(&self, other: &Nlattr<T, P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Nlattr<T, P>) -> bool

This method tests for !=.

impl<T, P> StructuralPartialEq for Nlattr<T, P>