Fixed --known-host option on MacOS

Cargo.lock

@@ -401,7 +401,7 @@ checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rexec"
-version = "1.4.0"
+version = "1.5.1"
 dependencies = [
  "brace-expand",
  "clap",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rexec"
-version = "1.5.0"
+version = "1.5.2"
 readme = "https://github.com/house-of-vanity/rexec#readme"
 edition = "2021"
 description = "Parallel SSH executor"

src/main.rs

@@ -2,8 +2,9 @@ extern crate log;
 
 use std::fs::read_to_string;
 use std::hash::Hash;
-use std::io::{BufRead, BufReader};
+use std::io::{self, BufRead, BufReader};
 use std::net::IpAddr;
+use std::path::{Path, PathBuf};
 use std::process::{self, Command, Stdio};
 use std::sync::{Arc, Mutex};
 use std::thread;
@@ -157,28 +158,80 @@ fn shorten_hostname(hostname: &str, common_suffix: &Option<String>) -> String {
     }
 }
 
-/// Read and parse the SSH known_hosts file to extract server names
+/// Resolve the default SSH known_hosts path for the current user.
-///
+fn default_known_hosts_path() -> PathBuf {
-/// # Returns
+    let home = std::env::var_os("HOME")
-/// * `Vec<Host>` - List of hosts found in the known_hosts file
+        .map(PathBuf::from)
-fn read_known_hosts() -> Vec<Host> {
+        .filter(|path| !path.as_os_str().is_empty())
+        .unwrap_or_else(|| PathBuf::from(format!("/home/{}", whoami::username())));
+
+    home.join(".ssh").join("known_hosts")
+}
+
+fn normalize_known_host_entry(entry: &str) -> Option<String> {
+    if entry.is_empty() || entry.starts_with('|') {
+        return None;
+    }
+
+    let hostname = entry
+        .strip_prefix('[')
+        .and_then(|value| value.split_once("]:").map(|(host, _)| host))
+        .unwrap_or(entry);
+
+    if hostname.is_empty() {
+        None
+    } else {
+        Some(hostname.to_string())
+    }
+}
+
+fn parse_known_hosts(content: &str) -> Vec<Host> {
     let mut result: Vec<Host> = Vec::new();
 
-    // Read known_hosts file from the user's home directory
+    for line in content.lines() {
-    for line in read_to_string(format!("/home/{}/.ssh/known_hosts", whoami::username()))
+        let line = line.trim();
-        .unwrap()
+
-        .lines()
+        if line.is_empty() || line.starts_with('#') {
-    {
+            continue;
-        let line = line.split(" ").collect::<Vec<&str>>();
+        }
-        let hostname = line[0];
+
-        result.push(Host {
+        let mut fields = line.split_whitespace();
-            name: hostname.to_string(),
+        let first = match fields.next() {
-            ip: None,
+            Some(field) => field,
-        })
+            None => continue,
+        };
+
+        let hostnames = if first.starts_with('@') {
+            match fields.next() {
+                Some(field) => field,
+                None => continue,
+            }
+        } else {
+            first
+        };
+
+        for hostname in hostnames.split(',').filter_map(normalize_known_host_entry) {
+            result.push(Host {
+                name: hostname,
+                ip: None,
+            });
+        }
     }
+
     result
 }
 
+/// Read and parse the SSH known_hosts file to extract server names
+///
+/// # Arguments
+/// * `path` - Path to the known_hosts file
+///
+/// # Returns
+/// * `io::Result<Vec<Host>>` - List of hosts found in the known_hosts file
+fn read_known_hosts(path: &Path) -> io::Result<Vec<Host>> {
+    read_to_string(path).map(|content| parse_known_hosts(&content))
+}
+
 /// Expand a numeric range in the format [start:end] to a list of strings
 ///
 /// # Arguments
@@ -315,7 +368,7 @@ fn execute_ssh_command(
     };
 
     // Function to handle output lines with proper block management
-    let handle_output = |line: String, display_name: &str, code_only: bool| {
+    let handle_output = |line: String, display_name: &str, code_only: bool, is_stderr: bool| {
         if !code_only {
             let mut current_block = CURRENT_BLOCK.lock().unwrap();
 
@@ -338,8 +391,19 @@ fn execute_ssh_command(
                 }
             }
 
-            // Print the log line
+            // Print the log line with colored separator based on stream type
-            println!("│ {} │ {}", display_name.yellow(), line);
+            let separator = if is_stderr {
+                "│".red()
+            } else {
+                "│".green()
+            };
+            println!(
+                "{} {} {} {}",
+                separator,
+                display_name.yellow(),
+                separator,
+                line
+            );
         }
     };
 
@@ -353,7 +417,8 @@ fn execute_ssh_command(
         for line in reader.lines() {
             match line {
                 Ok(line) => {
-                    handle_output(line, &display_name_stdout, code_only_stdout);
+                    handle_output(line, &display_name_stdout, code_only_stdout, false);
+                    // false = stdout
                 }
                 Err(_) => break,
             }
@@ -370,7 +435,8 @@ fn execute_ssh_command(
         for line in reader.lines() {
             match line {
                 Ok(line) => {
-                    handle_output(line, &display_name_stderr, code_only_stderr);
+                    handle_output(line, &display_name_stderr, code_only_stderr, true);
+                    // true = stderr
                 }
                 Err(_) => break,
             }
@@ -428,8 +494,19 @@ fn main() {
     // Build the list of target hosts based on user selection method
     let hosts = if args.known_hosts {
         // Use regex pattern matching against known_hosts file
-        info!("Using ~/.ssh/known_hosts to build server list.");
+        let known_hosts_path = default_known_hosts_path();
-        let known_hosts = read_known_hosts();
+        info!("Using {} to build server list.", known_hosts_path.display());
+        let known_hosts = match read_known_hosts(&known_hosts_path) {
+            Ok(hosts) => hosts,
+            Err(e) => {
+                error!(
+                    "Failed to read known_hosts file {}: {}",
+                    known_hosts_path.display(),
+                    e
+                );
+                process::exit(1);
+            }
+        };
         let mut all_hosts = Vec::new();
         for expression in args.expression.iter() {
             let re = match Regex::new(expression) {
@@ -611,3 +688,41 @@ fn main() {
         processed = end;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_known_hosts_extracts_usable_hosts() {
+        let content = r#"
+# comment
+admin.example.com ssh-ed25519 AAAA
+web.example.com,192.0.2.10 ecdsa-sha2-nistp256 AAAA
+@cert-authority *.example.com ssh-rsa AAAA
+|1|salt|hash ssh-ed25519 AAAA
+[custom.example.com]:2222 ssh-rsa AAAA
+"#;
+
+        let hosts: Vec<_> = parse_known_hosts(content)
+            .iter()
+            .map(|host| host.name.as_str())
+            .collect();
+
+        assert_eq!(
+            hosts,
+            vec![
+                "admin.example.com",
+                "web.example.com",
+                "192.0.2.10",
+                "*.example.com",
+                "custom.example.com"
+            ]
+        );
+    }
+
+    #[test]
+    fn normalize_known_host_entry_skips_hashed_entries() {
+        assert_eq!(normalize_known_host_entry("|1|salt|hash"), None);
+    }
+}