Skip to main content

limes_common/
config.rs

1use std::env;
2
3use limes_proto::{AuthSuccess, SessionSpec};
4
5use crate::error::{LimesError, Result};
6
7#[derive(Debug, Clone, PartialEq, Eq)]
8pub struct FrontendSpec {
9    /// Executable for a login or lock frontend app.
10    pub program: String,
11    /// Extra arguments passed before `FrontendRunner` appends the mode argument.
12    pub args: Vec<String>,
13}
14
15impl FrontendSpec {
16    #[must_use]
17    pub fn external(program: impl Into<String>, args: Vec<String>) -> Self {
18        Self {
19            program: program.into(),
20            args,
21        }
22    }
23
24    #[must_use]
25    pub fn command_line(&self) -> Vec<String> {
26        let mut command = Vec::with_capacity(self.args.len() + 1);
27        command.push(self.program.clone());
28        command.extend(self.args.iter().cloned());
29        command
30    }
31}
32
33#[derive(Debug, Clone)]
34pub struct Config {
35    pub login_frontend: Option<FrontendSpec>,
36    pub lock_frontend: Option<FrontendSpec>,
37    pub session_command: Vec<String>,
38    /// Reserved configuration value; runtimes currently do not enforce it.
39    /// Configure authentication lockouts in the PAM stack instead.
40    pub max_auth_attempts: u8,
41}
42
43impl Config {
44    pub fn from_env() -> Result<Self> {
45        let login_frontend = match env::var("LIMES_LOGIN_FRONTEND") {
46            Ok(value) if value.trim().is_empty() => None,
47            Ok(value) => Some(parse_external_command(&value)?),
48            Err(_) => None,
49        };
50        let lock_frontend = match env::var("LIMES_LOCK_FRONTEND") {
51            Ok(value) if value.trim().is_empty() => None,
52            Ok(value) => Some(parse_external_command(&value)?),
53            Err(_) => None,
54        };
55        let session_command = match env::var("LIMES_SESSION_COMMAND") {
56            Ok(value) if !value.trim().is_empty() => split_words(&value),
57            _ => Vec::new(),
58        };
59        let max_auth_attempts = env::var("LIMES_MAX_AUTH_ATTEMPTS")
60            .ok()
61            .and_then(|value| value.parse::<u8>().ok())
62            .unwrap_or(3)
63            .max(1);
64
65        Ok(Self {
66            login_frontend,
67            lock_frontend,
68            session_command,
69            max_auth_attempts,
70        })
71    }
72
73    #[must_use]
74    pub fn session_spec_for(&self, success: &AuthSuccess) -> SessionSpec {
75        let command = if self.session_command.is_empty() {
76            vec![
77                success
78                    .shell
79                    .clone()
80                    .filter(|shell| !shell.trim().is_empty())
81                    .unwrap_or_else(|| "/bin/sh".to_owned()),
82            ]
83        } else {
84            self.session_command.clone()
85        };
86
87        let mut spec =
88            SessionSpec::new(success.username.clone(), success.uid, success.gid, command);
89        spec.env.push(("USER".to_owned(), success.username.clone()));
90        spec.env
91            .push(("LOGNAME".to_owned(), success.username.clone()));
92        spec.env.push(("UID".to_owned(), success.uid.to_string()));
93        spec.env.push(("GID".to_owned(), success.gid.to_string()));
94        if let Some(home) = &success.home {
95            spec.env.push(("HOME".to_owned(), home.clone()));
96            spec.env.push(("PWD".to_owned(), home.clone()));
97            spec.working_dir = Some(home.clone());
98        }
99        if let Some(shell) = &success.shell {
100            spec.env.push(("SHELL".to_owned(), shell.clone()));
101        }
102        spec.env.push((
103            "PATH".to_owned(),
104            env::var("LIMES_SESSION_PATH").unwrap_or_else(|_| {
105                "/usr/local/bin:/usr/bin:/bin:/usr/local/sbin:/usr/sbin:/sbin".to_owned()
106            }),
107        ));
108        spec
109    }
110}
111
112fn parse_external_command(value: &str) -> Result<FrontendSpec> {
113    let words = split_words(value);
114    let (program, args) = words
115        .split_first()
116        .ok_or_else(|| LimesError::Config("empty frontend command".to_owned()))?;
117    Ok(FrontendSpec::external(program.clone(), args.to_vec()))
118}
119
120/// Tiny whitespace splitter for env-provided commands.
121///
122/// Prefer constructing `FrontendSpec` in code for anything that needs quoting.
123fn split_words(value: &str) -> Vec<String> {
124    value
125        .split_whitespace()
126        .map(std::borrow::ToOwned::to_owned)
127        .collect()
128}