use std::process::{Command, Stdio};
use std::sync::OnceLock;
use super::ContainerManager;
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) enum Identity {
Image,
User {
uid: u32,
gid: u32,
},
KeepId,
}
impl Identity {
pub(crate) fn user_arg(uid: u32, gid: u32) -> String {
format!("{uid}:{gid}")
}
pub(crate) fn from_parts(
engine: Option<ContainerManager>,
linux: bool,
rootless_docker: bool,
ids: Option<(u32, u32, u32)>,
) -> Identity {
let Some((uid, gid, euid)) = ids else {
return Identity::Image;
};
match engine {
Some(ContainerManager::Docker) if linux && rootless_docker => {
Identity::User { uid: 0, gid: 0 }
}
Some(ContainerManager::Docker) if linux => Identity::User { uid, gid },
Some(ContainerManager::Podman) if euid != 0 => Identity::KeepId,
_ => Identity::Image,
}
}
}
pub(crate) fn identity(engine: Option<ContainerManager>, linux: bool) -> Identity {
let rootless = engine == Some(ContainerManager::Docker) && linux && docker_is_rootless();
Identity::from_parts(engine, linux, rootless, user_ids())
}
#[cfg(unix)]
pub(crate) fn user_ids() -> Option<(u32, u32, u32)> {
Some(unsafe { (libc::getuid(), libc::getgid(), libc::geteuid()) })
}
#[cfg(not(unix))]
pub(crate) fn user_ids() -> Option<(u32, u32, u32)> {
None
}
static DOCKER_ROOTLESS: OnceLock<bool> = OnceLock::new();
pub(crate) fn docker_is_rootless() -> bool {
if let Some(known) = DOCKER_ROOTLESS.get() {
return *known;
}
match probe_docker_rootless() {
Ok(rootless) => *DOCKER_ROOTLESS.get_or_init(|| rootless),
Err(err) => {
eprintln!("[llmman] docker info did not say whether the daemon is rootless ({err}); assuming not");
false
}
}
}
fn probe_docker_rootless() -> Result<bool, String> {
let mut cmd = Command::new("docker");
cmd.args(["info", "--format", "{{json .SecurityOptions}}"])
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::null());
let mut child = cmd.spawn().map_err(|e| e.to_string())?;
match super::wait_with_timeout(&mut child, super::PROBE_TIMEOUT) {
Ok(Some(status)) if status.success() => {}
Ok(Some(status)) => return Err(format!("exited with {status}")),
Ok(None) => return Err(format!("no answer within {:?}", super::PROBE_TIMEOUT)),
Err(e) => return Err(e.to_string()),
}
let out = child.wait_with_output().map_err(|e| e.to_string())?;
Ok(String::from_utf8_lossy(&out.stdout).contains("rootless"))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn identity_follows_the_engine_and_who_runs_it() {
let ids = Some((1000, 1000, 1000));
let docker = Some(ContainerManager::Docker);
let podman = Some(ContainerManager::Podman);
assert_eq!(
Identity::from_parts(docker, true, false, ids),
Identity::User {
uid: 1000,
gid: 1000
}
);
assert_eq!(
Identity::from_parts(docker, true, true, ids),
Identity::User { uid: 0, gid: 0 }
);
assert_eq!(
Identity::from_parts(docker, false, false, ids),
Identity::Image
);
assert_eq!(
Identity::from_parts(podman, true, false, ids),
Identity::KeepId
);
assert_eq!(
Identity::from_parts(podman, true, false, Some((0, 0, 0))),
Identity::Image
);
assert_eq!(
Identity::from_parts(None, true, false, ids),
Identity::Image
);
assert_eq!(
Identity::from_parts(docker, true, false, None),
Identity::Image
);
assert_eq!(Identity::user_arg(1000, 100), "1000:100");
}
}