rmux-server 0.5.0

Tokio daemon and request dispatcher for the RMUX terminal multiplexer.
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

use std::collections::HashMap;

#[cfg(not(windows))]
const CLIENT_SPAWN_ENVIRONMENT_NAMES: &[&str] = &["PATH", "SHELL"];
#[cfg(windows)]
const CLIENT_SPAWN_ENVIRONMENT_NAMES: &[&str] = &["PATH", "PATHEXT"];

pub(in crate::handler) fn client_spawn_environment(
    client_environment: Option<&HashMap<String, String>>,
) -> Option<HashMap<String, String>> {
    let client_environment = client_environment?;
    let mut spawn_environment = HashMap::new();

    for name in CLIENT_SPAWN_ENVIRONMENT_NAMES {
        if let Some((client_name, value)) = client_environment_entry(client_environment, name) {
            spawn_environment.insert(client_name.to_owned(), value.to_owned());
        }
    }

    (!spawn_environment.is_empty()).then_some(spawn_environment)
}

#[cfg(not(windows))]
fn client_environment_entry<'a>(
    client_environment: &'a HashMap<String, String>,
    name: &str,
) -> Option<(&'a str, &'a str)> {
    client_environment
        .get_key_value(name)
        .map(|(client_name, value)| (client_name.as_str(), value.as_str()))
}

#[cfg(windows)]
fn client_environment_entry<'a>(
    client_environment: &'a HashMap<String, String>,
    name: &str,
) -> Option<(&'a str, &'a str)> {
    client_environment
        .iter()
        .find(|(client_name, _)| client_name.eq_ignore_ascii_case(name))
        .map(|(client_name, value)| (client_name.as_str(), value.as_str()))
}

#[cfg(test)]
mod tests {
    use std::collections::HashMap;

    use super::client_spawn_environment;

    #[test]
    fn client_spawn_environment_keeps_path_without_leaking_arbitrary_variables() {
        let client_environment = HashMap::from([
            ("PATH".to_owned(), "/tmp/client-bin:/usr/bin".to_owned()),
            (
                "RMUX_CLIENT_ENV_SENTINEL".to_owned(),
                "from-client".to_owned(),
            ),
        ]);

        let spawn_environment =
            client_spawn_environment(Some(&client_environment)).expect("PATH is retained");

        assert_eq!(
            spawn_environment.get("PATH").map(String::as_str),
            Some("/tmp/client-bin:/usr/bin")
        );
        assert!(!spawn_environment.contains_key("RMUX_CLIENT_ENV_SENTINEL"));
    }

    #[cfg(unix)]
    #[test]
    fn client_spawn_environment_keeps_shell_for_default_shell_resolution() {
        let client_environment = HashMap::from([
            ("PATH".to_owned(), "/usr/bin:/bin".to_owned()),
            ("SHELL".to_owned(), "/usr/bin/fish".to_owned()),
        ]);

        let spawn_environment =
            client_spawn_environment(Some(&client_environment)).expect("spawn env is retained");

        assert_eq!(
            spawn_environment.get("SHELL").map(String::as_str),
            Some("/usr/bin/fish")
        );
    }

    #[test]
    fn client_spawn_environment_is_empty_without_spawn_relevant_names() {
        let client_environment = HashMap::from([(
            "RMUX_CLIENT_ENV_SENTINEL".to_owned(),
            "from-client".to_owned(),
        )]);

        assert_eq!(client_spawn_environment(Some(&client_environment)), None);
        assert_eq!(client_spawn_environment(None), None);
    }
}