[−][src]Struct netlink_packet_core::buffer::NetlinkBuffer

pub struct NetlinkBuffer<T> {
    pub buffer: T,
}

A raw Netlink buffer that provides getters and setter for the various header fields, and to retrieve the payloads.

Example: reading a packet

use netlink_packet_core::{NetlinkBuffer, NLM_F_ROOT, NLM_F_REQUEST, NLM_F_MATCH};

const RTM_GETLINK: u16 = 18;

fn main() {
    // Artificially create an array of bytes that represents a netlink packet.
    // Normally, we would read it from a socket.
    let buffer = vec![
        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];

    // Wrap the storage into a NetlinkBuffer
    let packet = NetlinkBuffer::new_checked(&buffer[..]).unwrap();

    // Check that the different accessor return the expected values
    assert_eq!(packet.length(), 40);
    assert_eq!(packet.message_type(), RTM_GETLINK);
    assert_eq!(packet.sequence_number(), 1526271540);
    assert_eq!(packet.port_number(), 0);
    assert_eq!(packet.payload_length(), 24);
    assert_eq!(packet.payload(), &buffer[16..]);
    assert_eq!(
        Into::<u16>::into(packet.flags()),
        NLM_F_ROOT | NLM_F_REQUEST | NLM_F_MATCH);
}

Example: writing a packet

use netlink_packet_core::{NetlinkBuffer, NLM_F_ROOT, NLM_F_REQUEST, NLM_F_MATCH};

const RTM_GETLINK: u16 = 18;

fn main() {
    // The packet we want to write.
    let expected_buffer = vec![
        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];

    // Create a storage that is big enough for our packet
    let mut buf = vec![0; 40];
    // the extra scope is to restrict the scope of the borrow
    {
        // Create a NetlinkBuffer.
        let mut packet = NetlinkBuffer::new(&mut buf);
        // Set the various fields
        packet.set_length(40);
        packet.set_message_type(RTM_GETLINK);
        packet.set_sequence_number(1526271540);
        packet.set_port_number(0);
        packet.set_flags(From::from(NLM_F_ROOT | NLM_F_REQUEST | NLM_F_MATCH));
        // we kind of cheat here to keep the example short
        packet.payload_mut().copy_from_slice(&expected_buffer[16..]);
   }
   // Check that the storage contains the expected values
   assert_eq!(&buf[..], &expected_buffer[..]);
}

Note that in this second example we don't call new_checked() because the length field is initialized to 0, so new_checked() would return an error.

Fields

buffer: T

Implementations

`impl<T: AsRef<[u8]>> NetlinkBuffer<T>`[src]

`pub fn new(buffer: T) -> NetlinkBuffer<T>`[src]

Create a new NetlinkBuffer that uses the given buffer as storage. Note that when calling this method no check is performed, so trying to access fields may panic. If you're not sure the given buffer contains a valid netlink packet, use new_checked() instead.

`pub fn new_checked(buffer: T) -> Result<NetlinkBuffer<T>, DecodeError>`[src]

Check the length of the given buffer and make sure it's big enough so that trying to access packet fields won't panic. If the buffer is big enough, create a new NewlinkBuffer that uses this buffer as storage.

Example

With a buffer that does not even contain a full header:

static BYTES: [u8; 4] = [0x28, 0x00, 0x00, 0x00];
assert!(NetlinkBuffer::new_checked(&BYTES[..]).is_err());

Here is a slightly more tricky error, where technically, the buffer is big enough to contains a valid packet. Here, accessing the packet header fields would not panic but accessing the payload would, so new_checked also checks the length field in the packet header:

// The buffer is 24 bytes long. It contains a valid header but a truncated payload
static BYTES: [u8; 24] = [
    // The length field says the buffer is 40 bytes long
    0x28, 0x00, 0x00, 0x00,
    0x12, 0x00, // message type
    0x01, 0x03, // flags
    0x34, 0x0e, 0xf9, 0x5a, // sequence number
    0x00, 0x00, 0x00, 0x00, // port id
    // payload
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
assert!(NetlinkBuffer::new_checked(&BYTES[..]).is_err());

`pub fn payload_length(&self) -> usize`[src]

Return the payload length.

Panic

This panic is the underlying storage is too small or if the length field in the header is set to a value that exceeds the storage length (see new_checked())

`pub fn into_inner(self) -> T`[src]

Consume the packet, returning the underlying buffer.