nmaprs 0.1.0

High-performance parallel network scanner with nmap-compatible CLI surface
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

//! `--traceroute` using system `traceroute` / `tracert`.
//!
//! Hosts are probed **concurrently** up to `min(max_parallel, 32)` to avoid spawning hundreds of
//! subprocesses at once; output is printed in **input order**.

use std::net::IpAddr;

use anyhow::Result;
use futures::stream::{self, StreamExt};
use tokio::process::Command;

/// Upper bound on simultaneous `traceroute` / `tracert` processes (each is a heavy subprocess).
const MAX_TRACEROUTE_PARALLEL: usize = 32;

async fn traceroute_one(host: IpAddr) -> (String, String) {
    #[cfg(unix)]
    {
        let mut c = Command::new("traceroute");
        c.arg("-n").arg("-q").arg("1");
        #[cfg(target_os = "linux")]
        c.arg("-w").arg("1");
        c.arg(host.to_string());
        match c.output().await {
            Ok(out) => (
                String::from_utf8_lossy(&out.stdout).into_owned(),
                String::from_utf8_lossy(&out.stderr).into_owned(),
            ),
            Err(e) => {
                tracing::warn!(error = %e, %host, "traceroute failed");
                (String::new(), String::new())
            }
        }
    }
    #[cfg(windows)]
    {
        let mut c = Command::new("tracert");
        c.arg("-d").arg("-h").arg("15").arg(host.to_string());
        match c.output().await {
            Ok(out) => (
                String::from_utf8_lossy(&out.stdout).into_owned(),
                String::from_utf8_lossy(&out.stderr).into_owned(),
            ),
            Err(e) => {
                tracing::warn!(error = %e, %host, "tracert failed");
                (String::new(), String::new())
            }
        }
    }
    #[cfg(not(any(unix, windows)))]
    {
        let _ = host;
        (String::new(), String::new())
    }
}

/// Run system traceroute for each host, **bounded parallel** (`max_parallel` clamped to
/// [`MAX_TRACEROUTE_PARALLEL`]), preserving scan output order.
pub async fn run_traceroute(hosts: &[IpAddr], max_parallel: usize) -> Result<()> {
    if hosts.is_empty() {
        return Ok(());
    }
    let cap = max_parallel.clamp(1, MAX_TRACEROUTE_PARALLEL);
    let chunks: Vec<(usize, IpAddr)> = hosts.iter().copied().enumerate().collect();
    let mut out: Vec<(usize, String, String)> = stream::iter(chunks.into_iter())
        .map(|(idx, host)| async move {
            let (stdout, stderr) = traceroute_one(host).await;
            (idx, stdout, stderr)
        })
        .buffer_unordered(cap)
        .collect()
        .await;
    out.sort_by_key(|(i, _, _)| *i);
    for (_, stdout, stderr) in out {
        print!("{stdout}");
        if !stderr.is_empty() {
            eprint!("{stderr}");
        }
    }
    Ok(())
}

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

    #[tokio::test]
    async fn traceroute_empty_is_ok() {
        run_traceroute(&[], 8).await.unwrap();
    }
}