Struct NetlinkMessage

pub struct NetlinkMessage { /* private fields */ }

Represent a netlink message.

A netlink message is made of a header (represented by NetlinkHeader) and message (represented by NetlinkPayload):

0                8                16              24               32
+----------------+----------------+----------------+----------------+
|                 packet length (including header)                  |   \
+----------------+----------------+----------------+----------------+    |
|          message type           |              flags              |    |
+----------------+----------------+----------------+----------------+    | NetlinkHeader
|                           sequence number                         |    |
+----------------+----------------+----------------+----------------+    |
|                   port number (formerly known as PID)             |   /
+----------------+----------------+----------------+----------------+   
|                               payload                             |   \
|                          (variable length)                        |    |  NetlinkPayload
|                                                                   |    |
|                                                                   |   /
+----------------+----------------+----------------+----------------+

Implementations

impl NetlinkMessage

pub fn new(header: NetlinkHeader, payload: NetlinkPayload) -> Self

pub fn into_parts(self) -> (NetlinkHeader, NetlinkPayload)

pub fn payload(&self) -> &NetlinkPayload

pub fn payload_mut(&mut self) -> &mut NetlinkPayload

pub fn header(&self) -> &NetlinkHeader

pub fn header_mut(&mut self) -> &mut NetlinkHeader

pub fn to_bytes(&mut self, buffer: &mut [u8]) -> Result<usize, EncodeError>

Safely serialize the message. Under the hood, this calls Emitable::emit(), but unlike emit(), this method does not panic if the message is malformed or if the destination buffer is too small. Instead, an error is returned.

pub fn from_bytes(buffer: &[u8]) -> Result<Self, DecodeError>

Try to parse a message from a buffer

pub fn is_done(&self) -> bool

Check if the payload is a NLMSG_DONE message (Rtnl::Done)

pub fn is_noop(&self) -> bool

Check if the payload is a NLMSG_NOOP message (Rtnl::Noop)

pub fn is_overrun(&self) -> bool

Check if the payload is a NLMSG_OVERRUN message (Rtnl::Overrun)

pub fn is_error(&self) -> bool

Check if the payload is a NLMSG_ERROR message with a negative error code (Rtnl::Error)

pub fn is_ack(&self) -> bool

Check if the payload is a NLMSG_ERROR message with a non-negative error code (Rtnl::Ack)

pub fn finalize(&mut self)

Ensure the header (NetlinkHeader) is consistent with the payload (NetlinkPayload):

• compute the payload length and set the header’s length field
• check the payload type and set the header’s message type field accordingly

If you are not 100% sure the header is correct, this method should be called before calling Emitable::emit() or to_bytes(). emit() could panic if the header is inconsistent with the rest of the message, and to_bytes() would return an error.

Trait Implementations

impl Clone for NetlinkMessage

fn clone(&self) -> NetlinkMessage

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NetlinkMessage

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

Formats the value using the given formatter.

impl Emitable for NetlinkMessage

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 From<NetlinkPayload> for NetlinkMessage

fn from(payload: NetlinkPayload) -> Self

Converts to this type from the input type.

impl<'buffer, T: AsRef<[u8]> + 'buffer> Parseable<NetlinkMessage> for NetlinkBuffer<&'buffer T>

fn parse(&self) -> Result<NetlinkMessage, DecodeError>

Deserialize the current type.

impl PartialEq for NetlinkMessage

fn eq(&self, other: &NetlinkMessage) -> 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 Eq for NetlinkMessage

impl StructuralPartialEq for NetlinkMessage