nlink 0.15.1

Async netlink library for Linux network configuration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

//! Monitor ethtool events in real-time.
//!
//! This example demonstrates how to subscribe to the ethtool netlink
//! monitor multicast group and receive notifications about configuration
//! changes.
//!
//! # Usage
//!
//! ```bash
//! cargo run --example ethtool_monitor
//! ```
//!
//! Then in another terminal, change interface settings:
//! ```bash
//! sudo ethtool -s eth0 speed 100 duplex full
//! ```
//!
//! # Requirements
//!
//! - Linux kernel 5.6+ with ethtool netlink support
//! - No special privileges required for monitoring

use nlink::netlink::{Connection, Ethtool, genl::ethtool::EthtoolEvent};
use tokio_stream::StreamExt;

#[tokio::main]
async fn main() -> nlink::Result<()> {
    println!("Monitoring ethtool events (Ctrl+C to stop)...\n");

    let mut conn = Connection::<Ethtool>::new_async().await?;

    // Subscribe to the monitor multicast group
    conn.subscribe()?;
    println!("Subscribed to ethtool monitor group\n");

    // Receive and display events using the Stream API
    let mut events = conn.events();
    while let Some(result) = events.next().await {
        match result {
            Ok(event) => {
                print_event(&event);
            }
            Err(e) => {
                eprintln!("Error receiving event: {}", e);
            }
        }
    }

    Ok(())
}

fn print_event(event: &EthtoolEvent) {
    match event {
        EthtoolEvent::LinkStateChanged { ifname, state } => {
            let name = ifname.as_deref().unwrap_or("?");
            println!(
                "[{}] Link state: {}",
                name,
                if state.link { "UP" } else { "DOWN" }
            );
            if let Some(sqi) = state.sqi {
                println!("       SQI: {}/{}", sqi, state.sqi_max.unwrap_or(100));
            }
        }
        EthtoolEvent::LinkModesChanged { ifname, modes } => {
            let name = ifname.as_deref().unwrap_or("?");
            println!("[{}] Link modes changed:", name);
            if let Some(speed) = modes.speed {
                println!("       Speed: {} Mb/s", speed);
            }
            if let Some(duplex) = &modes.duplex {
                println!("       Duplex: {:?}", duplex);
            }
            println!(
                "       Autoneg: {}",
                if modes.autoneg { "on" } else { "off" }
            );
        }
        EthtoolEvent::LinkInfoChanged { ifname, info } => {
            let name = ifname.as_deref().unwrap_or("?");
            println!("[{}] Link info changed:", name);
            if let Some(port) = &info.port {
                println!("       Port: {:?}", port);
            }
            if let Some(transceiver) = &info.transceiver {
                println!("       Transceiver: {:?}", transceiver);
            }
        }
        EthtoolEvent::FeaturesChanged { ifname, features } => {
            let name = ifname.as_deref().unwrap_or("?");
            let active_count = features.active_features().len();
            println!("[{}] Features changed: {} active", name, active_count);
        }
        EthtoolEvent::RingsChanged { ifname, rings } => {
            let name = ifname.as_deref().unwrap_or("?");
            println!("[{}] Ring sizes changed:", name);
            if let Some(rx) = rings.rx {
                println!("       RX: {}", rx);
            }
            if let Some(tx) = rings.tx {
                println!("       TX: {}", tx);
            }
        }
        EthtoolEvent::ChannelsChanged { ifname, channels } => {
            let name = ifname.as_deref().unwrap_or("?");
            println!("[{}] Channels changed:", name);
            if let Some(combined) = channels.combined_count {
                println!("       Combined: {}", combined);
            }
        }
        EthtoolEvent::CoalesceChanged { ifname, coalesce } => {
            let name = ifname.as_deref().unwrap_or("?");
            println!("[{}] Coalesce changed:", name);
            if let Some(rx_usecs) = coalesce.rx_usecs {
                println!("       RX usecs: {}", rx_usecs);
            }
            if let Some(tx_usecs) = coalesce.tx_usecs {
                println!("       TX usecs: {}", tx_usecs);
            }
        }
        EthtoolEvent::PauseChanged { ifname, pause } => {
            let name = ifname.as_deref().unwrap_or("?");
            println!("[{}] Pause changed:", name);
            if let Some(rx) = pause.rx {
                println!("       RX: {}", if rx { "on" } else { "off" });
            }
            if let Some(tx) = pause.tx {
                println!("       TX: {}", if tx { "on" } else { "off" });
            }
        }
        EthtoolEvent::Unknown { cmd } => {
            println!("[?] Unknown event: cmd={}", cmd);
        }
        _ => {}
    }
    println!();
}