fix: handle = syntax and some tokens

Cargo.toml

@@ -1,5 +1,7 @@
 [package]
 name = "lssh"
+description = "List host names in ssh_config(5) files"
+license = "MIT"
 version = "0.1.0"
 edition = "2024"
 

src/main.rs

@@ -11,7 +11,7 @@
 //! [ssh(1)]: <https://manpages.debian.org/testing/manpages-de/ssh.1.de.html>
 //! [ssh_config(5)]: <https://manpages.debian.org/bullseye/openssh-client/ssh_config.5.en.html>
 
-mod words;
+mod ssh;
 
 use std::{
     collections::HashSet,
@@ -25,9 +25,7 @@ use std::{
 use clap::Parser;
 use glob::glob;
 
-use crate::words::{Keyword, Words, expand};
+use crate::ssh::{SSH_SYSTEM_CONFIG, SSH_USER_CONFIG, Words, expand_inlude_args, is_host_pattern};
-
-const SYSTEM_CONFIG: &str = "/etc/ssh/ssh_config";
 
 /// List host names in ssh_config(5) files
 #[derive(Debug, Parser)]
@@ -44,8 +42,8 @@ fn main() {
         Some(path) if path == "none" => vec![],
         Some(path) => vec![path.clone()],
         None => match env::home_dir() {
-            Some(home) => vec![SYSTEM_CONFIG.into(), home.join(".ssh/config")],
+            Some(home) => vec![SSH_SYSTEM_CONFIG.into(), home.join(SSH_USER_CONFIG)],
-            None => vec![SYSTEM_CONFIG.into()],
+            None => vec![SSH_SYSTEM_CONFIG.into()],
         },
     };
 
@@ -61,7 +59,7 @@ fn main() {
             };
         }
 
-        let mut hosts = Vec::from_iter(hosts.into_iter());
+        let mut hosts = Vec::from_iter(hosts);
         hosts.sort();
         hosts
     };
