Struct GenlMessage

pub struct GenlMessage<F> {
    pub header: GenlHeader,
    pub payload: F,
    /* private fields */
}

Represent the generic netlink messages

This type can wrap data types F which represents a generic family payload. The message can be serialize/deserialize if the type F implements GenlFamily, [Emitable], and ParseableParametrized<[u8], GenlHeader>.

Fields

header: GenlHeader

payload: F

Implementations

impl<F> GenlMessage<F>

where F: Debug,

pub fn new(header: GenlHeader, payload: F, family_id: u16) -> Self

Construct the message

pub fn from_parts(header: GenlHeader, payload: F) -> Self

Construct the message by the given header and payload

pub fn into_parts(self) -> (GenlHeader, F)

Consume this message and return its header and payload

pub fn resolved_family_id(&self) -> u16

Return the previously set resolved family ID in this message.

This value would be used to serialize the message only if the (GenlFamily::family_id()) return 0 in the underlying type.

pub fn set_resolved_family_id(&mut self, family_id: u16)

Set the resolved dynamic family ID of the message, if the generic family uses dynamic generated ID by kernel.

This method is a interface to provide other high level library to set the resolved family ID before the message is serialized.

Usage

Normally, you don’t have to call this function directly if you are using library which helps you handle the dynamic family id.

If you are the developer of some high level generic netlink library, you can call this method to set the family id resolved by your resolver. Without having to modify the message_type field of the serialized netlink packet header before sending it.

impl<F> GenlMessage<F>

where F: GenlFamily + Debug,

pub fn from_payload(payload: F) -> Self

Build the message from the payload

This function would automatically fill the header for you. You can directly emit the message without having to call finalize().

pub fn finalize(&mut self)

Ensure the header (GenlHeader) is consistent with the payload (F: GenlFamily):

• Fill the command and version number into the header

If you are not 100% sure the header is correct, this method should be called before calling [Emitable::emit()], as it could get error result if the header is inconsistent with the message.

pub fn family_id(&self) -> u16

Return the resolved family ID which should be filled into the message_type field in NetlinkHeader.

The implementation of NetlinkSerializable::message_type() would use this function’s result as its the return value. Thus, the family id can be automatically filled into the message_type during the call to NetlinkMessage::finalize().

Trait Implementations

impl<F: Clone> Clone for GenlMessage<F>

fn clone(&self) -> GenlMessage<F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug> Debug for GenlMessage<F>

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

Formats the value using the given formatter.

impl<F> Emitable for GenlMessage<F>

where F: GenlFamily + Emitable + Debug,

fn buffer_len(&self) -> usize

Return the length of the serialized data.

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

Serialize this types and write the serialized data into the given buffer.

impl<F> From<GenlMessage<F>> for NetlinkPayload<GenlMessage<F>>

where F: Debug,

fn from(message: GenlMessage<F>) -> Self

Converts to this type from the input type.

impl<F> NetlinkDeserializable for GenlMessage<F>

where F: ParseableParametrized<[u8], GenlHeader> + Debug, F::Error: Into<DecodeError>,

type Error = DecodeError

fn deserialize( header: &NetlinkHeader, payload: &[u8], ) -> Result<Self, Self::Error>

Deserialize the given buffer into Self.

impl<F> NetlinkSerializable for GenlMessage<F>

where F: GenlFamily + Emitable + Debug,

fn message_type(&self) -> u16

fn buffer_len(&self) -> usize

Return the length of the serialized data.

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

Serialize this types and write the serialized data into the given buffer. buffer’s length is exactly InnerMessage::buffer_len(). It means that if InnerMessage::buffer_len() is buggy and does not return the appropriate length, bad things can happen:

impl<'a, F, T> ParseableParametrized<GenlBuffer<&'a T>, u16> for GenlMessage<F>

where F: ParseableParametrized<[u8], GenlHeader> + Debug, T: AsRef<[u8]> + ?Sized, F::Error: Into<DecodeError>,

type Error = DecodeError

fn parse_with_param( buf: &GenlBuffer<&'a T>, message_type: u16, ) -> Result<Self, DecodeError>

Deserialize the current type.

impl<F: PartialEq> PartialEq for GenlMessage<F>

fn eq(&self, other: &GenlMessage<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F: Eq> Eq for GenlMessage<F>

impl<F> StructuralPartialEq for GenlMessage<F>