rtnetlink

https://docs.rs/rtnetlink/latest/rtnetlink
Admin
This crate provides methods to manipulate networking resources (links, addresses, arp tables, route...
Tokens:59,774
Snippets:1,165
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Create a VxLAN interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVxlan.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example demonstrating how to create and configure a VxLAN interface using the rtnetlink handle.

```rust
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}"))
}
```

--------------------------------

### Create a Netkit Pair

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkNetkit.html

Example demonstrating how to create a netkit pair using LinkNetkit and the rtnetlink handle.

```rust
use rtnetlink::{new_connection, LinkNetkit, packet_route::link::NetkitMode};
#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(LinkNetkit::new("netkit0", "netkit0-peer", NetkitMode::L3).build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a VLAN interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVlan.html?search=

Example demonstrating how to create a new VLAN interface using the LinkVlan struct and the rtnetlink handle.

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

    handle
        .link()
        .add(
            LinkVlan::new("vlan100", 10, 100)
                .up()
                .build()
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a GENEVE interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkGeneve.html

Example demonstrating how to create and configure a new GENEVE interface using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkGeneve::new("geneve0", 10)
        .remote("10.0.0.1".parse().unwrap())
        .up()
        .build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Creating a vcan interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVcan.html?search=

Example demonstrating how to create a new vcan interface using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkVcan::new("vcan0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Creating a rmnet interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkRmNet.html

Example demonstrating how to create a new rmnet interface using a parent device and a multiplexer ID.

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

    handle
        .link()
        .add(
            LinkRmNet::new("rmnet0")
                .parent_dev_name("dummy0")
                .mux_id(10)
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a virt_wifi interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVirtWifi.html

Example demonstrating how to create a new virt_wifi interface named 'virt_wifi0' using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkVirtWifi::new("virt_wifi0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a WireGuard interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkWireguard.html?search=

Example demonstrating how to create a new WireGuard interface named 'wg0' using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkWireguard::new("wg0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create an IP6TNL interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkIp6Tnl.html?search=

Example demonstrating how to create and configure an IP6TNL interface using the LinkIp6Tnl struct.

```rust
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}"))
}
```

--------------------------------

### Create a SIT interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkSit.html

Example demonstrating how to create a new SIT interface using LinkSit, setting the local and remote IPv4 addresses.

```rust
use std::net::Ipv4Addr;
use rtnetlink::{new_connection, LinkSit};
#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

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

--------------------------------

### Creating a WWAN interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkWwan.html

Example demonstrating how to create a WWAN interface using LinkWwan. The parent_dev_name method is required to specify the parent device.

```rust
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}"))
}
```

--------------------------------

### Create an AMT interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkAmt.html

Example demonstrating how to create and configure an AMT interface using the LinkAmt builder pattern.

```rust
use std::net::{IpAddr, Ipv4Addr};
use rtnetlink::{new_connection, LinkAmt};
use rtnetlink::packet_route::link::AmtMode;
#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(
            LinkAmt::new("amt0")
                .mode(AmtMode::Gateway)
                .dev(2)
                .local_ip(IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)))
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a GTP interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkGtp.html?search=

Example demonstrating how to create a new GTP interface using the LinkGtp builder pattern.

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

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

--------------------------------

### Create an IPIP interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkIpIp.html

Example demonstrating how to create an IPIP interface using LinkIpIp with local and remote IPv4 addresses.

```rust
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}"))
}
```

--------------------------------

### get()

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.NeighbourHandle.html?search=

Lists neighbour entries, equivalent to the 'ip neighbour show' command.

```APIDOC
## pub fn get(&self) -> NeighbourGetRequest

### Description
Lists neighbour entries. This is equivalent to running the `ip neighbour show` command.

### Returns
- **NeighbourGetRequest** - A request object to retrieve neighbour entries.
```

--------------------------------

### Create a CAN interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkCan.html?search=

Example demonstrating how to create and configure a new CAN interface named 'can0' with a specified bitrate using the rtnetlink handle.

```rust
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}"))
}
```

--------------------------------

### Create a vxcan pair

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVxcan.html?search=

Example demonstrating how to create a vxcan pair using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkVxcan::new("vxcan0", "vxcan1").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### get()

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.NeighbourHandle.html

List neighbour entries, equivalent to the 'ip neighbour show' command.

```APIDOC
## pub fn get(&self) -> NeighbourGetRequest

