netchecker 0.4.0

Cross-platform internet reachability checker: probes infrastructure, DNS, and a set of domestic/global/filtered sites in parallel
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

//! HTTP site probes — the reqwest equivalent of the original `curl --resolve`.
//!
//! Two routes:
//!   * Direct: pin the pre-resolved IP so reqwest never calls the OS resolver
//!     (the anti-wedge guarantee), and do NOT follow redirects — a cross-host
//!     redirect would trigger a fresh OS lookup and reopen the wedge. A 3xx
//!     still counts as reachable.
//!   * Proxy: hand the request to the proxy, which resolves the name itself, so
//!     following redirects is safe.

use std::net::SocketAddr;
use std::time::{Duration, Instant};

use reqwest::redirect::Policy;

use crate::sites::Probe;
use crate::ui::Status;

const TIMEOUT: Duration = Duration::from_secs(2);
const HARDCAP: Duration = Duration::from_secs(3);

pub async fn check_site(probe: &Probe, internet_ok: bool, proxy: Option<&str>) -> Status {
    if !internet_ok {
        return Status::new(probe.label.clone(), false, "Skipped — no internet");
    }

    let host = probe.host();
    let via_proxy = probe.use_proxy && proxy.is_some();

    let mut builder = reqwest::Client::builder()
        .connect_timeout(TIMEOUT)
        .timeout(TIMEOUT)
        .user_agent("netchecker/0.1");

    if via_proxy {
        let proxy = proxy.unwrap();
        match reqwest::Proxy::all(proxy) {
            Ok(p) => builder = builder.proxy(p).redirect(Policy::limited(5)),
            Err(_) => {
                return Status::new(
                    probe.label.clone(),
                    false,
                    format!("Invalid proxy URL: {proxy}"),
                );
            }
        }
    } else {
        // Direct route: pin the IP, disable proxies, don't follow redirects.
        let Some(ip) = probe.ip else {
            return Status::new(
                probe.label.clone(),
                false,
                "Local DNS could not resolve host — skipped",
            );
        };
        builder = builder
            .no_proxy()
            .redirect(Policy::none())
            .resolve(host, SocketAddr::new(ip.into(), 443));
    }

    let client = match builder.build() {
        Ok(c) => c,
        Err(e) => return Status::new(probe.label.clone(), false, format!("client error: {e}")),
    };

    let start = Instant::now();
    let fut = client.head(&probe.url).send();
    let outcome = tokio::time::timeout(HARDCAP, fut).await;
    let ms = start.elapsed().as_millis();

    match outcome {
        Err(_) => Status::new(
            probe.label.clone(),
            false,
            format!("Timed out after {ms} ms"),
        ),
        Ok(Err(e)) => {
            let reason = if e.is_connect() {
                "Connection failed"
            } else if e.is_timeout() {
                "Timed out"
            } else {
                "Request failed"
            };
            Status::new(probe.label.clone(), false, format!("{reason} — {ms} ms"))
        }
        Ok(Ok(resp)) => {
            let code = resp.status().as_u16();
            if (200..400).contains(&code) {
                Status::new(probe.label.clone(), true, format!("HTTP {code} — {ms} ms"))
            } else {
                Status::new(
                    probe.label.clone(),
                    false,
                    format!("HTTP {code} (blocked/error) — {ms} ms"),
                )
            }
        }
    }
}