@@ -94,30 +92,31 @@ fn find_hosts(filename: &Path) -> io::Result<HashSet<String>> {
         let line = buf[..n].trim();
 
         let mut words: Words<'_> = line.into();
-        let Some(Ok(directive)) = words.next() else {
+        let Some(Ok(keyword)) = words.next() else {
-            continue;
-        };
-
-        let Ok(keyword) = Keyword::try_from(directive.as_str()) else {
             continue;
         };
 
         match keyword {
-            Keyword::Include => find_hosts_in_include_directive(&mut hosts, words),
+            k if k.eq_ignore_ascii_case("include") => {
-            Keyword::Host => find_hosts_in_host_directive(&mut hosts, words),
+                find_hosts_in_include_directive(&mut hosts, words);
+            }
+            k if k.eq_ignore_ascii_case("host") => {
+                find_hosts_in_host_directive(&mut hosts, words);
+            }
+            _ => continue,
         }
     }
 }
 
 fn find_hosts_in_include_directive(hosts: &mut HashSet<String>, words: Words<'_>) {
-    for pattern in words {
+    for arg in words {
-        let Ok(pattern) = pattern else {
+        let Ok(arg) = arg else {
             // TODO: print warning
             continue;
         };
 
         // Expanding env vars before globbing is what ssh does as well.
-        let Ok(pattern) = expand(&pattern) else {
+        let Ok(pattern) = expand_inlude_args(arg) else {
             // TODO: print warning
             continue;
         };
@@ -145,18 +144,17 @@ fn find_hosts_in_include_directive(hosts: &mut HashSet<String>, words: Words<'_>
 }
 
 fn find_hosts_in_host_directive(hosts: &mut HashSet<String>, words: Words<'_>) {
-    for host in words {
+    for word in words {
-        let Ok(host) = host else {
+        let Ok(word) = word else {
             // TODO: print warning
             continue;
         };
 
-        if host.contains(['*', '?', '!', ',']) {
+        if is_host_pattern(word) {
-            // Ignore patterns (see ssh_config(5) "PATTERNS").
             continue;
         }
 
-        hosts.insert(host.into());
+        hosts.insert(word.to_string());
     }
 }
 
@@ -172,7 +170,7 @@ mod tests {
     }
 
     #[test]
-    fn test() {
+    fn find_hosts() {
         let mut hosts = HashSet::new();
         find_hosts_in_host_directive(&mut hosts, "foo.test".into());
         assert!(hosts.contains("foo.test"));

src/ssh.rs

@@ -0,0 +1,399 @@
+use std::{collections::HashMap, env, path::PathBuf, str::CharIndices, sync::OnceLock};
+
+pub const SSH_SYSTEM_CONFIG: &str = "/etc/ssh/ssh_config";
+pub const SSH_USER_CONFIG: &str = ".ssh/config";
+
+static ENV: OnceLock<Env> = OnceLock::new();
+
+#[derive(Debug, PartialEq)]
+pub struct InvalidQuotesError;
+
+#[derive(Debug, PartialEq)]
+pub enum ExpandError {
+    /// Missing closing delimiter `}`.
+    EnvMissingClosing { var: String },
+    /// The environment variable does not exist.
+    EnvNoValue { var: String },
+    /// The environment variable has not name (`${}`).
+    EnvZeroLen,
+    /// The token was invalid for the keyword.
+    TokenUnkownKey { token: char },
+    /// A token was expected, but was missing.
+    TokenInvalidFormat,
+    /// The token was valid, but is not implemented.
+    TokenNotImplemented { token: char },
+}
+
+/// Context that can expand words.
+struct Env {
+    home_dir: PathBuf,
+    vars: HashMap<String, String>,
+}
+
+/// Iterator over words in a ssh_config(5) keyword-argument pair.
+pub struct Words<'a> {
+    chars: CharIndices<'a>,
+    s: &'a str,
+    state: WordsExpect,
+}
+
+enum WordsExpect {
+    Keyword,
+    EqualsOrArgument,
+    Arguments,
+}
+
+pub fn expand_inlude_args(s: &str) -> Result<String, ExpandError> {
+    ENV.get_or_init(Env::from_env).expand_include_arg(s)
+}
+
+pub fn is_host_pattern(s: &str) -> bool {
+    s.contains(['*', '?', '!', ','])
+}
+
+impl<'a> From<&'a str> for Words<'a> {
+    fn from(s: &'a str) -> Self {
+        Self {
+            s,
+            chars: s.char_indices(),
+            state: WordsExpect::Keyword,
+        }
+    }
+}
+
+impl<'a> Iterator for Words<'a> {
+    type Item = Result<&'a str, InvalidQuotesError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        use WordsExpect as Expect;
+
+        macro_rules! word {
+            ($range:expr) => {
+                match self.state {
+                    Expect::Keyword => {
+                        self.state = Expect::EqualsOrArgument;
+                        Some(Ok(&self.s[$range]))
+                    }
+                    Expect::EqualsOrArgument | Expect::Arguments => {
+                        self.state = Expect::Arguments;
+                        Some(Ok(&self.s[$range]))
+                    }
+                }
+            };
+
+            ($range:expr; $state:ident) => {
+                match self.state {
+                    Expect::Keyword => {
+                        self.state = Expect::$state;
+                        Some(Ok(&self.s[$range]))
+                    }
+                    Expect::EqualsOrArgument | Expect::Arguments => {
+                        self.state = Expect::$state;
+                        Some(Ok(&self.s[$range]))
+                    }
+                }
+            };
+        }
+
+        let (idx, ch) = loop {
+            let (idx, ch) = self.chars.next()?;
+            match (ch, &self.state) {
+                ('=', Expect::EqualsOrArgument) => {
+                    self.state = Expect::Arguments;
+                }
+                (ch, _) if ch.is_whitespace() => {}
+                _ => break (idx, ch),
+            }
+        };
+
+        match ch {
+            '\'' | '"' => {
+                let delim = ch;
+                let start_idx = idx + 1;
+                loop {
+                    match self.chars.next() {
+                        Some((idx, ch)) if ch == delim => {
+                            return word!(start_idx..idx);
+                        }
+                        Some(_) => {}
+                        // End of words, but no closing delimiter for current word.
+                        None => return Some(Err(InvalidQuotesError)),
+                    }
+                }
+            }
+            _ => {
+                let start_idx = idx;
+                loop {
+                    match (&self.state, self.chars.next()) {
+                        (Expect::Keyword, Some((idx, '='))) => {
+                            return word!(start_idx..idx; Arguments);
+                        }
+                        (_, Some((idx, ch))) if ch.is_whitespace() => {
+                            return word!(start_idx..idx);
+                        }
+                        (_, Some(_)) => {}
+                        (_, None) => return word!(start_idx..),
+                    }
+                }
+            }
+        };
+    }
+}
+
+impl Env {
+    fn from_env() -> Self {
+        let mut vars = HashMap::new();
+        for (var, val) in env::vars_os() {
+            let Some(var) = var.to_str() else {
+                continue;
+            };
+
+            let Some(val) = val.to_str() else {
+                continue;
+            };
+
+            vars.insert(var.to_string(), val.to_string());
+        }
+
+        Self {
+            home_dir: env::home_dir().unwrap_or_else(|| PathBuf::from("~")),
+            vars,
+        }
+    }
+
+    fn home_dir_str(&self) -> &str {
+        self.home_dir.to_str().unwrap_or("~")
+    }
+
+    fn expand_include_arg(&self, arg: &str) -> Result<String, ExpandError> {
+        enum S {
+            Literal,
+            EnvVar,
+            MaybeEnvVar,
+            ExpectToken,
+        }
+
+        let mut expanded = String::new();
+        let mut state = S::Literal;
+        let mut var_start: Option<usize> = None;
+
+        for (idx, ch) in arg.char_indices() {
+            match (&state, ch) {
+                (S::Literal | S::MaybeEnvVar, '~') => {
+                    expanded.push_str(self.home_dir_str());
+                    state = S::Literal;
+                }
+                (S::Literal | S::MaybeEnvVar, '%') => state = S::ExpectToken,
+                (S::Literal, '$') => state = S::MaybeEnvVar,
+                (S::Literal, ch) => expanded.push(ch),
+                (S::MaybeEnvVar, '$') => expanded.push('$'),
+                (S::MaybeEnvVar, '{') => {
+                    state = S::EnvVar;
+                    var_start = None;
+                }
+                (S::MaybeEnvVar, ch) => {
+                    state = S::Literal;
+                    expanded.push('$');
+                    expanded.push(ch);
+                }
+                (S::EnvVar, '}') => {
+                    let Some(start) = var_start else {
+                        return Err(ExpandError::EnvZeroLen);
+                    };
+                    let var = &arg[start..idx];
+                    let Some(val) = self.vars.get(var) else {
+                        return Err(ExpandError::EnvNoValue {
+                            var: var.to_string(),
+                        });
+                    };
+
+                    if val == "~" {
+                        expanded.push_str(self.home_dir_str());
+                    } else {
+                        expanded.push_str(val);
+                    }
+
+                    state = S::Literal;
+                }
+                (S::EnvVar, _) => {
+                    if var_start.is_none() {
+                        var_start = Some(idx)
+                    }
+                }
+                (S::ExpectToken, ch) => {
+                    state = S::Literal;
+
+                    macro_rules! unimplemented_token {
+                        ($t:expr) => {{
+                            return Err(ExpandError::TokenNotImplemented { token: $t });
+                        }};
+                    }
+
+                    match ch {
+                        // A literal ‘%’.
+                        '%' => expanded.push('%'),
+                        // Hash of %l%h%p%r%j.
+                        'C' => unimplemented_token!(ch),
+                        // Local user's home directory.
+                        'd' => expanded.push_str(self.home_dir_str()),
+                        // The fingerprint of the server's host key.
+                        // ('f', _) => todo!(),
+                        // The known_hosts hostname or address that is being searched for.
+                        // ('H', _) => todo!(),
+                        // The remote hostname.
+                        'h' => unimplemented_token!(ch),
+                        // A string describing the reason for a KnownHostsCommand execution: either
+                        // ADDRESS when looking up a host by address (only when CheckHostIP is
+                        // enabled), HOSTNAME when searching by hostname, or ORDER when preparing
+                        // the host key algorithm preference list to use for the destination host.
+                        // ('I', _) => todo!(),
+                        // The local user ID.
+                        'i' => unimplemented_token!(ch),
+                        // The contents of the ProxyJump option, or the empty string if this option
+                        // is unset.
+                        'j' => unimplemented_token!(ch),
+                        // The base64 encoded host key.
+                        // ('K', _) => todo!(),
+                        // The host key alias if specified, otherwise the original remote hostname
+                        // given on the command line.
+                        'k' => unimplemented_token!(ch),
+                        // The local hostname.
+                        'L' => unimplemented_token!(ch),
+                        // The local hostname, including the domain name.
+                        'l' => unimplemented_token!(ch),
+                        // The original remote hostname, as given on the command line.
+                        'n' => unimplemented_token!(ch),
+                        // The remote port.
+                        'p' => unimplemented_token!(ch),
+                        // The remote username.
+                        'r' => unimplemented_token!(ch),
+                        // The local tun(4) or tap(4) network interface assigned if tunnel
+                        // forwarding was requested, or "NONE" otherwise.
+                        // ('T', _) => todo!(),
+                        // The type of the server host key, e.g. ssh-ed25519.
+                        // ('t', _) => todo!(),
+                        // The local username.
+                        'u' => unimplemented_token!(ch),
+                        // Unknown key %*.
+                        _ => return Err(ExpandError::TokenUnkownKey { token: ch }),
+                    }
+                }
+            }
+        }
+
+        match state {
+            S::Literal => {}
+            S::MaybeEnvVar => expanded.push('$'),
+            S::EnvVar => {
+                let start = var_start.expect("var_start must be set");
+                return Err(ExpandError::EnvMissingClosing {
+                    var: arg[start..].to_string(),
+                });
+            }
+            S::ExpectToken => {
+                return Err(ExpandError::TokenInvalidFormat);
+            }
+        }
+
+        Ok(expanded)
+    }
+}
+
+impl std::error::Error for InvalidQuotesError {}
+
+impl std::fmt::Display for InvalidQuotesError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "invalid quotes")
+    }
+}
+
+impl std::error::Error for ExpandError {}
+
+impl std::fmt::Display for ExpandError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        use ExpandError::*;
+
+        match self {
+            EnvMissingClosing { var } => {
+                write!(f, "environment variable '{var}' missing closing '}}'")
+            }
+            EnvNoValue { var } => write!(f, "env var ${{{var}}} has no value"),
+            EnvZeroLen => write!(f, "zero-length environment variable"),
+            TokenUnkownKey { token } => write!(f, "unknown key %{token}"),
+            TokenInvalidFormat => write!(f, "invalid format"),
+            TokenNotImplemented { token } => {
+                write!(f, "valid key %{token} is not implemented")
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_words() {
+        macro_rules! assert_words {
+            ($words:expr, $parsed:expr) => {
+                assert_eq!(
+                    Words::from($words).collect::<Vec<Result<_, _>>>()[..],
+                    $parsed,
+                )
+            };
+        }
+
+        assert_words!("foo bar baz", [Ok("foo"), Ok("bar"), Ok("baz")]);
+        assert_words!("foo \"bar \" ' baz'", [Ok("foo"), Ok("bar "), Ok(" baz")]);
+        assert_words!("foo 'bar\"", [Ok("foo"), Err(InvalidQuotesError)]);
+        assert_words!("foo==bar", [Ok("foo"), Ok("=bar")]);
+        assert_words!("foo '==bar'", [Ok("foo"), Ok("==bar")]);
+        assert_words!("foo='=bar'", [Ok("foo"), Ok("=bar")]);
+        assert_words!("'foo''==bar'", [Ok("foo"), Ok("==bar")]);
+    }
+
+    #[test]
+    fn expand_include_args() {
+        let env = Env {
+            home_dir: PathBuf::from("/home/jhill"),
+            vars: HashMap::from([
+                ("FOO".to_string(), "foo".to_string()),
+                ("BAR".to_string(), "bar".to_string()),
+                ("BAZ".to_string(), "baz".to_string()),
+                ("QUX".to_string(), "~".to_string()),
+            ]),
+        };
+
+        macro_rules! assert_expand {
+            ($e:expr, $expanded:expr) => {
+                assert_eq!(env.expand_include_arg($e).as_deref(), $expanded)
+            };
+        }
+
+        assert_expand!("~", Ok("/home/jhill"));
+        assert_expand!("FOO ${BAR} ${BAZ}", Ok("FOO bar baz"));
+        assert_expand!("~/${FOO}", Ok("/home/jhill/foo"));
+        assert_expand!("${QUX}/${FOO}", Ok("/home/jhill/foo"));
+
+        // Environment expansion errors.
+        // TODO: Is this emulating the ssh behaviour?
+        assert_expand!(
+            "foo ${QUUX} baz",
+            Err(&ExpandError::EnvNoValue {
+                var: "QUUX".to_string()
+            })
+        );
+        assert_expand!(
+            "foo ${BAR baz",
+            Err(&ExpandError::EnvMissingClosing {
+                var: "BAR baz".to_string()
+            })
+        );
+        assert_expand!("foo ${} baz", Err(&ExpandError::EnvZeroLen));
+
+        // Token expansion errors.
+        assert_expand!("%", Err(&ExpandError::TokenInvalidFormat));
+        assert_expand!("%Z", Err(&ExpandError::TokenUnkownKey { token: 'Z' }));
+        assert_expand!("%C", Err(&ExpandError::TokenNotImplemented { token: 'C' }));
+    }
+}

src/words.rs

@@ -1,223 +0,0 @@
-use std::{collections::HashMap, env, path::PathBuf, str::Chars, sync::OnceLock};
-
-static EXPANDER: OnceLock<Env> = OnceLock::new();
-
-/// Missing `'\''`, `'"'` or `'}'` delimiter.
-#[derive(Debug)]
-pub struct MissingDelimiter;
-
-/// Iterator over words in str.
-pub struct Words<'a> {
-    chars: Chars<'a>,
-}
-
-pub enum Keyword {
-    Host,
-    Include,
-}
-
-/// Context that can expand words.
-struct Env {
-    dir: PathBuf,
-    vars: HashMap<String, String>,
-}
-
-/// Expand env vars in the given word.
-pub fn expand(word: &str) -> Result<String, MissingDelimiter> {
-    EXPANDER.get_or_init(|| Env::from_env()).expand(word)
-}
-
-impl Iterator for Words<'_> {
-    type Item = Result<String, MissingDelimiter>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let ch = loop {
-            let ch = self.chars.next()?;
-            if !ch.is_whitespace() {
-                break ch;
-            }
-        };
-
-        let mut word = String::new();
-        match ch {
-            '\'' | '"' => {
-                let delim = ch;
-                loop {
-                    match self.chars.next() {
-                        Some(ch) if ch == delim => {
-                            return Some(Ok(word));
-                        }
-                        Some(ch) => word.push(ch),
-                        None => return Some(Err(MissingDelimiter)),
-                    }
-                }
-            }
-            ch => {
-                word.push(ch);
-                loop {
-                    match self.chars.next() {
-                        Some(ch) if ch.is_whitespace() => return Some(Ok(word)),
-                        Some(ch) => word.push(ch),
-                        None => return Some(Ok(word)),
-                    }
-                }
-            }
-        };
-    }
-}
-
-impl TryFrom<&str> for Keyword {
-    type Error = ();
-
-    fn try_from(value: &str) -> Result<Keyword, Self::Error> {
-        let keyword = match value.to_lowercase().as_str() {
-            "host" => Keyword::Host,
-            "include" => Keyword::Include,
-            _ => return Err(()),
-        };
-
-        Ok(keyword)
-    }
-}
-
-impl<'a> From<&'a str> for Words<'a> {
-    fn from(value: &'a str) -> Self {
-        Words {
-            chars: value.chars(),
-        }
-    }
-}
-
-impl Env {
-    fn from_env() -> Self {
-        let mut vars = HashMap::new();
-        for (var, val) in env::vars_os() {
-            let Some(var) = var.to_str() else {
-                continue;
-            };
-
-            let Some(val) = val.to_str() else {
-                continue;
-            };
-
-            vars.insert(var.to_string(), val.to_string());
-        }
-
-        Self {
-            dir: env::home_dir().unwrap_or_else(|| PathBuf::from("~")),
-            vars,
-        }
-    }
-
-    fn dir_str(&self) -> &str {
-        self.dir.to_str().unwrap_or("~")
-    }
-
-    fn expand(&self, word: &str) -> Result<String, MissingDelimiter> {
-        let mut chars = word.chars();
-        let mut expanded = String::new();
-
-        'outer: while let Some(ch) = chars.next() {
-            match ch {
-                '$' => {
-                    let Some(ch) = chars.next() else {
-                        expanded.push('$');
-                        break;
-                    };
-
-                    if ch != '{' {
-                        expanded.push('$');
-                        expanded.push(ch);
-                        break;
-                    }
-
-                    let mut var = String::new();
-                    while let Some(ch) = chars.next() {
-                        match ch {
-                            '}' => match self.vars.get(&var) {
-                                Some(val) if val == "~" => {
-                                    // ssh -vG indeed shows this to be true
-                                    expanded.push_str(self.dir_str());
-                                    continue 'outer;
-                                }
-                                Some(val) => {
-                                    expanded.push_str(val);
-                                    continue 'outer;
-                                }
-                                None => {
-                                    // TODO: I *think* the word must be ignored if the var is not
-                                    //       set?
-                                    expanded.push('$');
-                                    expanded.push('{');
-                                    expanded.push_str(&var);
-                                    expanded.push('}');
-                                    continue 'outer;
-                                }
-                            },
-                            ch => var.push(ch),
-                        }
-                    }
-
-                    return Err(MissingDelimiter);
-                }
-                '~' => expanded.push_str(self.dir_str()),
-                ch => expanded.push(ch),
-            }
-        }
-
-        Ok(expanded)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn words() {
-        let mut words = Words::from("foo bar baz");
-        assert_eq!(words.next().unwrap().unwrap(), "foo");
-        assert_eq!(words.next().unwrap().unwrap(), "bar");
-        assert_eq!(words.next().unwrap().unwrap(), "baz");
-        assert!(words.next().is_none());
-
-        let mut words = Words::from("foo \"bar baz\"");
-        assert_eq!(words.next().unwrap().unwrap(), "foo");
-        assert_eq!(words.next().unwrap().unwrap(), "bar baz");
-        assert!(words.next().is_none());
-
-        let mut words = Words::from("foo 'bar baz'");
-        assert_eq!(words.next().unwrap().unwrap(), "foo");
-        assert_eq!(words.next().unwrap().unwrap(), "bar baz");
-        assert!(words.next().is_none());
-
-        let mut words = Words::from("foo 'bar baz\"");
-        assert_eq!(words.next().unwrap().unwrap(), "foo");
-        assert!(words.next().unwrap().is_err());
-        assert!(words.next().is_none());
-    }
-
-    #[test]
-    fn expand() {
-        let expander = Env {
-            dir: PathBuf::from("/home/jhill"),
-            vars: HashMap::from([
-                ("FOO".to_string(), "foo".to_string()),
-                ("BAR".to_string(), "bar".to_string()),
-                ("BAZ".to_string(), "baz".to_string()),
-                ("WEIRD".to_string(), "~".to_string()),
-            ]),
-        };
-
-        assert_eq!(expander.expand("~").unwrap(), "/home/jhill");
-        assert_eq!(expander.expand("FOO ${BAR} ${BAZ}").unwrap(), "FOO bar baz");
-        assert_eq!(expander.expand("~/${FOO}").unwrap(), "/home/jhill/foo");
-        assert_eq!(
-            expander.expand("${WEIRD}/${FOO}").unwrap(),
-            "/home/jhill/foo"
-        );
-        // TODO: Is this emulating the ssh behaviour?
-        assert_eq!(expander.expand("foo ${QUX} baz").unwrap(), "foo ${QUX} baz");
-        assert!(expander.expand("foo ${BAR baz").is_err());
-    }
-}