rtnetlink Rust Crate

The rtnetlink crate provides a Rust interface for manipulating Linux networking resources using the rtnetlink protocol. It allows developers to programmatically manage:

• Links: Network interfaces.
• Addresses: IP addresses assigned to interfaces.
• ARP tables: Address Resolution Protocol entries.
• Route tables: IP routing configurations.

This crate is a specialized implementation of the netlink route protocol as defined in the Linux man pages.

You can create a WWAN (Wireless Wide Area Network) interface using LinkWwan::new(name). When creating a WWAN interface, you must specify the parent device using .parent_dev_name(). You can also optionally set a linkid using .linkid().

This corresponds to the following ip link command structure: ip link add name NAME parentdev PARENTDEV type wwan linkid LINKID

use rtnetlink::{new_connection, LinkWwan};

#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(
            LinkWwan::new("wwan0p")
                .parent_dev_name("wwan0")
                .linkid(15)
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}

Use LinkGtp::new(name) to initialize a LinkMessageBuilder for a GTP (GPRS Tunneling Protocol) interface. You can then configure the interface using methods like .role(), .pdp_hashsize(), and .restart_count() before calling .build() and executing the command via a netlink handle.

Note that create_sockets is automatically set to true by default to match iproute2 behavior.

use rtnetlink::{new_connection, LinkGtp};
use rtnetlink::packet_route::link::GtpRole;

#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(
            LinkGtp::new("gtp0")
                .role(GtpRole::Sgsn)
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}

You can create and configure an HSR network interface using LinkHsr. This is done by initializing a LinkMessageBuilder via LinkHsr::new(name) and then chaining configuration methods to set port indices, protocol versions, and other HSR-specific parameters. Once configured, use the handle.link().add(...) method to execute the creation of the link.

use rtnetlink::{new_connection, LinkHsr};

#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(
            LinkHsr::new("hsr0")
                .port1(3)
                .port2(4)
                .build()
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}

Use LinkIpIp and its LinkMessageBuilder to create new IP-in-IP network links. This is the programmatic equivalent of the ip link add name NAME type ipip ... command.

To create an interface, call LinkIpIp::new("interface_name") to get a builder, configure the tunnel parameters, and then use the link handle to execute the command.

use std::net::Ipv4Addr;
use rtnetlink::{new_connection, LinkIpIp};

#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(
            LinkIpIp::new("ipip0")
                .local(Ipv4Addr::new(192, 168, 1, 1))
                .remote(Ipv4Addr::new(10, 0, 0, 1))
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}

Use LinkIp6Tnl::new(name) to create a builder for an IPv6 Tunnel (IP6TNL) interface. You can configure properties like local/remote addresses, TTL, and encapsulation settings using the LinkMessageBuilder methods. Once configured, use the handle.link().add(...).execute().await pattern to create the interface on the system.

use std::net::Ipv6Addr;
use rtnetlink::{new_connection, LinkIp6Tnl};

#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(
            LinkIp6Tnl::new("ip6tnl0")
                .local(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1))
                .remote(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 2))
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}

To create a VXLAN interface, use LinkVxlan::new(name, vni) to initialize a LinkMessageBuilder. You can then chain configuration methods to define attributes like the physical device index, destination port, and IP addresses before calling .build() and executing the command via a link handle.

Note: LinkMessageBuilder::link() is not compatible with VXLAN; use the .dev(index) method instead to specify the physical device index.

use rtnetlink::{new_connection, LinkVxlan};

#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(LinkVxlan::new("vxlan100", 100)
            .dev(10)
            .port(4789)
            .up()
            .build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}

Use LinkCan::new(name) to initialize a LinkMessageBuilder for a CAN interface. You can then chain configuration methods like .bitrate(u32) or .bit_timing(CanBitTiming) before calling .build() to prepare the interface for addition via the netlink handle.

Note: The .bitrate() method is a shorthand for setting the bitrate within the bit timing parameters, equivalent to the ip link add ... type can bitrate BITRATE command.

use rtnetlink::{new_connection, LinkCan};

#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(
            LinkCan::new("can0")
                .bitrate(500000)
                .build()
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}