Struct netlink_packet_route::rtnl::route::RouteHeader

#[non_exhaustive]
pub struct RouteHeader {
    pub address_family: u8,
    pub destination_prefix_length: u8,
    pub source_prefix_length: u8,
    pub tos: u8,
    pub table: u8,
    pub protocol: u8,
    pub scope: u8,
    pub kind: u8,
    pub flags: RouteFlags,
}

High level representation of RTM_GETROUTE, RTM_ADDROUTE, RTM_DELROUTE messages headers.

These headers have the following structure:

0                8                16              24               32
+----------------+----------------+----------------+----------------+
| address family | dest. length   | source length  |      tos       |
+----------------+----------------+----------------+----------------+
|     table      |   protocol     |      scope     | type (kind)    |
+----------------+----------------+----------------+----------------+
|                               flags                               |
+----------------+----------------+----------------+----------------+

Example

extern crate netlink_packet_route;
use netlink_packet_route::{constants::*, RouteFlags, RouteHeader};

fn main() {
    let mut hdr = RouteHeader::default();
    assert_eq!(hdr.address_family, 0u8);
    assert_eq!(hdr.destination_prefix_length, 0u8);
    assert_eq!(hdr.source_prefix_length, 0u8);
    assert_eq!(hdr.tos, 0u8);
    assert_eq!(hdr.table, RT_TABLE_UNSPEC);
    assert_eq!(hdr.protocol, RTPROT_UNSPEC);
    assert_eq!(hdr.scope, RT_SCOPE_UNIVERSE);
    assert_eq!(hdr.kind, RTN_UNSPEC);
    assert_eq!(hdr.flags.bits(), 0u32);

    // set some values
    hdr.destination_prefix_length = 8;
    hdr.table = RT_TABLE_MAIN;
    hdr.protocol = RTPROT_KERNEL;
    hdr.scope = RT_SCOPE_NOWHERE;

    // ...
}

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

address_family: u8

Address family of the route: either AF_INET for IPv4 prefixes, or AF_INET6 for IPv6 prefixes.

destination_prefix_length: u8

Prefix length of the destination subnet.

Note that setting

source_prefix_length: u8

Prefix length of the source address.

There could be multiple addresses from which a certain network is reachable. To decide which source address to use to reach and address in that network, the kernel rely on the route’s source address for this destination.

For instance, interface if1 could have two addresses 10.0.0.1/24 and 10.0.0.128/24, and we could have the following routes:

10.0.0.10/32 dev if1 scope link src 10.0.0.1
10.0.0.11/32 dev if1 scope link src 10.0.0.1
10.0.0.12/32 dev if1 scope link src 10.0.0.1
10.0.0.0/24 dev if1 scope link src 10.0.0.128

It means that for 10.0.0.10, 10.0.0.11 and 10.0.0.12 the packets will be sent with 10.0.0.1 as source address, while for the rest of the 10.0.0.0/24 subnet, the source address will be 10.0.0.128

tos: u8

TOS filter

table: u8

Routing table ID. It can be one of the RT_TABLE_* constants or a custom table number between 1 and 251 (included). Note that Linux supports routing table with an ID greater than 255, in which case this attribute will be set to RT_TABLE_COMPAT and an [Nla::Table] netlink attribute will be present in the message.

protocol: u8

Protocol from which the route was learnt. It should be set to one of the RTPROT_* constants.

scope: u8

The scope of the area where the addresses in the destination subnet are valid. Predefined scope values are the RT_SCOPE_* constants.

kind: u8

Route type. It should be set to one of the RTN_* constants.

flags: RouteFlags

Flags when querying the kernel with a RTM_GETROUTE message. See RouteFlags.

Trait Implementations

impl Clone for RouteHeader

fn clone(&self) -> RouteHeader

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RouteHeader

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

Formats the value using the given formatter.

impl Default for RouteHeader

fn default() -> RouteHeader

Returns the “default value” for a type.

impl Emitable for RouteHeader

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 RouteHeader

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<RouteMessageBuffer<&'a T>> for RouteHeader

fn parse(buf: &RouteMessageBuffer<&'a T>) -> Result<Self, DecodeError>

Deserialize the current type.

impl PartialEq<RouteHeader> for RouteHeader

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

impl StructuralEq for RouteHeader

impl StructuralPartialEq for RouteHeader