nd300 3.0.5

Cross-platform network diagnostic tool
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

use serde::Serialize;

use super::shared_cache::SharedCache;

#[derive(Debug, Clone, Serialize)]
pub struct ReverseDnsEntry {
    pub ip: String,
    pub hostname: Option<String>,
    pub label: String,
}

pub async fn collect_with_cache(cache: &SharedCache) -> Option<Vec<ReverseDnsEntry>> {
    let mut entries = Vec::new();

    let gateway_ip = cache.gateway_ip.clone();

    let mut ips_to_check: Vec<(String, String)> = Vec::new();

    if let Some(ref gw) = gateway_ip {
        ips_to_check.push((gw.clone(), "Gateway".to_string()));
    }

    ips_to_check.push(("1.1.1.1".to_string(), "Cloudflare DNS".to_string()));
    ips_to_check.push(("8.8.8.8".to_string(), "Google DNS".to_string()));

    for (ip, label) in ips_to_check {
        let hostname = reverse_lookup(&ip).await;
        entries.push(ReverseDnsEntry {
            ip,
            hostname,
            label,
        });
    }

    if entries.is_empty() {
        None
    } else {
        Some(entries)
    }
}

pub async fn collect() -> Option<Vec<ReverseDnsEntry>> {
    let mut entries = Vec::new();

    // Get gateway IP
    let gateway_ip = default_net::get_default_gateway()
        .ok()
        .map(|gw| gw.ip_addr.to_string());

    // Collect IPs to reverse-lookup
    let mut ips_to_check: Vec<(String, String)> = Vec::new();

    if let Some(ref gw) = gateway_ip {
        ips_to_check.push((gw.clone(), "Gateway".to_string()));
    }

    ips_to_check.push(("1.1.1.1".to_string(), "Cloudflare DNS".to_string()));
    ips_to_check.push(("8.8.8.8".to_string(), "Google DNS".to_string()));

    for (ip, label) in ips_to_check {
        let hostname = reverse_lookup(&ip).await;
        entries.push(ReverseDnsEntry {
            ip,
            hostname,
            label,
        });
    }

    if entries.is_empty() {
        None
    } else {
        Some(entries)
    }
}

async fn reverse_lookup(ip: &str) -> Option<String> {
    #[cfg(windows)]
    {
        let output = tokio::process::Command::new("nslookup")
            .args([ip])
            .output()
            .await
            .ok()?;

        let text = String::from_utf8_lossy(&output.stdout);
        for line in text.lines() {
            if line.trim().starts_with("Name:") {
                return line.split(':').nth(1).map(|s| s.trim().to_string());
            }
        }
        None
    }

    #[cfg(unix)]
    {
        let output = tokio::process::Command::new("dig")
            .args(["-x", ip, "+short"])
            .output()
            .await
            .ok()?;

        let text = String::from_utf8_lossy(&output.stdout).trim().to_string();
        if text.is_empty() {
            None
        } else {
            Some(text.trim_end_matches('.').to_string())
        }
    }
}