Struct netlink_packet::header::NetlinkHeader

pub struct NetlinkHeader { /* private fields */ }

A Netlink header representation.

A netlink header has the following structure:

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

Example: parsing a netlink header

extern crate netlink_packet;
use netlink_packet::{NetlinkBuffer, NetlinkHeader, Parseable};
use netlink_packet::constants::{RTM_GETLINK, NLM_F_ROOT, NLM_F_REQUEST, NLM_F_MATCH};

// a packet captured with tcpdump that was sent when running `ip link show`
static PKT: [u8; 40] = [
    0x28, 0x00, 0x00, 0x00, // length = 40
    0x12, 0x00, // message type = 18 (RTM_GETLINK)
    0x01, 0x03, // flags = Request + Specify Tree Root + Return All Matching
    0x34, 0x0e, 0xf9, 0x5a, // sequence number = 1526271540
    0x00, 0x00, 0x00, 0x00, // port id = 0
    // payload
    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x08, 0x00, 0x1d, 0x00, 0x01, 0x00, 0x00, 0x00];

fn main() {
    let pkt: NetlinkHeader = NetlinkBuffer::new_checked(&PKT[..]).unwrap().parse().unwrap();
    assert_eq!(pkt.length(), 40);
    assert_eq!(pkt.message_type(), RTM_GETLINK);
    assert_eq!(pkt.sequence_number(), 1_526_271_540);
    assert_eq!(pkt.port_number(), 0);
    assert_eq!(u16::from(pkt.flags()), NLM_F_ROOT | NLM_F_REQUEST | NLM_F_MATCH);
}

Example: emitting a netlink header

extern crate netlink_packet;
use netlink_packet::{NetlinkBuffer, NetlinkHeader, NetlinkFlags, Emitable};
use netlink_packet::constants::{RTM_GETLINK, NLM_F_ROOT, NLM_F_REQUEST, NLM_F_MATCH};

// a packet captured with tcpdump that was sent when running `ip link show`
static PKT: [u8; 40] = [
    0x28, 0x00, 0x00, 0x00, // length = 40
    0x12, 0x00, // message type = 18 (RTM_GETLINK)
    0x01, 0x03, // flags = Request + Specify Tree Root + Return All Matching
    0x34, 0x0e, 0xf9, 0x5a, // sequence number = 1526271540
    0x00, 0x00, 0x00, 0x00, // port id = 0
    // payload
    0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x08, 0x00, 0x1d, 0x00, 0x01, 0x00, 0x00, 0x00];

fn main() {
    let flags = NetlinkFlags::from(NLM_F_ROOT | NLM_F_REQUEST | NLM_F_MATCH);
    let pkt = NetlinkHeader::new(40, RTM_GETLINK, flags, 0x5af9_0e34, 0);
    assert_eq!(pkt.buffer_len(), 16);
    let mut buf = vec![0; 16];
    pkt.emit(&mut buf[..]);
    assert_eq!(&buf[..], &PKT[..16]);
}

Implementations

impl NetlinkHeader

pub fn new(
    length: u32,
    message_type: u16,
    flags: NetlinkFlags,
    sequence_number: u32,
    port_number: u32
) -> Self

Create a new header, initialized with the given values

pub fn length(&self) -> u32

Get the length field

pub fn length_mut(&mut self) -> &mut u32

Get a mutable reference to the length field

pub fn set_length(&mut self, value: u32) -> &mut Self

Setter for the length field

pub fn message_type(&self) -> u16

Get the message type field

pub fn message_type_mut(&mut self) -> &mut u16

Get a mutable reference to the message type field

pub fn set_message_type(&mut self, value: u16) -> &mut Self

Setter for the message_type field

pub fn flags(&self) -> NetlinkFlags

Get the flags field

pub fn flags_mut(&mut self) -> &mut NetlinkFlags

Get a mutable reference to the flags field

pub fn set_flags(&mut self, value: NetlinkFlags) -> &mut Self

Setter for the flags field

pub fn sequence_number(&self) -> u32

Get the sequence number field

pub fn sequence_number_mut(&mut self) -> &mut u32

Get a mutable reference to the sequence number field

pub fn set_sequence_number(&mut self, value: u32) -> &mut Self

Setter for the sequence number field

pub fn port_number(&self) -> u32

Get the port number field

pub fn port_number_mut(&mut self) -> &mut u32

Get a mutable reference to the port number field

pub fn set_port_number(&mut self, value: u32) -> &mut Self

Setter for the port number field

Trait Implementations

impl Clone for NetlinkHeader

fn clone(&self) -> NetlinkHeader

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NetlinkHeader

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

Formats the value using the given formatter.

impl Default for NetlinkHeader

fn default() -> NetlinkHeader

Returns the “default value” for a type.

impl Emitable for NetlinkHeader

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 Hash for NetlinkHeader

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T: AsRef<[u8]> + ?Sized> Parseable<NetlinkHeader> for NetlinkBuffer<&'a T>

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

Deserialize the current type.

impl PartialEq<NetlinkHeader> for NetlinkHeader

fn eq(&self, other: &NetlinkHeader) -> bool

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

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

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

impl Copy for NetlinkHeader

impl Eq for NetlinkHeader

impl StructuralEq for NetlinkHeader

impl StructuralPartialEq for NetlinkHeader