use crate::exec;
use std::path::Path;
use std::env;
use std::str;
pub static CONFIG_FILE: &str = "/opt/zakuro/etc/zk0.env";
pub static CONFIG_DIR: &str = "/opt/zakuro/etc";
pub static LEGACY_CONFIG_FILE: &str = "/opt/zakuro/etc/profile.d/zk0.sh";
use std::collections::HashSet;
pub fn eval(s1: &str) -> String {
evaluate_expr(s1)
}
use crate::common::print_debug;
pub fn evaluate_expr(s1: &str) -> String {
let mut output: String = String::from("");
if !s1.starts_with("'") {
for pathx in s1.split(':') {
let splits: Vec<&str> = pathx.split("/").collect();
let condition: bool = splits.len() > 1;
for varpath in splits {
if let Some('$') = varpath.chars().next() {
let _varpath = &varpath[1..];
if let Ok(s) = env::var(_varpath) {
env::set_var(_varpath, &s);
output.push_str(&s.to_string());
} else {
output.push_str((&varpath).as_ref());
}
} else if condition {
output.push_str(&format!("/{}", varpath));
} else {
output.push_str((&varpath).as_ref());
}
}
output.push(':');
}
if output.ends_with(':') {
output = output[..output.len() - 1].to_string();
}
output = output.replace("//", "/");
let string_list: Vec<&str> = output.split(":").collect();
let unique_values: HashSet<_> = string_list.into_iter().collect();
let unique_list: Vec<_> = unique_values.into_iter().collect();
output = unique_list.join(":");
} else {
output = String::from(s1);
}
output
}
pub type Assignments = Vec<(String, String)>;
pub type Rejected = Vec<(usize, String)>;
pub fn parse_config(content: &str) -> (Assignments, Rejected) {
let mut out = Vec::new();
let mut rejected = Vec::new();
for (n, raw) in content.lines().enumerate() {
let line = raw.trim();
if line.is_empty() || line.starts_with('#') {
continue;
}
let line = line.strip_prefix("export ").unwrap_or(line).trim_start();
let Some((key, value)) = line.split_once('=') else {
rejected.push((n + 1, String::new()));
continue;
};
let mut kc = key.chars();
let key_ok = matches!(kc.next(), Some(c) if c.is_ascii_alphabetic() || c == '_')
&& kc.all(|c| c.is_ascii_alphanumeric() || c == '_');
if !key_ok {
rejected.push((n + 1, String::new()));
continue;
}
let chars: Vec<char> = value.chars().collect();
let bad = chars.iter().enumerate().any(|(i, c)| {
c.is_control()
|| matches!(
c,
'`' | ';' | '&' | '|' | '<' | '>' | '(' | ')' | '{' | '}' | '\\'
)
|| (*c == '$'
&& !matches!(chars.get(i + 1), Some(d) if d.is_ascii_alphabetic() || *d == '_'))
});
if bad {
rejected.push((n + 1, key.to_string()));
continue;
}
out.push((key.to_string(), value.to_string()));
}
(out, rejected)
}
fn fetch_config_to(agent: &ureq::Agent, url: &str, path: &str) -> Result<(), String> {
let body = crate::verified_fetch::fetch_verified(agent, url)?;
std::fs::write(path, body).map_err(|e| format!("writing {}: {}", path, e))
}
pub const NO_ENV_PROFILE_VAR: &str = "ZC_NO_ENV_PROFILE";
fn dir_is_writable(dir: &str) -> bool {
std::fs::metadata(dir).is_ok_and(|m| m.is_dir() && !m.permissions().readonly())
&& tempfile_probe(dir)
}
fn tempfile_probe(dir: &str) -> bool {
let p = Path::new(dir).join(format!(".zc-write-probe-{}", std::process::id()));
let ok = std::fs::write(&p, b"").is_ok();
let _ = std::fs::remove_file(&p);
ok
}
fn may_bootstrap(dir_writable: bool, interactive: bool, opted_out: bool, macos: bool) -> bool {
!opted_out && !macos && (dir_writable || interactive)
}
#[derive(Debug, PartialEq, Eq)]
enum DirFix {
Done,
Sudo,
Skip,
}
fn dir_fix_plan(created: bool, sudo_available: bool) -> DirFix {
if created {
DirFix::Done
} else if sudo_available {
DirFix::Sudo
} else {
DirFix::Skip
}
}
fn sudo_on_path() -> bool {
env::var_os("PATH").is_some_and(|p| env::split_paths(&p).any(|d| d.join("sudo").is_file()))
}
pub fn update() {
let profile = crate::profile::active();
if !profile.legacy_env_profile && !Path::new(CONFIG_FILE).exists() {
return;
}
if !Path::new(CONFIG_FILE).exists() {
if let Ok(legacy) = std::fs::read_to_string(LEGACY_CONFIG_FILE) {
let (ok, _) = parse_config(&legacy);
let data: String = ok.iter().map(|(k, v)| format!("{}={}\n", k, v)).collect();
let _ = std::fs::write(CONFIG_FILE, data);
}
}
let dir_writable = dir_is_writable(CONFIG_DIR);
if !Path::new(CONFIG_FILE).exists()
&& !may_bootstrap(
dir_writable,
std::io::IsTerminal::is_terminal(&std::io::stdin()),
env::var_os(NO_ENV_PROFILE_VAR).is_some(),
cfg!(target_os = "macos"),
)
{
return;
}
if !Path::new(CONFIG_FILE).exists() {
if !dir_writable {
let created =
std::fs::create_dir_all(CONFIG_DIR).is_ok() && dir_is_writable(CONFIG_DIR);
match dir_fix_plan(created, sudo_on_path()) {
DirFix::Done => {}
DirFix::Sudo => {
for command in [
&format!("sudo mkdir -p {}", CONFIG_DIR),
&format!("sudo chown -R $USER {}", CONFIG_DIR),
] {
exec::tty(command);
}
}
DirFix::Skip => {
eprintln!("zc: cannot create {}; skipping the env profile", CONFIG_DIR);
return;
}
}
}
let url = format!("{}/env", profile.get_base);
let agent = ureq::Agent::new_with_config(
ureq::Agent::config_builder()
.timeout_global(Some(std::time::Duration::from_secs(30)))
.build(),
);
if let Err(e) = fetch_config_to(&agent, &url, CONFIG_FILE) {
eprintln!("Error downloading env profile: {}", e);
}
}
let content = match std::fs::read_to_string(CONFIG_FILE) {
Ok(content) => content,
Err(e) => {
eprintln!("Error reading config: {}", e);
return;
}
};
apply_script(&content);
}
fn is_invalid_cuda_mask(key: &str, value: &str) -> bool {
key == "CUDA_VISIBLE_DEVICES" && value.trim().eq_ignore_ascii_case("all")
}
fn apply_script(script_content: &str) {
let (assignments, rejected) = parse_config(script_content);
for (line, key) in rejected {
eprintln!(
"zc: ignoring line {} of {} (shell syntax or not KEY=VALUE){}",
line,
CONFIG_FILE,
if key.is_empty() {
String::new()
} else {
format!(": {}", key)
}
);
}
for (key, _value) in assignments {
if env::var(&key).is_err() {
let value = evaluate_expr(&_value);
print_debug(&format!("{}={}", key, value));
if is_invalid_cuda_mask(&key, &value) {
continue;
}
env::set_var(key, value);
}
}
}
#[cfg(test)]
mod tests {
#[test]
fn dir_fix_plan_prefers_create_then_sudo_then_skip() {
assert_eq!(dir_fix_plan(true, true), DirFix::Done);
assert_eq!(dir_fix_plan(true, false), DirFix::Done);
assert_eq!(dir_fix_plan(false, true), DirFix::Sudo);
assert_eq!(dir_fix_plan(false, false), DirFix::Skip);
}
use super::*;
#[test]
fn a_gui_or_service_zc_never_reaches_for_sudo() {
assert!(
!may_bootstrap(false, false, false, false),
"launchd/systemd/app: no tty for sudo"
);
assert!(!may_bootstrap(true, true, false, true), "never on macOS");
assert!(
!may_bootstrap(true, true, true, false),
"ZC_NO_ENV_PROFILE wins"
);
assert!(
may_bootstrap(false, true, false, false),
"a terminal on a fleet node may sudo"
);
assert!(
may_bootstrap(true, false, false, false),
"a writable dir needs no sudo"
);
}
#[test]
fn a_missing_dir_is_not_writable() {
assert!(!dir_is_writable("/nonexistent/zc-envs-test"));
let d = std::env::temp_dir();
assert!(dir_is_writable(d.to_str().unwrap()));
}
#[test]
fn profile_script_does_not_blind_cuda() {
env::remove_var("CUDA_VISIBLE_DEVICES");
apply_script("CUDA_VISIBLE_DEVICES=all\nZC_ENVS_TEST_MARKER=1\n");
assert!(env::var("CUDA_VISIBLE_DEVICES").is_err());
assert_eq!(env::var("ZC_ENVS_TEST_MARKER").as_deref(), Ok("1"));
env::remove_var("ZC_ENVS_TEST_MARKER");
}
#[test]
fn real_cuda_masks_are_kept() {
assert!(!is_invalid_cuda_mask("CUDA_VISIBLE_DEVICES", "0,1"));
assert!(!is_invalid_cuda_mask("CUDA_VISIBLE_DEVICES", "GPU-abc"));
assert!(!is_invalid_cuda_mask("NVIDIA_VISIBLE_DEVICES", "all"));
assert!(is_invalid_cuda_mask("CUDA_VISIBLE_DEVICES", "all"));
}
#[test]
fn lines_with_shell_syntax_are_rejected() {
for bad in [
"A=$(touch /tmp/x)",
"A=`id`",
"A=1; rm -rf ~",
"A=1 && id",
"A=${HOME}",
"A=$",
"A=b|c",
"A=b>c",
"not an assignment",
"1BAD=x",
"A B=x",
] {
let (ok, rej) = parse_config(bad);
assert!(ok.is_empty(), "should not apply {:?}", bad);
assert_eq!(rej.len(), 1, "should reject {:?}", bad);
}
env::remove_var("ZC_ENVS_TEST_GOOD");
env::remove_var("ZC_ENVS_TEST_BAD");
apply_script("ZC_ENVS_TEST_GOOD=1\nZC_ENVS_TEST_BAD=$(id)\n");
assert_eq!(env::var("ZC_ENVS_TEST_GOOD").as_deref(), Ok("1"));
assert!(env::var("ZC_ENVS_TEST_BAD").is_err());
env::remove_var("ZC_ENVS_TEST_GOOD");
}
#[test]
fn prod_env_body_applies_all_but_command_substitution() {
let body = "ZAKURO_HOME=$HOME/.zakuro\nZAKURO_CONTEXT=$ZAKURO_HOME/node\nZAKURO_ROOT=/opt/zakuro\nZAKURO_BIN=$ZAKURO_ROOT/bin\nPYENV=\"zak310\"\nZAK_PYTHON=/opt/miniconda/envs/$PYENV/bin\nPATH=$PATH:$ZAK_PYTHON:/usr/bin:/usr/local/bin:/usr/bin:$SPARK_HOME/bin:$SPARK_HOME/sbin:$ZAKURO_BIN\nSPARK_HOME=/opt/spark\nMASTER_HOST=\"10.13.13.2\"\nSPARK_MASTER='spark://$MASTER_HOST:$SPARK_MASTER_PORT'\nSPARK_NO_DAEMONIZE=true\nZAK_IP=$(zc wg0ip)\nSPARK_LOCAL_IP=$ZAK_IP\n";
let (ok, rej) = parse_config(body);
assert_eq!(rej, vec![(12, "ZAK_IP".to_string())]);
assert_eq!(ok.len(), 12);
assert!(ok.iter().any(|(k, _)| k == "PATH"));
assert!(ok.iter().any(|(k, _)| k == "SPARK_LOCAL_IP"));
assert!(!ok.iter().any(|(k, _)| k == "ZAK_IP"));
}
#[test]
fn plain_assignments_parse() {
let (v, rej) = parse_config("# c\n\nexport A=1\nPATH=$PATH:/opt/zakuro/bin\nB='x'\n");
assert!(rej.is_empty());
assert_eq!(v.len(), 3);
assert_eq!(v[1], ("PATH".into(), "$PATH:/opt/zakuro/bin".into()));
}
fn serve(body: &'static str, digest: String) -> String {
let server = tiny_http::Server::http("127.0.0.1:0").unwrap();
let addr = server.server_addr().to_ip().unwrap();
std::thread::spawn(move || {
if let Ok(req) = server.recv() {
let h = tiny_http::Header::from_bytes(
crate::verified_fetch::HASH_HEADER.as_bytes(),
digest.as_bytes(),
)
.unwrap();
let _ = req.respond(tiny_http::Response::from_string(body).with_header(h));
}
});
format!("http://{addr}/env")
}
fn sha(b: &str) -> String {
hex::encode(ring::digest::digest(&ring::digest::SHA256, b.as_bytes()))
}
fn agent() -> ureq::Agent {
ureq::Agent::new_with_config(ureq::Agent::config_builder().build())
}
#[test]
fn verified_body_is_written_then_only_shell_line_rejected() {
let body = "ZAKURO_ROOT=/opt/zakuro\nZAK_IP=$(zc wg0ip)\nSPARK_NO_DAEMONIZE=true\n";
let url = serve(body, sha(body));
let dir = std::env::temp_dir().join(format!("zc-envs-{}-{}", std::process::id(), line!()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("zk0.env");
fetch_config_to(&agent(), &url, path.to_str().unwrap()).unwrap();
let written = std::fs::read_to_string(&path).unwrap();
assert_eq!(written, body);
let (ok, rej) = parse_config(&written);
assert_eq!(rej, vec![(2, "ZAK_IP".to_string())]);
assert_eq!(ok.len(), 2);
}
#[test]
fn tampered_body_writes_nothing() {
let url = serve("ZAKURO_ROOT=/evil\n", sha("ZAKURO_ROOT=/opt/zakuro\n"));
let dir = std::env::temp_dir().join(format!("zc-envs-{}-{}", std::process::id(), line!()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("zk0.env");
assert!(fetch_config_to(&agent(), &url, path.to_str().unwrap()).is_err());
assert!(!path.exists());
}
#[test]
fn config_file_is_not_shell_sourced() {
assert!(!CONFIG_FILE.contains("profile.d"));
assert!(!CONFIG_DIR.contains("profile.d"));
assert!(!CONFIG_FILE.ends_with(".sh"));
}
}