nd300 3.1.0

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

use serde::Serialize;
use std::time::Duration;

use super::DiagnosticResult;

#[derive(Debug, Clone, Serialize)]
pub struct PortResult {
    pub port: u16,
    pub service: String,
    pub host: String,
    pub open: bool,
    pub latency_ms: Option<f64>,
}

const PORT_TESTS: &[(u16, &str, &str)] = &[
    (80, "HTTP", "1.1.1.1"),
    (443, "HTTPS", "1.1.1.1"),
    (53, "DNS", "8.8.8.8"),
    (22, "SSH", "github.com"),
];

pub async fn check() -> (DiagnosticResult, Vec<PortResult>) {
    let mut results = Vec::new();

    let mut handles = Vec::new();
    for (port, service, host) in PORT_TESTS {
        let port = *port;
        let service = service.to_string();
        let host = host.to_string();
        handles.push(tokio::spawn(async move {
            test_port(&host, port, &service).await
        }));
    }

    for handle in handles {
        if let Ok(result) = handle.await {
            results.push(result);
        }
    }

    let open = results.iter().filter(|r| r.open).count();
    let total = results.len();

    let result = if open == total {
        DiagnosticResult::ok("Ports", "All common ports open")
    } else if open == 0 {
        DiagnosticResult::fail("Ports", "All tested ports blocked")
    } else {
        let blocked: Vec<String> = results
            .iter()
            .filter(|r| !r.open)
            .map(|r| format!("{} ({})", r.service, r.port))
            .collect();
        DiagnosticResult::warn("Ports", format!("Blocked: {}", blocked.join(", ")))
    };

    (result, results)
}

async fn test_port(host: &str, port: u16, service: &str) -> PortResult {
    let addr = format!("{}:{}", host, port);
    let start = std::time::Instant::now();

    // Resolve hostname first if needed (bounded so a dead resolver can't hang).
    let addrs = match super::util::lookup_host_timeout(addr, super::util::RESOLVE).await {
        Some(addrs) => addrs,
        None => {
            return PortResult {
                port,
                service: service.to_string(),
                host: host.to_string(),
                open: false,
                latency_ms: None,
            };
        }
    };

    for addr in addrs {
        match tokio::time::timeout(Duration::from_secs(5), tokio::net::TcpStream::connect(addr))
            .await
        {
            Ok(Ok(_stream)) => {
                let latency = start.elapsed().as_secs_f64() * 1000.0;
                return PortResult {
                    port,
                    service: service.to_string(),
                    host: host.to_string(),
                    open: true,
                    latency_ms: Some(latency),
                };
            }
            _ => continue,
        }
    }

    PortResult {
        port,
        service: service.to_string(),
        host: host.to_string(),
        open: false,
        latency_ms: None,
    }
}