netui 0.2.1

NetUI is a Rust-based tui designed to monitor network interfaces. It allows you to send ARP messages via the network interface and listen for packets to show bandwidth stats.
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
138
139
140
141
142
143
144
145
146
147

//! Default gateway detection for distinguishing Internet vs LAN traffic.
//!
//! This module provides cross-platform gateway detection to identify
//! the default route used for Internet traffic.

use std::net::Ipv4Addr;

#[cfg(target_os = "macos")]
use std::process::Command;

/// Detect the default gateway IPv4 address.
///
/// This function attempts to detect the default gateway using platform-specific
/// methods. The gateway is the router that handles Internet traffic.
///
/// # Returns
/// - `Some(Ipv4Addr)` - The gateway IP if detected
/// - `None` - If gateway detection fails
///
/// # Platform Support
/// - **Linux**: Uses `/proc/net/route` parsing
/// - **macOS**: Uses `netstat -rn` command
/// - **Other**: Returns None (could be extended)
pub fn detect_default_gateway() -> Option<Ipv4Addr> {
    #[cfg(target_os = "linux")]
    {
        detect_gateway_linux()
    }

    #[cfg(target_os = "macos")]
    {
        detect_gateway_macos()
    }

    #[cfg(not(any(target_os = "linux", target_os = "macos")))]
    {
        detect_gateway_fallback()
    }
}

/// Detect default gateway on Linux by parsing /proc/net/route.
#[cfg(target_os = "linux")]
fn detect_gateway_linux() -> Option<Ipv4Addr> {
    use std::fs;

    // /proc/net/route format:
    // Iface Destination Gateway Flags ...
    // eth0  00000000    010011AC  ...  (Destination 00000000 = default route)
    if let Ok(content) = fs::read_to_string("/proc/net/route") {
        for line in content.lines().skip(1) {
            // Skip header
            let parts: Vec<&str> = line.split_whitespace().collect();
            if parts.len() >= 3 {
                // Destination is in hex, little-endian
                let dest = parts[1];
                // Gateway is in hex, little-endian
                let gateway_hex = parts[2];

                // Check if this is the default route (Destination == 00000000)
                if dest == "00000000" && gateway_hex != "00000000" {
                    // Parse hex gateway address (little-endian)
                    if let Ok(gateway_u32) = u32::from_str_radix(gateway_hex, 16) {
                        // Convert from little-endian to host order
                        let gateway_bytes = gateway_u32.to_le_bytes();
                        return Some(Ipv4Addr::new(
                            gateway_bytes[0],
                            gateway_bytes[1],
                            gateway_bytes[2],
                            gateway_bytes[3],
                        ));
                    }
                }
            }
        }
    }

    tracing::debug!("Failed to detect gateway on Linux");
    None
}

/// Detect default gateway on macOS using `netstat -rn`.
#[cfg(target_os = "macos")]
fn detect_gateway_macos() -> Option<Ipv4Addr> {
    // netstat -rn output format:
    // Destination        Gateway            Flags
    // default            192.168.1.1        UGSc
    let output = Command::new("netstat")
        .arg("-rn")
        .arg("-f")
        .arg("inet")
        .output();

    if let Ok(output) = output {
        let content = String::from_utf8_lossy(&output.stdout);
        for line in content.lines() {
            let line = line.trim();
            // Look for "default" route
            if line.starts_with("default") || line.starts_with("0.0.0.0") {
                let parts: Vec<&str> = line.split_whitespace().collect();
                // The gateway is typically the second column
                if parts.len() >= 2 {
                    if let Ok(gateway) = parts[1].parse::<Ipv4Addr>() {
                        return Some(gateway);
                    }
                }
            }
        }
    }

    tracing::debug!("Failed to detect gateway on macOS");
    None
}

/// Fallback gateway detection (returns None).
///
/// This could be extended to support other platforms or use
/// external libraries like pnet for cross-platform detection.
#[cfg(not(any(target_os = "linux", target_os = "macos")))]
fn detect_gateway_fallback() -> Option<Ipv4Addr> {
    tracing::warn!("Gateway detection not implemented for this platform");
    None
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_detect_gateway_returns_some_ip() {
        // This test will pass if gateway detection works on the current platform
        // It may return None on unsupported platforms or in CI environments
        let gateway = detect_default_gateway();
        if let Some(gw) = gateway {
            // Verify it's a valid IPv4 address (not 0.0.0.0)
            assert_ne!(gw, Ipv4Addr::new(0, 0, 0, 0));
            println!("Detected gateway: {}", gw);
        } else {
            println!("Gateway detection returned None (expected in some environments)");
        }
    }

    #[test]
    fn test_detect_gateway_does_not_panic() {
        // Verify the function doesn't panic
        let _ = detect_default_gateway();
    }
}