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 pub program: String,
11 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 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
120fn split_words(value: &str) -> Vec<String> {
124 value
125 .split_whitespace()
126 .map(std::borrow::ToOwned::to_owned)
127 .collect()
128}