### Description
List neighbour entries (equivalent to `ip neighbour show`).

### Returns
- **NeighbourGetRequest** - A request object to retrieve neighbour entries.
```

--------------------------------

### Create a MAC VLAN interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkMacVlan.html

Example demonstrating how to create a new MAC VLAN interface using the LinkMacVlan builder.

```rust
use rtnetlink::{new_connection, packet_route::link::MacVlanMode,
                LinkMacVlan};

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

    handle
        .link()
        .add(
            LinkMacVlan::new("macvlan100", 10, MacVlanMode::Bridge)
                .up()
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Creating a VRF interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVrf.html

Example demonstrating how to create a new VRF interface using the LinkVrf struct and the rtnetlink handle.

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

    handle
        .link()
        .add(
            LinkVrf::new("my-vrf", 100)
                .up()
                .build()
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a XFRM interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkXfrm.html

Example demonstrating how to create a new XFRM interface using the LinkXfrm struct and the rtnetlink connection handle.

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

    handle
        .link()
        .add(LinkXfrm::new("xfrm8", 9, 0x08).build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a DSA interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkDsa.html

Example demonstrating how to create a new DSA interface using LinkDsa and the rtnetlink handle.

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

    handle
        .link()
        .add(
            LinkDsa::new("swp0")
                .conduit(3)
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a dummy interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkDummy.html

Example demonstrating how to create a new dummy interface named 'dummy0' using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkDummy::new("dummy0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a netdevsim interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkNetdevsim.html

Example demonstrating how to create a new netdevsim interface named 'netdevsim0' using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkNetdevsim::new("netdevsim0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a MACsec interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkMacSec.html

Example demonstrating how to create and configure a new MACsec interface using LinkMacSec and the rtnetlink handle.

```rust
use rtnetlink::{new_connection, LinkMacSec};

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

    handle
        .link()
        .add(
            LinkMacSec::new("macsec0", 10)
                .up()
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a PFCP interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkPfcp.html

Example demonstrating how to create a new PFCP interface named 'pfcp0' using the rtnetlink library.

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

    handle
        .link()
        .add(LinkPfcp::new("pfcp0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a TUN interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkTun.html

Example demonstrating how to create a new TUN interface named 'tun0' using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkTun::new("tun0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a nlmon interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkNlmon.html?search=

Example demonstrating how to create a new nlmon interface named 'nl0' using the rtnetlink handle.

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

    handle
        .link()
        .add(LinkNlmon::new("nl0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create an ifb interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkIfb.html

Example demonstrating how to create an ifb interface named 'ifb0' using the rtnetlink connection handle.

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

    handle
        .link()
        .add(LinkIfb::new("ifb0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Creating a veth pair

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVeth.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example code demonstrating how to create a veth pair using the LinkVeth struct and the rtnetlink handle.

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

    handle
        .link()
        .add(LinkVeth::new("veth1", "veth1-peer").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create an IPoIB interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkIpoib.html

Example demonstrating how to create an IPoIB interface named 'ib0' with a specific mode and partition key using the rtnetlink handle.

```rust
use rtnetlink::{new_connection, LinkIpoib};
use rtnetlink::packet_route::link::IpoibMode;
#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().unwrap();
    tokio::spawn(connection);

    handle
        .link()
        .add(
            LinkIpoib::new("ib0")
                .mode(IpoibMode::Connected)
                .pkey(0x8001)
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a Linux Bridge Interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBridge.html

Example demonstrating how to create a new Linux bridge interface named 'br0' using the LinkBridge struct.

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

    handle
        .link()
        .add(LinkBridge::new("br0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### get

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.TrafficFilterHandle.html

Retrieves the list of filters, equivalent to the 'tc filter show dev <iface_name>' command.

```APIDOC
## pub fn get(&mut self) -> TrafficFilterGetRequest

### Description
Retrieve the list of filters associated with the interface.

### Returns
- **TrafficFilterGetRequest** - A request object to execute the filter retrieval.
```

--------------------------------

### Attach interface to controller using LinkUnspec

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkUnspec.html

Example demonstrating how to use LinkUnspec to set a controller index for a network interface identified by name.

```rust
use rtnetlink::{new_connection, LinkUnspec};

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

    let controller_index = 63u32;

    handle
        .link()
        .set(
            LinkUnspec::new_with_name("my-nic")
                .controller(controller_index)
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a HSR interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkHsr.html

Example demonstrating how to create and configure a new HSR interface named 'hsr0' with specific ports using the LinkHsr builder.

```rust
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}"))
}
```

--------------------------------

### Creating a team interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkTeam.html?search=

Example showing how to create a new team interface named 'team0' using the LinkTeam struct and the rtnetlink handle.

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

    handle
        .link()
        .add(LinkTeam::new("team0").build())
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### Create a MAC VTAP interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkMacVtap.html

This example demonstrates how to create a new MAC VTAP interface named 'macvtap100' using the Bridge mode on a base interface with index 10.

```rust
use rtnetlink::{new_connection, packet_route::link::MacVtapMode,
                LinkMacVtap};

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

    handle
        .link()
        .add(
            LinkMacVtap::new("macvtap100", 10, MacVtapMode::Bridge)
                .up()
                .build(),
        )
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### TrafficClassGetRequest::execute

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.TrafficClassGetRequest.html?search=

Executes the traffic class get request and returns a stream of results.

```APIDOC
## pub fn execute(self) -> impl Stream<Item = Result<TcMessage, Error>>

### Description
Executes the traffic class get request. This method consumes the request and returns a stream of `TcMessage` results or an `Error`.

### Signature
`pub fn execute(self) -> impl Stream<Item = Result<TcMessage, Error>>`

### Returns
- **impl Stream<Item = Result<TcMessage, Error>>** - A stream of traffic class messages or errors encountered during execution.
```

--------------------------------

### RouteGetRequest::execute

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.RouteGetRequest.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Executes the route get request and returns a stream of route messages.

```APIDOC
## pub fn execute(self) -> impl Stream<Item = Result<RouteMessage, Error>>

### Description
Executes the route get request. This method consumes the request and returns a stream of results, where each item is either a RouteMessage or an Error.

### Returns
- **impl Stream<Item = Result<RouteMessage, Error>>** - A stream of route messages retrieved from the system.
```

--------------------------------

### Create a bond interface

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBond.html

Demonstrates how to use the LinkBond builder to configure and execute the creation of a new bond interface.

```rust
use rtnetlink::{new_connection, LinkBond, packet_route::link::BondMode};

#[tokio::main]
async fn main() -> Result<(), String> {
    let (connection, handle, _) = new_connection().map_err(|e|
        format!("{e}"))?;
    tokio::spawn(connection);

    let message = LinkBond::new("bond0")
       .mode(BondMode::ActiveBackup)
       .miimon(100)
       .updelay(100)
       .downdelay(100)
       .min_links(2)
       .up()
       .build();

    handle
        .link()
        .add(message)
        .execute()
        .await
        .map_err(|e| format!("{e}"))
}
```

--------------------------------

### LinkBatAdv::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBatAdv.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new LinkBatAdv instance for the specified interface name.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new instance of `LinkBatAdv` associated with the provided interface name. This returns a `LinkMessageBuilder` for further configuration.

### Parameters
- **name** (&str) - Required - The name of the batadv interface.
```

--------------------------------

### QDiscHandle::get

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscHandle.html

Retrieves the list of qdisc, equivalent to the 'tc qdisc show' command.

```APIDOC
## pub fn get(&mut self) -> QDiscGetRequest

### Description
Retrieve the list of qdisc (equivalent to `tc qdisc show`).

### Returns
- **QDiscGetRequest** - A request object to perform the qdisc retrieval.
```

--------------------------------

### LinkBareudp::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBareudp.html?search=u32+-%3E+bool

Creates a new instance of a BareUDP interface builder with the specified name.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new LinkBareudp interface builder using the provided name.

### Parameters
- **name** (&str) - Required - The name of the BareUDP interface to create.

### Returns
- **LinkMessageBuilder<Self>** - A builder object for configuring the BareUDP link message.
```

--------------------------------

### LinkBatAdv::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBatAdv.html?search=

Creates a new instance of LinkBatAdv for the specified interface name, returning a builder for the link message.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new LinkBatAdv instance associated with the provided interface name. This returns a LinkMessageBuilder that can be used to construct the link message.

### Parameters
- **name** (&str) - Required - The name of the batadv interface.
```

--------------------------------

### pub fn from_socket<S>(socket: S) -> (Connection<RouteNetlinkMessage, S>, Handle, UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>)

Source: https://docs.rs/rtnetlink/latest/rtnetlink/fn.from_socket.html?search=

Initializes a new netlink connection using the provided asynchronous socket.

```APIDOC
## Function: from_socket

### Description
Creates a new netlink connection from an existing asynchronous socket. This function returns a tuple containing the connection object, a handle for sending requests, and an unbounded receiver for incoming netlink messages.

### Signature
`pub fn from_socket<S>(socket: S) -> (Connection<RouteNetlinkMessage, S>, Handle, UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>)`

### Parameters
- **socket** (S) - Required - An object implementing the `AsyncSocket` trait.

### Returns
- **Connection<RouteNetlinkMessage, S>** - The connection object managing the netlink stream.
- **Handle** - A handle used to interact with the netlink connection.
- **UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>** - A receiver for processing incoming netlink messages and their associated socket addresses.
```

--------------------------------

### pub fn new_connection()

Source: https://docs.rs/rtnetlink/latest/rtnetlink/fn.new_connection.html

Initializes a new netlink connection and returns the connection object, a handle, and a message receiver.

```APIDOC
## fn new_connection

### Description
Creates a new netlink connection for route netlink messages.

### Signature
`pub fn new_connection() -> Result<(Connection<RouteNetlinkMessage>, Handle, UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>)>`

### Returns
- **Connection<RouteNetlinkMessage>** - The connection object.
- **Handle** - A handle to interact with the connection.
- **UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>** - A receiver for incoming netlink messages and their source socket addresses.
```

--------------------------------

### pub fn get(&mut self) -> TrafficClassGetRequest

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.TrafficClassHandle.html

Retrieves the list of traffic classes for the associated network interface, equivalent to the 'tc class show dev <interface_name>' command.

```APIDOC
## pub fn get(&mut self) -> TrafficClassGetRequest

### Description
Retrieves the list of traffic classes for the associated network interface. This is the programmatic equivalent of running the `tc class show dev <interface_name>` command.

### Returns
- **TrafficClassGetRequest** - A request object that can be used to execute the retrieval of traffic class information.
```

--------------------------------

### LinkBatAdv::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBatAdv.html?search=u32+-%3E+bool

Creates a new instance of LinkBatAdv for the specified interface name, returning a LinkMessageBuilder.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new LinkBatAdv instance associated with the provided interface name. This returns a builder pattern object used to construct link messages.

### Parameters
- **name** (&str) - Required - The name of the batadv interface.
```

--------------------------------

### LinkBareudp::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBareudp.html?search=

Creates a new LinkBareudp instance with the specified interface name.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new builder for a BareUDP network interface with the given name.

### Parameters
- **name** (&str) - Required - The name of the BareUDP interface.

### Returns
- **LinkMessageBuilder<Self>** - A builder object used to configure and create the link message.
```

--------------------------------

### QDiscNewRequest Methods

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscNewRequest.html?search=

Methods available for configuring and executing a QDiscNewRequest.

```APIDOC
## pub async fn execute(self) -> Result<(), Error>

### Description
Executes the configured queueing discipline request.

## pub fn handle(self, major: u16, minor: u16) -> Self

### Description
Sets the handle for the qdisc request.

## pub fn root(self) -> Self

### Description
Sets the parent of the qdisc to root.

## pub fn parent(self, parent: u32) -> Self

### Description
Sets the parent identifier for the qdisc request.

## pub fn ingress(self) -> Self

### Description
Configures the request for a new ingress qdisc.
```

--------------------------------

### LinkIpVtap::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkIpVtap.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new LinkIpVtap instance, returning a builder for further configuration of the network interface.

```APIDOC
## pub fn new(name: &str, base_iface_index: u32, mode: IpVtapMode) -> LinkMessageBuilder<Self>

### Description
Creates a new configuration for an IPVTAP interface. This acts as a wrapper for the LinkMessageBuilder to set the link name, base interface index, and operation mode.

### Parameters
- **name** (&str) - The name of the interface.
- **base_iface_index** (u32) - The index of the base interface.
- **mode** (IpVtapMode) - The mode of the IPVTAP interface.

### Returns
- **LinkMessageBuilder<Self>** - A builder object used to finalize the link creation message.
```

--------------------------------

### QDiscHandle::add

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscHandle.html

Creates a new qdisc, equivalent to 'tc qdisc add dev STRING'.

```APIDOC
## pub fn add(&mut self, index: i32) -> QDiscNewRequest

### Description
Create a new qdisc, don’t replace if the object already exists (equivalent to `tc qdisc add dev STRING`).

### Parameters
- **index** (i32) - The interface index.

### Returns
- **QDiscNewRequest** - A request object to perform the qdisc creation.
```

--------------------------------

### QDiscNewRequest Methods

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscNewRequest.html?search=std%3A%3Avec

Methods available for configuring and executing a new queueing discipline request.

```APIDOC
## pub async fn execute(self) -> Result<(), Error>

### Description
Executes the configured queueing discipline request.

## pub fn handle(self, major: u16, minor: u16) -> Self

### Description
Sets the handle for the qdisc request.

## pub fn root(self) -> Self

### Description
Sets the parent of the qdisc to root.

## pub fn parent(self, parent: u32) -> Self

### Description
Sets the parent identifier for the qdisc.

## pub fn ingress(self) -> Self

### Description
Configures the request to create a new ingress qdisc.
```

--------------------------------

### LinkBareudp::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBareudp.html?search=std%3A%3Avec

Creates a new instance of a LinkBareudp interface builder with the specified name.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new builder for a BareUDP network interface with the given name.

### Parameters
- **name** (&str) - Required - The name of the network interface to be created.
```

--------------------------------

### LinkBareudp::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBareudp.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new instance of a LinkBareudp interface builder with the specified name.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new LinkBareudp instance, returning a builder for configuring the interface.

### Parameters
- **name** (&str) - Required - The name of the BareUDP interface to create.
```

--------------------------------

### QDiscNewRequest::ingress

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscNewRequest.html?search=u32+-%3E+bool

Configures the request to create an ingress qdisc.

```APIDOC
## pub fn ingress(self) -> Self

### Description
Configures the request to create a new ingress queueing discipline.
```

--------------------------------

### LinkMacVtap::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkMacVtap.html?search=std%3A%3Avec

Creates a new LinkMacVtap instance, returning a builder to configure the interface.

```APIDOC
## pub fn new(name: &str, base_iface_index: u32, mode: MacVtapMode) -> LinkMessageBuilder<Self>

### Description
Creates a new MAC VTAP interface configuration. This acts as a wrapper for the underlying LinkMessageBuilder to set the link and mode.

### Parameters
- **name** (&str) - The name of the new MAC VTAP interface.
- **base_iface_index** (u32) - The index of the base interface to attach the MAC VTAP to.
- **mode** (MacVtapMode) - The operational mode for the MAC VTAP (e.g., Bridge, Private, VEPA, Passthru).
```

--------------------------------

### QDiscNewRequest::execute

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscNewRequest.html?search=u32+-%3E+bool

Executes the constructed queueing discipline request.

```APIDOC
## pub async fn execute(self) -> Result<(), Error>

### Description
Executes the configured queueing discipline request.

### Returns
- **Result<(), Error>** - Returns Ok(()) on success, or an Error if the request fails.
```

--------------------------------

### QDiscGetRequest::ingress

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscGetRequest.html?search=u32+-%3E+bool

Configures the request to target the ingress qdisc.

```APIDOC
## pub fn ingress(self) -> Self

### Description
Configures the request to retrieve the ingress qdisc.
```

--------------------------------

### from_socket<S>(socket: S)

Source: https://docs.rs/rtnetlink/latest/rtnetlink/fn.from_socket.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a new netlink connection using the provided asynchronous socket.

```APIDOC
## from_socket

### Description
Creates a new connection, handle, and message receiver from an existing asynchronous socket.

### Signature
`pub fn from_socket<S>(socket: S) -> (Connection<RouteNetlinkMessage, S>, Handle, UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>)`

### Constraints
- `S: AsyncSocket`

### Returns
- `Connection<RouteNetlinkMessage, S>`: The connection object.
- `Handle`: The handle to interact with the netlink socket.
- `UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>`: A stream of incoming messages and their source addresses.
```

--------------------------------

### QDiscGetRequest implementation methods

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscGetRequest.html?search=std%3A%3Avec

Methods available for the QDiscGetRequest struct to execute requests and configure filters.

```rust
pub fn execute(self) -> impl Stream<Item = Result<TcMessage, Error>>
```

```rust
pub fn index(self, index: i32) -> Self
```

```rust
pub fn ingress(self) -> Self
```

--------------------------------

### execute method

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkGetRequest.html?search=

Executes the link request and returns a stream of link messages.

```rust
pub fn execute(self) -> impl Stream<Item = Result<LinkMessage, Error>>
```

--------------------------------

### QDiscGetRequest::execute

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscGetRequest.html

Executes the configured qdisc retrieval request and returns a stream of results.

```APIDOC
## pub fn execute(self) -> impl Stream<Item = Result<TcMessage, Error>>

### Description
Executes the request to retrieve qdisc information. Returns a stream of `TcMessage` results.

### Signature
`pub fn execute(self) -> impl Stream<Item = Result<TcMessage, Error>>`
```

--------------------------------

### LinkIpVtap::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkIpVtap.html?search=std%3A%3Avec

Creates a new instance of LinkIpVtap using the provided interface name, base interface index, and mode.

```APIDOC
## pub fn new(name: &str, base_iface_index: u32, mode: IpVtapMode) -> LinkMessageBuilder<Self>

### Description
Creates a new LinkIpVtap instance. This is a wrapper for `LinkMessageBuilder::<LinkIpVtap>::new().link().mode()`.

### Parameters
- **name** (&str) - The name of the interface.
- **base_iface_index** (u32) - The index of the base interface.
- **mode** (IpVtapMode) - The mode for the IPVTAP interface.

### Returns
- **LinkMessageBuilder<Self>** - A builder for the link message.
```

--------------------------------

### LinkVti6::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVti6.html

Creates a new instance of a LinkVti6 builder with the specified link name.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new LinkVti6 instance for a VTI6 link with the given name. This returns a builder that can be used to further configure the link message.

### Parameters
- **name** (&str) - Required - The name of the VTI6 link to be created.
```

--------------------------------

### Create a new LinkBondPort

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkBondPort.html

Initializes a new LinkBondPort using a port index.

```rust
pub fn new(port_index: u32) -> LinkMessageBuilder<Self>
```

--------------------------------

### fn from_socket

Source: https://docs.rs/rtnetlink/latest/rtnetlink/fn.from_socket.html?search=u32+-%3E+bool

Initializes a new netlink connection using the provided asynchronous socket.

```APIDOC
## fn from_socket<S>(socket: S)

### Description
Creates a new netlink connection from an existing asynchronous socket. This function returns a tuple containing the connection object, a handle for interacting with the netlink socket, and an unbounded receiver for incoming messages.

### Signature
`pub fn from_socket<S>(socket: S) -> (Connection<RouteNetlinkMessage, S>, Handle, UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>)`

### Constraints
- **S**: Must implement `AsyncSocket`.
```

--------------------------------

### fn from_socket<S>(socket: S) -> (Connection<RouteNetlinkMessage, S>, Handle, UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>)

Source: https://docs.rs/rtnetlink/latest/rtnetlink/fn.from_socket.html?search=std%3A%3Avec

Initializes a new netlink connection using the provided asynchronous socket. Returns a tuple containing the connection, a handle for operations, and a receiver for incoming messages.

```APIDOC
## Function: from_socket

### Description
Creates a new netlink connection from an existing asynchronous socket. This function returns the connection object, a handle to interact with the netlink socket, and a receiver for incoming messages.

### Signature
`pub fn from_socket<S>(socket: S) -> (Connection<RouteNetlinkMessage, S>, Handle, UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>)`

### Parameters
- **socket** (S) - The asynchronous socket to be used for the connection. Must implement the `AsyncSocket` trait.

### Returns
- **Connection<RouteNetlinkMessage, S>** - The connection object managing the netlink stream.
- **Handle** - A handle used to send requests over the netlink connection.
- **UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>** - A receiver for messages received from the netlink socket.
```

--------------------------------

### CloneToUninit implementation

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscHandle.html?search=std%3A%3Avec

Experimental nightly-only API for performing copy-assignment from self to a destination pointer.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### XFRM Configuration Methods

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkMessageBuilder.html

Methods for creating and configuring XFRM interface types.

```APIDOC
## pub fn new(name: &str) -> Self

### Description
Create LinkMessageBuilder for XFRM.

## pub fn if_id(self, if_id: u32) -> Self

### Description
Sets the if_id for the XFRM interface. Equivalent to `if_id IF_ID`.

## pub fn dev(self, iface_index: u32) -> Self

### Description
Sets the physical device index for the XFRM interface. Equivalent to `dev PHYS_DEV`.
```

--------------------------------

### LinkVti::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVti.html?search=std%3A%3Avec

Creates a new LinkVti instance with the specified name, returning a builder for further configuration.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new VTI link builder with the provided name.

### Parameters
- **name** (&str) - Required - The name of the VTI link to be created.

### Returns
- **LinkMessageBuilder<Self>** - A builder object used to configure the VTI link.
```

--------------------------------

### LinkVti::new

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkVti.html?search=u32+-%3E+bool

Creates a new LinkVti instance with the specified name, returning a builder for further configuration.

```APIDOC
## pub fn new(name: &str) -> LinkMessageBuilder<Self>

### Description
Creates a new instance of `LinkVti` with the provided name. This returns a `LinkMessageBuilder` which can be used to configure the link properties.

### Parameters
- **name** (&str) - Required - The name of the VTI link to be created.

### Returns
- **LinkMessageBuilder<Self>** - A builder object for constructing the link message.
```

--------------------------------

### execute

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkSetRequest.html

Executes the link set request.

```APIDOC
## pub async fn execute(self) -> Result<(), Error>

### Description
Executes the link set request.

### Returns
- **Result<(), Error>** - Returns Ok(()) on success, or an Error if the execution fails.
```

--------------------------------

### WWAN Configuration Methods

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.LinkMessageBuilder.html

Methods for creating and configuring WWAN interface types.

```APIDOC
## pub fn new(name: &str) -> Self

### Description
Create LinkMessageBuilder for wwan interface type.

## pub fn linkid(self, linkid: u32) -> Self

### Description
Sets the linkid for the wwan interface. Equivalent to `linkid LINKID` in `ip link add name NAME type wwan linkid LINKID`.

## pub fn parent_dev_name(self, parent: impl Into<String>) -> Self

### Description
Specifies the parent device name of the wwan interface. Equivalent to `parentdev PARENTDEV`.
```

--------------------------------

### execute

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscDelRequest.html

Executes the QDisc deletion request.

```APIDOC
## pub async fn execute(self) -> Result<(), Error>

### Description
Executes the QDisc deletion request and returns the result.

### Returns
- **Result<(), Error>** - Returns Ok(()) on success, or an Error if the operation fails.
```

--------------------------------

### new_connection_with_socket<S>()

Source: https://docs.rs/rtnetlink/latest/rtnetlink/fn.new_connection_with_socket.html?search=

Initializes a new netlink connection with a given asynchronous socket.

```APIDOC
## Function: new_connection_with_socket<S>()

### Description
Creates a new netlink connection using the provided asynchronous socket. This function returns a tuple containing the connection, a handle for operations, and an unbounded receiver for incoming messages.

### Signature
`pub fn new_connection_with_socket<S>() -> Result<(Connection<RouteNetlinkMessage, S>, Handle, UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>)>`

### Constraints
- **S**: Must implement `AsyncSocket`

### Returns
- **Result**: A tuple containing:
  - `Connection<RouteNetlinkMessage, S>`: The netlink connection object.
  - `Handle`: A handle to interact with the connection.
  - `UnboundedReceiver<(NetlinkMessage<RouteNetlinkMessage>, SocketAddr)>`: A receiver for messages and their source addresses.
```

--------------------------------

### QDiscNewRequest::root

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.QDiscNewRequest.html?search=u32+-%3E+bool

Sets the parent of the qdisc to root.

```APIDOC
## pub fn root(self) -> Self

### Description
Configures the qdisc to be attached to the root parent.
```

--------------------------------

### AddressHandle::get

Source: https://docs.rs/rtnetlink/latest/rtnetlink/struct.AddressHandle.html?search=

Retrieves the list of IP addresses from the system, equivalent to running 'ip addr show'.

```APIDOC
## fn get(&self) -> AddressGetRequest

### Description
Retrieve the list of ip addresses (equivalent to `ip addr show`).

### Returns
- **AddressGetRequest** - A request object to execute the retrieval of IP addresses.
```
Tokens:
Raw