load OS truststore into the existing root store

Author: kavehtehrani

src/engine/traceroute.rs

@@ -248,23 +248,18 @@ async fn run_system_traceroute(
     let dest_ip_str = destination_ip.to_string();
 
     // Determine which command to use based on OS
+    // Note: -n / -d intentionally NOT passed so the OS resolves hostnames.
     let (cmd, args): (&'static str, Vec<String>) = if cfg!(target_os = "windows") {
         (
             "tracert",
-            vec![
-                "-h".to_string(),
-                max_hops.to_string(),
-                "-d".to_string(),
-                dest.clone(),
-            ],
+            vec!["-h".to_string(), max_hops.to_string(), dest.clone()],
         )
     } else {
         (
             "traceroute",
             vec![
                 "-m".to_string(),
                 max_hops.to_string(),
-                "-n".to_string(),
                 "-q".to_string(),
                 "3".to_string(),
                 dest.clone(),
@@ -277,6 +272,15 @@ async fn run_system_traceroute(
         .context("Traceroute task failed")?
         .context("Failed to execute traceroute command")?;
 
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(anyhow::anyhow!(
+            "traceroute exited with {}: {}",
+            output.status,
+            stderr.trim()
+        ));
+    }
+
     let stdout = String::from_utf8_lossy(&output.stdout);
     let hops = parse_traceroute_output(&stdout, event_tx).await;
 
@@ -331,16 +335,19 @@ async fn parse_traceroute_output(
 }
 
 /// Parse a single hop line from traceroute output.
+///
+/// Handles three formats:
+/// - Linux/macOS with DNS:    `1  host.name (1.2.3.4)  0.5 ms 0.4 ms 0.6 ms`
+/// - Linux/macOS without DNS: `1  1.2.3.4  0.5 ms 0.4 ms 0.6 ms`
+/// - Windows with DNS:        `1  <1 ms <1 ms <1 ms  host.name [1.2.3.4]`
 fn parse_hop_line(line: &str) -> Option<TracerouteHop> {
     let parts: Vec<&str> = line.split_whitespace().collect();
     if parts.is_empty() {
         return None;
     }
 
-    // First part should be hop number
     let hop_number: u8 = parts.first()?.parse().ok()?;
 
-    // Check for timeout line (all asterisks)
     if parts.iter().skip(1).all(|p| *p == "*") {
         return Some(TracerouteHop {
             hop_number,
@@ -351,37 +358,44 @@ fn parse_hop_line(line: &str) -> Option<TracerouteHop> {
         });
     }
 
-    // Find IP address and RTT values
     let mut ip_address: Option<String> = None;
+    let mut hostname: Option<String> = None;
     let mut rtts: Vec<f64> = Vec::new();
+    let mut prev_candidate: Option<String> = None;
 
     for part in parts.iter().skip(1) {
-        // Skip "ms" markers
         if *part == "ms" {
             continue;
         }
 
-        // Try to parse as RTT (number)
-        if let Ok(rtt) = part.trim_end_matches("ms").parse::<f64>() {
+        // Numeric RTT (handles plain `0.5`, `0.5ms`, and Windows `<1`).
+        let cleaned = part.trim_start_matches('<').trim_end_matches("ms");
+        if let Ok(rtt) = cleaned.parse::<f64>() {
             rtts.push(rtt);
+            prev_candidate = None;
             continue;
         }
 
-        // Handle Windows "<1 ms" format
-        if part.starts_with('<') {
-            if let Ok(rtt) = part
-                .trim_start_matches('<')
-                .trim_end_matches("ms")
-                .parse::<f64>()
-            {
-                rtts.push(rtt);
-                continue;
+        let was_wrapped = part.starts_with('(') || part.starts_with('[');
+        let stripped = part
+            .trim_start_matches(['(', '['])
+            .trim_end_matches([')', ']']);
+
+        if stripped.parse::<IpAddr>().is_ok() {
+            if ip_address.is_none() {
+                ip_address = Some(stripped.to_string());
+                if was_wrapped {
+                    if let Some(prev) = prev_candidate.take() {
+                        if prev != stripped {
+                            hostname = Some(prev);
+                        }
+                    }
+                }
             }
-        }
-
-        // Try to parse as IP address
-        if part.parse::<IpAddr>().is_ok() || (part.contains('.') && !part.contains("ms")) {
-            ip_address = Some(part.to_string());
+            prev_candidate = None;
+        } else {
+            // Not an IP, not a number: candidate hostname for the next wrapped IP.
+            prev_candidate = Some(part.to_string());
         }
     }
 
@@ -392,8 +406,71 @@ fn parse_hop_line(line: &str) -> Option<TracerouteHop> {
     Some(TracerouteHop {
         hop_number,
         ip_address,
-        hostname: None,
+        hostname,
         rtt_ms: rtts,
         timeout: false,
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parses_linux_with_hostname() {
+        let line = " 1  host.example.com (1.2.3.4)  0.5 ms  0.4 ms  0.6 ms";
+        let hop = parse_hop_line(line).unwrap();
+        assert_eq!(hop.hop_number, 1);
+        assert_eq!(hop.ip_address.as_deref(), Some("1.2.3.4"));
+        assert_eq!(hop.hostname.as_deref(), Some("host.example.com"));
+        assert_eq!(hop.rtt_ms, vec![0.5, 0.4, 0.6]);
+        assert!(!hop.timeout);
+    }
+
+    #[test]
+    fn parses_linux_without_dns() {
+        let line = " 2  1.2.3.4  0.5 ms 0.4 ms 0.6 ms";
+        let hop = parse_hop_line(line).unwrap();
+        assert_eq!(hop.ip_address.as_deref(), Some("1.2.3.4"));
+        assert_eq!(hop.hostname, None);
+        assert_eq!(hop.rtt_ms, vec![0.5, 0.4, 0.6]);
+    }
+
+    #[test]
+    fn parses_linux_when_hostname_equals_ip() {
+        // When DNS fails, traceroute often shows `ip (ip)` with both being identical.
+        let line = " 3  10.0.0.1 (10.0.0.1)  5.2 ms 4.8 ms 5.1 ms";
+        let hop = parse_hop_line(line).unwrap();
+        assert_eq!(hop.ip_address.as_deref(), Some("10.0.0.1"));
+        assert_eq!(hop.hostname, None, "hostname should be elided when same as ip");
+    }
+
+    #[test]
+    fn parses_timeout_line() {
+        let line = " 5  * * *";
+        let hop = parse_hop_line(line).unwrap();
+        assert_eq!(hop.ip_address, None);
+        assert_eq!(hop.hostname, None);
+        assert!(hop.timeout);
+        assert!(hop.rtt_ms.is_empty());
+    }
+
+    #[test]
+    fn parses_windows_with_hostname() {
+        let line = "  1    <1 ms    <1 ms    <1 ms  router.local [192.168.1.1]";
+        let hop = parse_hop_line(line).unwrap();
+        assert_eq!(hop.ip_address.as_deref(), Some("192.168.1.1"));
+        assert_eq!(hop.hostname.as_deref(), Some("router.local"));
+        assert_eq!(hop.rtt_ms, vec![1.0, 1.0, 1.0]);
+    }
+
+    #[test]
+    fn first_ip_wins_on_multi_router_hop() {
+        // Some hops have two routers responding; we keep the first IP/hostname pair.
+        let line = " 5  a.example.com (1.1.1.1)  260.2 ms b.example.com (2.2.2.2)  260.1 ms 260.0 ms";
+        let hop = parse_hop_line(line).unwrap();
+        assert_eq!(hop.ip_address.as_deref(), Some("1.1.1.1"));
+        assert_eq!(hop.hostname.as_deref(), Some("a.example.com"));
+        assert_eq!(hop.rtt_ms.len(), 3);
+    }
+}

src/tui/mod.rs

@@ -4,6 +4,7 @@ mod export;
 mod help;
 mod history;
 mod state;
+mod traceroute;
 
 pub use state::UiState;
 
@@ -79,6 +80,8 @@ pub async fn run(args: Cli) -> Result<()> {
         .and_then(|n| n.to_str())
         .map(|s| s.to_string());
     state.proxy_url = args.proxy.clone();
+    state.traceroute_enabled = args.traceroute;
+    state.traceroute_max_hops = args.traceroute_max_hops;
 
     // Spawn background task to check for updates (non-blocking, silent on error)
     let (update_tx, mut update_rx) = tokio::sync::mpsc::channel::<Option<String>>(1);
@@ -269,6 +272,7 @@ pub async fn run(args: Cli) -> Result<()> {
                                 state.tls_summary = None;
                                 state.ip_comparison = None;
                                 state.traceroute_summary = None;
+                                state.traceroute_hops.clear();
                                 run_ctx = Some(start_run(&args).await?);
                             }
                         }
@@ -350,15 +354,17 @@ pub async fn run(args: Cli) -> Result<()> {
                         }
                         (KeyModifiers::SHIFT, KeyCode::BackTab) => {
                             // Shift+Tab cycles backwards
-                            let new_tab = if state.tab == 0 { 3 } else { state.tab - 1 };
+                            let tab_count = if state.traceroute_enabled { 5 } else { 4 };
+                            let new_tab = if state.tab == 0 { tab_count - 1 } else { state.tab - 1 };
                             state.tab = new_tab;
                             if new_tab == 1 {
                                 state.history_selected = 0;
                                 state.history_scroll_offset = 0;
                             }
                         }
                         (_, KeyCode::Tab) => {
-                            let new_tab = (state.tab + 1) % 4;
+                            let tab_count = if state.traceroute_enabled { 5 } else { 4 };
+                            let new_tab = (state.tab + 1) % tab_count;
                             state.tab = new_tab;
                             // Reset history selection when switching to history tab
                             if new_tab == 1 {
@@ -367,7 +373,7 @@ pub async fn run(args: Cli) -> Result<()> {
                             }
                         }
                         (_, KeyCode::Char('?')) => {
-                            state.tab = 3; // help
+                            state.tab = if state.traceroute_enabled { 4 } else { 3 }; // help
                         }
                         // History navigation and deletion (only when on History tab)
                         (_, KeyCode::Up) | (_, KeyCode::Char('k')) => {
@@ -885,6 +891,7 @@ fn apply_event(state: &mut UiState, ev: TestEvent) {
                 .map(|r| format!("{:.1}ms", r))
                 .unwrap_or_else(|| "*".to_string());
             state.info = format!("Traceroute hop {}: {} {}", hop_number, addr, rtt);
+            state.traceroute_hops.push(hop);
         }
         TestEvent::TracerouteComplete { summary } => {
             state.info = format!(
@@ -907,12 +914,17 @@ fn draw(area: Rect, f: &mut ratatui::Frame, state: &mut UiState) {
         .constraints([Constraint::Length(3), Constraint::Min(0)].as_ref())
         .split(area);
 
-    let tabs = Tabs::new(vec![
+    let mut tab_titles: Vec<Line> = vec![
         Line::from("Dashboard"),
         Line::from("History"),
-        Line::from("Charts"),
-        Line::from("Help"),
-    ])
+    ];
+    if state.traceroute_enabled {
+        tab_titles.push(Line::from("Traceroute"));
+    }
+    tab_titles.push(Line::from("Charts"));
+    tab_titles.push(Line::from("Help"));
+
+    let tabs = Tabs::new(tab_titles)
     .select(state.tab)
     .block(
         Block::default()
@@ -929,6 +941,9 @@ fn draw(area: Rect, f: &mut ratatui::Frame, state: &mut UiState) {
     .highlight_style(Style::default().fg(Color::Yellow));
     f.render_widget(tabs, chunks[0]);
 
+    let traceroute_idx: Option<usize> = if state.traceroute_enabled { Some(2) } else { None };
+    let charts_idx: usize = if state.traceroute_enabled { 3 } else { 2 };
+
     match state.tab {
         0 => draw_dashboard(chunks[1], f, state),
         1 => {
@@ -938,7 +953,8 @@ fn draw(area: Rect, f: &mut ratatui::Frame, state: &mut UiState) {
                 show_history(chunks[1], f, &mut *state)
             }
         }
-        2 => draw_charts(chunks[1], f, state),
+        i if Some(i) == traceroute_idx => traceroute::draw_traceroute(chunks[1], f, state),
+        i if i == charts_idx => draw_charts(chunks[1], f, state),
         _ => draw_help(chunks[1], f),
     }
 }

src/tui/state.rs

@@ -1,4 +1,4 @@
-use crate::model::{DnsSummary, IpVersionComparison, Phase, RunResult, TlsSummary, TracerouteSummary};
+use crate::model::{DnsSummary, IpVersionComparison, Phase, RunResult, TlsSummary, TracerouteHop, TracerouteSummary};
 use ratatui::{
     style::Color,
     style::Style,
@@ -89,6 +89,9 @@ pub struct UiState {
     pub tls_summary: Option<TlsSummary>,
     pub ip_comparison: Option<IpVersionComparison>,
     pub traceroute_summary: Option<TracerouteSummary>,
+    pub traceroute_enabled: bool,
+    pub traceroute_max_hops: u8,
+    pub traceroute_hops: Vec<TracerouteHop>,
     /// None = check not completed, Some(None) = on latest, Some(Some(v)) = update available
     pub update_status: Option<Option<String>>,
 }
@@ -167,6 +170,9 @@ impl Default for UiState {
             tls_summary: None,
             ip_comparison: None,
             traceroute_summary: None,
+            traceroute_enabled: false,
+            traceroute_max_hops: 30,
+            traceroute_hops: Vec::new(),
             update_status: None,
         }
     }